Ofertas de alojamiento 



Donativo para el sitio de elGuille

Buscar en Google y en elGuille.info:
Búsqueda personalizada

Equivalencias entre Visual Basic y Visual C# (5)

 
Publicado el 12/Ago/2007
Actualizado el 12/Ago/2007
Autor: Guillermo 'guille' Som

Aquí te muestro cómo puedes convertir algunas funciones 'típicas' de Visual Basic en el equivalente para C#, la mayoría de ellas son para manipular las cadenas o para saber si una cadena es una fecha o un número (IsNumeric y IsDate).



 

Introducción:

En realidad el código que te voy a mostrar está hecho con Visual C# 2005 y consiste en la creación de una DLL que podrás usar con tus proyectos de Visual Studio 2005 o de las versiones Express de los lenguajes de Visual Studio 2005, es decir, los basados en .NET Framework 2.0 o superior.

Esta DLL la puedes usar tanto con Visual C# 2005 como con Visual Basic 2005 (y con otros lenguajes que soporten la versión 2.0 de .NET Framework, aunque no lo he probado, "debería" funcionar).

 

¿Que funciones contiene la DLL?

A la hora de escribir esto (11 de Agosto de 2007 a las 22.42 GMT+2) estas son las funciones "equivalentes" con respecto a Visual Basic, es decir, estas funciones están presentes en Visual Basic, pero C# no las tiene, y aunque algunas son fáciles de crear otras no lo son tanto.
Aquí te muestro la relación de esas funciones y los parámetros que reciben, más abajo te muestro cómo usarlas, con ejemplos tanto para C# como para Visual Basic, aunque en VB no son necesarias, pero...

Nota:
Los tipos de datos de los argumentos así como los ejemplos de uso te los muestro para C#, ya que para Visual Basic no tiene mucho sentido usar estas funciones, porque son casi "igualicas" que las incluidas en la librería Microsoft.VisualBasic.dll

 

Función   Descripción
Asc(char c) Devuelve el valor numérico del carácter
Asc(string c) Devuelve el valor numérico del primer carácter de la cadena
Chr(int n) Devuelve el carácter que corresponder al número
ChrW(int n) Igual que Chr
Instr(int start, string s1, string s2, bool binaria) Esta función tiene 4 sobrecargas y sirve para averiguar la posición de una cadena dentro de otra.
Esta es la que recibe todos los parámetros.
start: indica la posición desde la que se iniciará la búsqueda, si no se indica se buscará desde el primer carácter.
s1: será la cadena en la que se buscará
s2: será la cadena a buscar
binaria: indicará si se hace una búsqueda binaria (diferencia mayúsculas de minúsculas), si no se indica el valor será true.
Instr(int start, string s1, string s2) Como el anterior pero siempre diferenciando mayúsculas de minúsculas
Instr(string s1, string s2, bool binaria)  
Instr(string s1, string s2)  
InStrRev(int start, string s1, string s2, bool binaria) Esta función tiene 3 sobrecargas y sirve para buscar una cadena dentro de otra, pero buscando por el final.
Los parámetros tienen el mismo significado que InStr.
InStrRev(int start, string s1, string s2)  
InStrRev(string s1, string s2)  
IsDate<T>(T fecha) Devuelve un valor bool si el parámetro es una fecha.
El parámetro es generic, por tanto se puede comparar con cualquier tipo.
IsNumeric<T>(T numero) Devuelve un valor bool si el parámetro es un número.
El parámetro es generic, por tanto se puede comparar con cualquier tipo.
En realidad se comprueba si se puede convertir a double, que a efectos prácticos sirve para cualquier tipo numérico.
Left(string s, int length) Devuelve los primeros caracteres de la cadena.
Si length es mayor que la longitud de la cadena, se devuelve la cadena completa. Y si es cero, se devuelve una cadena vacía.
Len(string s) Devuelve el número de caracteres de la cadena.
Si la cadena es nula, se devuelve cero.
Mid(string s, int start, int length) Esta función devuelve de la cadena indicada los length caracteres empezando por la posición start.
Mid(string s, int start) Si no se indica length se devuelve desde la posición start hasta el final.
Mid(ref string s1, string s2, int start, int length) Este método es un "intento" de simular la instrucción Mid de Visual Basic, la cual se usa para asignar un valor a una porción de una cadena.
Este método no devuelve un valor, sino que asigna en la primera cadena (que se indicará con ref) el contenido de la segunda, insertándola en la posición start y con el número de caracteres indicados en length.
Si no se indica length se usará la longitud de la cadena a asignar.
Si start + length es mayor que la longitud de la cadena inicial, se asignarán solo los caracteres que "quepan", es decir, no se amplía el tamaño de la cadena.
Mid(ref string s1, int start, int length, string s2) Igual que la anterior, pero con el orden de los parámetros cambiados
Mid(ref string s1, string s2, int start)  
Mid(ref string s1, int start, string s2)  
Right(string s1, int length) Devuelve los últimos caracteres de la cadena.

