Ofertas de alojamiento 



Donativo para el sitio de elGuille

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

La clase Equivalencias

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

La clase Equivalencias, con las funciones de conversión y manipulación de cadenas para Visual C# 2005 (o superior) compatibles con las de Visual Basic.



 

Introducción:

Aquí tienes el código de la clase Equivalencias con algunas funciones propias de Visual Basic para poder usarlas desde Visual C# 2005 o superior.

Si quieres ver cómo usarlas y bajarte el código fuente, debes ir a la página de Equivalencias entre Visual Basic y Visual C# (5).

 


Código para C Sharp (C#) El código para C# (versión 2.0 o superior)
using System;
using System.Collections.Generic;

namespace elGuille.info.Util.Conversion
{
    /// <summary>
    /// Funciones con equivalencias de VB a C#
    /// </summary>
    static public class Equivalencias
    {
        /// <summary>
        /// Comprueba si el parámetro es de tipo DateTime
        /// </summary>
        /// <typeparam name="T">
        /// El tipo de datos a comprobar
        /// </typeparam>
        /// <param name="fecha">
        /// El valor a comprobar si es una fecha válida
        /// </param>
        /// <returns>
        /// Un valor verdadero o falso según el parámetro sea una fecha
        /// </returns>
        static public bool IsDate<T>(T fecha) //where T: IConvertible
        {
            // Si no queremos aceptar como válido un valor nulo
            // ya que Convert.ToDateTime devolverá DateTime.MinValue
            // cuando el parámetro es null
            if(fecha == null)
            {
                return false;
            }
#if DEBUG
            Console.WriteLine("    El tipo de fecha es: {0}", fecha.GetType().Name);
#endif

            // Aportación de Harvey Triana con fecha 11/Ago/2007
            // en el grupo de noticias microsoft.public.es.csharp
            if(fecha is DateTime)
            {
                return true;
            }

            try
            {
                DateTime fecha1 = Convert.ToDateTime(fecha);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Comprueba si el parámetro es un número
        /// </summary>
        /// <typeparam name="T">
        /// El tipo de datos a comprobar
        /// </typeparam>
        /// <param name="numero">
        /// El valor a comprobar si es un número
        /// </param>
        /// <returns>
        /// Un valor verdadero o falso según el parámetro sea un número,
        /// en realidad se comprueba si es convertible a Double.
        /// </returns>
        static public bool IsNumeric<T>(T numero) //where T : IConvertible
        {
            // Si es un valor nulo, devolver directamente true
            if(numero == null)
            {
                return true;
            }
#if DEBUG
            Console.WriteLine("    El tipo de numero es: {0}", numero.GetType().Name);
#endif
            // Salvo excepciones, todos los números se pueden convertir a Double
            try
            {
                double num = Convert.ToDouble(numero);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// El valor numérico ASCII del carácter indicado
        /// </summary>
        /// <param name="valor">
        /// El valor de tipo Char a convertir en número ASCII
        /// </param>
        /// <returns>
        /// El valor entero del carácter indicado
        /// </returns>
        static public int Asc(char valor)
        {
            return (int)valor;
        }

        /// <summary>
        /// El valor numérico ASCII de la cadena indicada
        /// (se comprobará el primer carácter de la cadena)
        /// </summary>
        /// <param name="valor">
        /// El valor de tipo String a convertir a número ASCII
        /// </param>
        /// <returns>
        /// El valor entero del primer carácter de la cadena indicada
        /// </returns>
        static public int Asc(string valor)
        {
            if( string.IsNullOrEmpty(valor) || valor.Length < 1) 
                return 0;

            return (int)valor[0];
        }

        /// <summary>
        /// Convierte un número en un Char
        /// </summary>
        /// <param name="valor">
        /// El valor numérico a convertir
        /// </param>
        /// <returns>
        /// El valor de tipo Char del número indicado
        /// </returns>
        static public char ChrW(int valor)
        {
            return (char)valor;
        }

        /// <summary>
        /// Convierte un número en un Char
        /// </summary>
        /// <param name="valor">
        /// El valor numérico a convertir
        /// </param>
        /// <returns>
        /// El valor de tipo Char del número indicado
        /// </returns>
        static public char Chr(int valor)
        {
            return (char)valor;
        }

        //---------------------------------------------------------------------
        // Funciones de manipulación de cadenas
        //---------------------------------------------------------------------

        /// <summary>
        /// Devuelve la longitud de <paramref name="cadena"/>
        /// (si es un valor nulo devolverá cero)
        /// </summary>
        /// <param name="cadena">
        /// La cadena de la que se quiere averiguar el tamaño
        /// </param>
        /// <returns>
        /// La cantidad de caracteres de la cadena o cero si es nulo
        /// </returns>
        static public int Len(string cadena)
        {
            if(string.IsNullOrEmpty(cadena))
                return 0;
            return cadena.Length;
        }

        /// <summary>
        /// Devuelve la posición de la cadena2 en cadena1
        /// empezando por el carácter en la posición start
        /// (por compatibilidad con Visual Basic,
        /// la posición del primer carácter se considera que es 1)
        /// </summary>
        /// <param name="start">
        /// La posición del carácter (en base 1)
        /// a partir del que se comprobará
        /// </param>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <param name="binaria">
        /// True si se diferencian las mayúsculas de minúsculas
        /// </param>
        /// <returns>
        /// Devuelve la posición de cadena2 en cadena1.
        /// Si la cadena no existe devuelve cero
        /// </returns>
        static public int InStr(int start, string cadena1, string cadena2, bool binaria)
        {
            if(string.IsNullOrEmpty(cadena1) ||
                string.IsNullOrEmpty(cadena2) ||
                start > cadena1.Length)
            {
                return 0;
            }
            // Restar uno a la posición y usar cero si es menor de cero
            if(--start < 0)
                start = 0;

            if(binaria)
            {
                return cadena1.IndexOf(cadena2, start) + 1;
            }
            else
            {
                return cadena1.IndexOf(cadena2, start, 
                    StringComparison.CurrentCultureIgnoreCase) + 1;
            }
        }

        /// <summary>
        /// Devuelve la posición de la cadena2 en cadena1
        /// empezando por el carácter en la posición start
        /// (por compatibilidad con Visual Basic,
        /// la posición del primer carácter se considera que es 1)
        /// </summary>
        /// <param name="start">
        /// La posición del carácter (en base 1)
        /// a partir del que se comprobará
        /// </param>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <returns>
        /// Devuelve la posición con índice 1 de cadena2 dentro de cadena1,
        /// comprobando desde el carácter de la posición start.
        /// Si no está, devolverá cero.
        /// </returns>
        static public int InStr(int start, string cadena1, string cadena2)
        {
            return InStr(start, cadena1, cadena2, true);
        }

        /// <summary>
        /// Devuelve la posición de la cadena2 en cadena1
        /// empezando por el primer carácter
        /// (por compatibilidad con Visual Basic,
        /// la posición del primer carácter se considera que es 1)
        /// </summary>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <param name="binaria">
        /// True si se diferencian las mayúsculas de minúsculas
        /// </param>
        /// <returns>
        /// Devuelve la posición de cadena2 en cadena1.
        /// Si la cadena no existe devuelve cero
        /// </returns>
        static public int InStr(string cadena1, string cadena2, bool binaria)
        {
            return InStr(1, cadena1, cadena2, binaria);
        }

        /// <summary>
        /// Devuelve la posición de la cadena2 en cadena1
        /// (por compatibilidad con Visual Basic,
        /// la posición del primer carácter se considera que es 1)
        /// </summary>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <returns>
        /// Devuelve la posición con índice 1 de cadena2 dentro de cadena1.
        /// Si no está, devolverá cero.
        /// </returns>
        static public int InStr(string cadena1, string cadena2)
        {
            return InStr(1, cadena1, cadena2);
        }

        /// <summary>
        /// Devuelve la posición de <paramref name="cadena2"/>
        /// dentro de <paramref name="cadena1"/>
        /// empezando por el caracter de la posición <paramref name="start"/>
        /// (se comprueba desde el final de la cadena)
        /// </summary>
        /// <param name="start">
        /// La posición del carácter (en base 1)
        /// a partir del que se comprobará
        /// </param>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <param name="binaria">
        /// True si se diferencian las mayúsculas de minúsculas
        /// </param>
        /// <returns>
        /// Devuelve la posición de cadena2 en cadena1.
        /// Si la cadena no existe devuelve cero
        /// </returns>
        static public int InStrRev(int start, string cadena1, string cadena2, bool binaria)
        {
            if(string.IsNullOrEmpty(cadena1) ||
                string.IsNullOrEmpty(cadena2) ||
                start > cadena1.Length)
            {
                return 0;
            }
            // Restar uno a la posición y usar cero si es menor de cero
            if(--start < 0)
                start = 0;
            // Si se hace comparación binaria o no
            if(binaria)
            {
                return cadena1.LastIndexOf(cadena2, start) + 1;
            }
            else
            {
                return cadena1.LastIndexOf(cadena2, start, 
                    StringComparison.CurrentCultureIgnoreCase) + 1;
            }
        }

        /// <summary>
        /// Devuelve la posición de <paramref name="cadena2"/>
        /// dentro de <paramref name="cadena1"/>
        /// empezando por el caracter de la posición <paramref name="start"/>
        /// (se comprueba desde el final de la cadena)
        /// </summary>
        /// <param name="start">
        /// La posición del carácter (en base 1)
        /// a partir del que se comprobará
        /// </param>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <returns>
        /// Devuelve la posición de cadena2 en cadena1.
        /// Si la cadena no existe devuelve cero
        /// </returns>
        static public int InStrRev(int start, string cadena1, string cadena2)
        {
            return InStrRev(start, cadena1, cadena2, true);
        }

        /// <summary>
        /// Devuelve la posición de <paramref name="cadena2"/>
        /// dentro de <paramref name="cadena1"/>
        /// empezando por el último carácter
        /// (se comprueba desde el final de la cadena)
        /// </summary>
        /// <param name="cadena1">
        /// La cadena en la que se hará la búsqueda
        /// </param>
        /// <param name="cadena2">
        /// La cadena que queremos comprobar si está en la primera
        /// </param>
        /// <returns>
        /// Devuelve la posición de cadena2 en cadena1.
        /// Si la cadena no existe devuelve cero
        /// </returns>
        static public int InStrRev(string cadena1, string cadena2)
        {
            return InStrRev(1, cadena1, cadena2);
        }

        /// <summary>
        /// Devuelve los primeros caracteres de la cadena
        /// </summary>
        /// <param name="cadena">
        /// La cadena de la que se obtendrán los caracteres
        /// </param>
        /// <param name="length">
        /// El total de caracteres a devolver
        /// </param>
        /// <returns>
        /// Devuelve una cadena con los primeros length caracteres
        /// </returns>
        static public string Left(string cadena, int length)
        {
            if(string.IsNullOrEmpty(cadena) || length < 1)
                return "";

            // Comprobar que no nos pasamos
            if(length > cadena.Length)
            {
                length = cadena.Length;
            }
            return cadena.Substring(0, length);
        }

        /// <summary>
        /// Devuelve los últimos <paramref name="length"/> caracteres de la cadena
        /// </summary>
        /// <param name="cadena">
        /// La cadena de la que se obtendrán los caracteres
        /// </param>
        /// <param name="length">
        /// El total de caracteres a devolver
        /// </param>
        /// <returns>
        /// Devuelve una cadena con los últimos length caracteres
        /// </returns>
        static public string Right(string cadena, int length)
        {
            if(string.IsNullOrEmpty(cadena) || length < 1)
                return "";

            int n = cadena.Length;
            // Comprobar que no nos pasamos
            if(length > n)
            {
                length = n;
            }
            return cadena.Substring(n - length, length);
        }

        /// <summary>
        /// Devuelve <paramref name="length"/> caracteres de la cadena indicada 
        /// empezando por el carácter de la posición <paramref name="start"/>
        /// </summary>
        /// <param name="cadena">
        /// La cadena de la que se obtendrán los caracteres
        /// </param>
        /// <param name="start">
        /// Posición de inicio (en base 1) desde donde se tomará la cadena
        /// </param>
        /// <param name="length">
        /// Número de caracteres que se devolverán
        /// </param>
        /// <returns></returns>
        static public string Mid(string cadena, int start, int length)
        {
            if(string.IsNullOrEmpty(cadena) || length < 1 || start > cadena.Length)
                return "";
            // Comprobar que no nos pasamos
            if(length > cadena.Length - start)
            {
                length = cadena.Length - start + 1;
            }
            return cadena.Substring(start - 1, length);
        }

        /// <summary>
        /// Devuelve los caracteres desde la posición <paramref name="start"/>
        /// </summary>
        /// <param name="cadena">
        /// La cadena de la que se obtendrán los caracteres
        /// </param>
        /// <param name="start">
        /// Posición desde la que se devolverá la cadena
        /// </param>
        /// <returns></returns>
        static public string Mid(string cadena, int start)
        {
            if(string.IsNullOrEmpty(cadena))
                return "";

            return Mid(cadena, start, cadena.Length);
        }

        /// <summary>
        /// Sustituye en <paramref name="cadena"/> 
        /// los caracteres indicados desde <paramref name="start"/>
        /// con una longitud de <paramref name="length"/> y pone
        /// el contenido de <paramref name="cadena2"/>
        /// </summary>
        /// <param name="cadena">
        /// La cadena a la que se asignarán los caracteres
        /// </param>
        /// <param name="cadena2">
        /// La cadena a poner en cadena1
        /// </param>
        /// <param name="start">
        /// Posición desde la que se devolverá la cadena
        /// </param>
        /// <param name="length"></param>
        static public void Mid(ref string cadena, string cadena2, int start, int length)
        {
            if(string.IsNullOrEmpty(cadena))
            {
                throw new ArgumentNullException("cadena", 
                        "La cadena de destino no puede tener un valor nulo.");
            }
            int n = cadena.Length;
            if(start >= n)
            {
                throw new ArgumentOutOfRangeException("start", 
                        "La posición de inicio debe estar dentro de la cadena original.");
            }
            cadena = Left(Left(cadena, start - 1) + 
                     Left(cadena2, length) + Mid(cadena, start + length), n);
        }

        /// <summary>
        /// Sustituye en <paramref name="cadena"/> 
        /// los caracteres indicados desde <paramref name="start"/>
        /// con una longitud de <paramref name="length"/> y pone
        /// el contenido de <paramref name="cadena2"/>
        /// </summary>
        /// <param name="cadena">
        /// La cadena a la que se asignarán los caracteres
        /// </param>
        /// <param name="start">
        /// Posición desde la que se devolverá la cadena
        /// </param>
        /// <param name="length">
        /// El número de caracteres que se sustituirán
        /// </param>
        /// <param name="cadena2">
        /// La cadena a poner en cadena1
        /// </param>
        static public void Mid(ref string cadena, int start, int length, string cadena2)
        {
            Mid(ref cadena, cadena2, start, length);
        }

        /// <summary>
        /// Sustituye en <paramref name="cadena"/> 
        /// los caracteres indicados desde <paramref name="start"/>
        /// y pone el contenido de <paramref name="cadena2"/>
        /// </summary>
        /// <param name="cadena">
        /// La cadena a la que se asignarán los caracteres
        /// </param>
        /// <param name="cadena2">
        /// La cadena a poner en cadena1
        /// </param>
        /// <param name="start">
        /// Posición desde la que se devolverá la cadena
        /// </param>
        static public void Mid(ref string cadena, string cadena2, int start)
        {
            Mid(ref cadena, start, cadena2);
        }

        /// <summary>
        /// Sustituye en <paramref name="cadena"/> 
        /// los caracteres indicados desde <paramref name="start"/>
        /// y pone el contenido de <paramref name="cadena2"/>
        /// </summary>
        /// <param name="cadena">
        /// La cadena a la que se asignarán los caracteres
        /// </param>
        /// <param name="start">
        /// Posición desde la que se devolverá la cadena
        /// </param>
        /// <param name="cadena2">
        /// La cadena a poner en cadena1
        /// </param>
        static public void Mid(ref string cadena, int start, string cadena2)
        {
            Mid(ref cadena, cadena2, start, cadena2.Length);
        }
    }
}

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

System.Collections.Generic
 



 


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_equivalencias.aspx