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