Nota:
Al igual que las funciones equivalentes de Visual Basic, se considera que el primer carácter de la cadena está en la posición 1.

Todas estas funciones están definidas en la clase Equivalencias y como todas ellas son estáticas (compartidas) hay que usar siempre el nombre de esa clase para acceder a ellas.

 

¿Cómo usar estas funciones?

Para usar la librería que define las funciones de "equivalencias", hay que añadir una referencia a la DLL que define las funciones y añadir la siguiente importación de espacios de nombres:

using elGuille.info.Util.Conversion;

Aquí tienes varios ejemplos de cómo usar las funciones de manipulación de cadenas:

int i, p;
char c;
string s, s1, s2;

s1 = "Hola Mundo";
s2 = "Mundo";

s = s1;
p = 2;
i = 3;
Console.Write("Mid({0}, {1}, {2}) = \"hola\" = ", s, p, i);
Equivalencias.Mid(ref s, "hola", p, i);
Console.WriteLine("'{0}'", s);

s = s1;
Console.Write("Mid({0}, {1}) = \"RADIOLA\" = ", s, p);
Equivalencias.Mid(ref s, p, "RADIOLA");
Console.WriteLine("'{0}'", s);

s = s1;
//s = "";
p = 2; // 22;
Console.Write("Mid({0}, {1}) = \"RADIOLANDO\" = ", s, p);
try
{
    Equivalencias.Mid(ref s, p, "RADIOLANDO");
    Console.WriteLine("'{0}'", s);
}
catch(Exception ex)
{
    Console.WriteLine(ex.Message);
}

s = s1;
i = Equivalencias.Len(s);
Console.WriteLine("La longitud de '{0}' es {1}", s, i);

s = "";
i = Equivalencias.Len(s);
Console.WriteLine("La longitud de '{0}' es {1}", s, i);

i = 55;
s = Equivalencias.Left(s1, i);
Console.WriteLine("Los {0} primeros caracteres de '{1}' son '{2}'", i, s1, s);

s = Equivalencias.Right(s1, i);
Console.WriteLine("Los {0} últimos caracteres de '{1}' son '{2}'", i, s1, s);

p = 3;
s = Equivalencias.Mid(s1, p, i);
Console.WriteLine("Los {0} caracteres de '{1}' desde la posición {3} son '{2}'", i, s1, s, p);

s = Equivalencias.Mid(s1, i);
Console.WriteLine("Usando Mid, los {0} primeros caracteres de '{1}' son '{2}'", i, s1, s);

i = Equivalencias.InStr(s1, s2);
Console.WriteLine("La posición de '{1}' dentro de '{2}' es {0}", i, s2, s1);

p = 5;
i = Equivalencias.InStr(p, s1, s2);
Console.WriteLine("La posición de '{1}' dentro de '{2}' empezando en {3} es {0}", i, s2, s1, p);

p = 7;
i = Equivalencias.InStr(p, s1, s2);
Console.WriteLine("La posición de '{1}' dentro de '{2}' empezando en {3} es {0}", i, s2, s1, p);

p = 1;
s2 = "HOLA";
i = Equivalencias.InStr(p, s1, s2, false);
Console.WriteLine("binaria = false");
Console.WriteLine("La posición de '{1}' dentro de '{2}' empezando en {3} es {0}", i, s2, s1, p);

i = Equivalencias.InStr(p, s1, s2);
Console.WriteLine("binaria = true");
Console.WriteLine("La posición de '{1}' dentro de '{2}' empezando en {3} es {0}", i, s2, s1, p);

c = 'C';
i = Equivalencias.Asc(c);
Console.WriteLine("El valor ASCII de {0} es {1}", c, i);

s = "Bien";
i = Equivalencias.Asc(s);
Console.WriteLine("El valor ASCII de {0} es {1}", s, i);

i = 65;
c = Equivalencias.ChrW(i);
Console.WriteLine("El valor ASCII {0} corresponde al carácter {1}", i, c);

La salida de este código es el siguiente:

Mid(Hola Mundo, 2, 3) = "hola" = 'Hhol Mundo'
Mid(Hola Mundo, 2) = "RADIOLA" = 'HRADIOLAdo'
Mid(Hola Mundo, 2) = "RADIOLANDO" = 'HRADIOLAND'
La longitud de 'Hola Mundo' es 10
La longitud de '' es 0
Los 55 primeros caracteres de 'Hola Mundo' son 'Hola Mundo'
Los 55 últimos caracteres de 'Hola Mundo' son 'Hola Mundo'
Los 55 caracteres de 'Hola Mundo' desde la posición 3 son 'la Mundo'
Usando Mid, los 55 primeros caracteres de 'Hola Mundo' son ''
La posición de 'Mundo' dentro de 'Hola Mundo' es 6
La posición de 'Mundo' dentro de 'Hola Mundo' empezando en 5 es 6
La posición de 'Mundo' dentro de 'Hola Mundo' empezando en 7 es 0
binaria = false
La posición de 'HOLA' dentro de 'Hola Mundo' empezando en 1 es 1
binaria = true
La posición de 'HOLA' dentro de 'Hola Mundo' empezando en 1 es 0
El valor ASCII de C es 67
El valor ASCII de Bien es 66
El valor ASCII 65 corresponde al carácter A

Para usar las funciones IsDate e IsNumeric he creado dos métodos para mostrar información extra.
Estos son los dos métodos y después te muestro cómo usarlos.

static void pruebaNum<T>(T numero)
{
    Console.WriteLine("Probando con '{0}'", numero);

    if(Equivalencias.IsNumeric(numero))
    {
        Console.WriteLine("El valor {0} es un número", numero);
    }
    else
    {
        Console.WriteLine("El valor {0} NO es un número", numero);
    }
}

static void pruebaFecha<T>(T fecha)
{
    Console.WriteLine("Probando con '{0}'", fecha);

    if(Equivalencias.IsDate(fecha))
    {
        Console.WriteLine("La fecha {0} es correcta", fecha);
    }
    else
    {
        Console.WriteLine("La fecha {0} NO es correcta", fecha);
    }
}

Y para usarlas, veamos ejemplos para la comprobación de las fechas (IsDate):

object o = null;
pruebaFecha(o);
// En realidad un valor nulo es convertible a fecha
// pero devuelve el 01/01/0001 00:00:00
Console.WriteLine(Convert.ToDateTime(o));


pruebaFecha("11/08/2007");
pruebaFecha("La fecha es: 11/08/2007");
pruebaFecha<object>(null);
pruebaFecha("11/Ago/2007");
pruebaFecha("08-11-07");
pruebaFecha<int>(123456);
pruebaFecha<DateTime>(new DateTime(2007,8,11));
// también sin indicar el tipo
pruebaFecha(new DateTime(2007, 8, 11, 12, 44, 00));

La salida de este código es la siguiente:

Probando con ''
La fecha  NO es correcta
01/01/0001 00:00:00
Probando con '11/08/2007'
    El tipo de fecha es: String
La fecha 11/08/2007 es correcta
Probando con 'La fecha es: 11/08/2007'
    El tipo de fecha es: String
La fecha La fecha es: 11/08/2007 NO es correcta
Probando con ''
La fecha  NO es correcta
Probando con '11/Ago/2007'
    El tipo de fecha es: String
La fecha 11/Ago/2007 es correcta
Probando con '08-11-07'
    El tipo de fecha es: String
La fecha 08-11-07 es correcta
Probando con '123456'
    El tipo de fecha es: Int32
La fecha 123456 NO es correcta
Probando con '11/08/2007 00:00:00'
    El tipo de fecha es: DateTime
La fecha 11/08/2007 00:00:00 es correcta
Probando con '11/08/2007 12:44:00'
    El tipo de fecha es: DateTime
La fecha 11/08/2007 12:44:00 es correcta

Ahora vamos a ver algunos ejemplos para la función IsNumeric:

pruebaNum(o);
Console.WriteLine(Convert.ToInt32(o));

pruebaNum("123456");
pruebaNum("123456e-10");
pruebaNum("0.123456e-10");
pruebaNum(12345.66);
pruebaNum<decimal>((decimal)123456.87654);
pruebaNum<int>(12345);
pruebaNum<ulong>((ulong)1234567890123456789);

Al ejecutar este código obtendremos esta salida:

Probando con ''
El valor  es un número
0
Probando con '123456'
    El tipo de numero es: String
El valor 123456 es un número
Probando con '123456e-10'
    El tipo de numero es: String
El valor 123456e-10 es un número
Probando con '0.123456e-10'
    El tipo de numero es: String
El valor 0.123456e-10 es un número
Probando con '12345,66'
    El tipo de numero es: Double
El valor 12345,66 es un número
Probando con '123456,87654'
    El tipo de numero es: Decimal
El valor 123456,87654 es un número
Probando con '12345'
    El tipo de numero es: Int32
El valor 12345 es un número
Probando con '1234567890123456789'
    El tipo de numero es: UInt64
El valor 1234567890123456789 es un número

 

Como puedes comprobar, al ser de tipo generic las funciones IsDate y IsNumeric, aceptan parámetros de cualquier tipo, no solo de cadenas. Esos tipos incluso pueden ser tipos que tu mismo hayas definido, aunque para que los puedan usar estas funciones debes definir ese tipo como IComparable y en las funciones de implementación de esa interfaz simplemente llamar a la clase Convert con el método adecuado. No es necesario que detectes errores, ya que la función IsNumeric o IsDate ya lo hace y tendrá en cuenta el posible error de conversión.

Si no quieres implementar la interfaz IComparable puedes crear una sobrecarga del operador de conversión de tu tipo a una cadena, de esa forma podrás usar "el tipo" indicando en la función que usarás un string como parámetro. Algo así:

// Probando con nuestros propios tipos
miTipo mt = new miTipo("123456");
// Aquí se usará el valor devuelto por
// la conversión implícita a string
pruebaNum<string>(mt);

Ese operador lo puedes definir de esta forma:

// operador para convertir implícitamente a string
public static implicit operator string(miTipo mt)
{
    return mt.Valor;
}

En este caso, devuelvo el contenido de Valor que es de tipo string, pero también podrías devolver la sobrecarga que tengas del método ToString.

 

Y esto es todo, más abajo te dejo el código fuente de la DLL así como el de los ejemplos de uso. En este caso, también está el código de ejemplo para Visual Basic, además del código de C# (que es como el mostrado en el artículo).

Nota:
En ese ZIP incluyo una versión del fichero de documentación XML de la librería que utiliza una hoja de estilos que muestra adecuadamente el contenido de los ficheros de documentación. Te aviso que al abrirlo te mostrará un mensaje de advertencia indicando que tiene código "script", si nadie lo ha modificado por el camino (para eso está la comprobación MD5) te puedes fiar del contenido, ya que esa hoja de estilos es en realidad una de las que se incluyen con Visual Studio 2005.

 

Pulsa en este link si quieres ver el código completo de la clase Equivalencias (para C#).

 

Espero que te sea de utilidad.

Nos vemos.
Guillermo

 


Espacios de nombres usados en el código de este artículo:

elGuille.info.Util.Conversion
System.Collections.Generic
 


Código de ejemplo (comprimido):

Fichero con el código de ejemplo: equivalenciasVB.zip - 26.40 KB

Contiene los tres proyectos (dos de C# y uno de VB) sin binarios, sólo el código.

(MD5 checksum: D041E7C2D9FE91BF4EA06C69F6131AF8)


 


Cosas que te pueden interesar



Mentor de
SolidQ
Most Valuable Professional
MVP de .NET (antes Visual Basic)
de octubre de 1997 a septiembre de 2015



Orador internacional de Ineta
Orador de Ineta Latam

ir al índice del Guille


Escribir un mensaje al Guille (mensaje EN elGuille.info)
Has entrado usando el host: elguille.info
Puedes verlo también en: http://mundoprogramacion.com/net/dotnet/equivalenciavbcs5.aspx