al0-e04 - equivalencias entre vb y cs funciones estandar

2012

Página 1

ENTREGA NÚMERO 04:

FUNCIONES

ESTÁNDAR

1. Introducción

2. Funciones de la DLL

3. Como usar las funciones

4. Código en Basic

5. Código en C#

6. Espacios de nombre

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).

¿Qué funciones contiene la DLL?

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

http://www.elguille.info/NET/dotnet/equivalenciavbcs3.htm#conversiones

http://www.elguille.info/NET/dotnet/equivalenciavbcs3.htm#redondeos

http://www.elguille.info/NET/dotnet/equivalenciavbcs3.htm#optional

http://www.elguille.info/NET/dotnet/equivalenciavbcs3.htm#ParamArray

http://www.elguille.info/NET/dotnet/equivalenciavbcs3.htm#parametrosReferenciaValor

2012

Página 2

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 "igualitas" 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

2012

Página 3

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 Igual que la anterior, pero con el orden de los parámetros

2012

Página 4

start, int length, string s2) 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;

2012

Página 5

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");


s = s1;

//s = "";

p = 2; // 22;

Console.Write("Mid({0}, {1}) = \"RADIOLANDO\" = ", s, p);

try

{

Equivalencias.Mid(ref s, p, "RADIOLANDO");


}

catch(Exception ex)

{

Console.WriteLine(ex.Message);

}

s = s1;

i = Equivalencias.Len(s);

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

s = "";

2012

Página 6

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;


2012

Página 7


{3} es {0}", i, s2, s1, p);

p = 1;

s2 = "HOLA";

i = Equivalencias.InStr(p, s1, s2, false);

Console.WriteLine("binaria = false");


{3} es {0}", i, s2, s1, p);


Console.WriteLine("binaria = true");


{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

2012

Página 8

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);

}

}

2012

Página 9

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));

2012

Página 10

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'


La fecha La fecha es: 11/08/2007 NO es correcta

Probando con ''

La fecha NO es correcta

Probando con '11/Ago/2007'


La fecha 11/Ago/2007 es correcta

Probando con '08-11-07'


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");

2012

Página 11

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


El tipo de numero es: String

El valor 123456 es un número

Probando con '123456e-10'


El valor 123456e-10 es un número

Probando con '0.123456e-10'


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


El tipo de numero es: Int32


Probando con '1234567890123456789'

El tipo de numero es: UInt64


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

2012

Página 12

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.

2012

Página 13

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.

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

{

2012

Página 14

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;

}

2012

Página 15

/// <summary>

/// El valor numérico ASCII de la cadena indicada

/// (se comprobará el primer carácter de la cadena)

/// </summary>


/// 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>


/// 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>


/// 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>

2012

Página 16

/// 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>


/// 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>


/// empezando por el carácter en la posición start


2012

Página 17


/// </summary>




/// </param>



/// </param>



/// </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>


/// empezando por el primer carácter



/// </summary>



/// </param>



/// </param>



/// </param>

/// <returns>



/// </returns>

static public int InStr(string cadena1, string cadena2, bool

binaria)

{

return InStr(1, cadena1, cadena2, binaria);

}

/// <summary>




/// </summary>



/// </param>



/// </param>

/// <returns>

2012

Página 18

/// 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>



/// </param>



/// </param>



/// </param>

/// <returns>



/// </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>



2012

Página 19

/// empezando por el caracter de la posición <paramref

name="start"/>


/// </summary>




/// </param>



/// </param>



/// </param>

/// <returns>



/// </returns>

static public int InStrRev(int start, string cadena1, string

cadena2)

{

return InStrRev(start, cadena1, cadena2, true);

}

/// <summary>



/// empezando por el último carácter


/// </summary>



/// </param>



/// </param>

/// <returns>



/// </returns>

static public int InStrRev(string cadena1, string cadena2)

{

return InStrRev(1, cadena1, cadena2);

}

/// <summary>

/// Devuelve los primeros caracteres de la cadena

/// </summary>


/// 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 "";

2012

Página 20

// 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>


/// 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;


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>


/// Posición de inicio (en base 1) desde donde se tomará la

cadena

/// </param>


/// 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 "";


if(length > cadena.Length - start)

{

2012

Página 21

length = cadena.Length - start + 1;

}

return cadena.Substring(start - 1, length);

}

/// <summary>

/// Devuelve los caracteres desde la posición <paramref

name="start"/>

/// </summary>



/// </param>


/// Posición desde la que se devolverá la cadena

/// </param>

/// <returns></returns>

static public string Mid(string cadena, int start)

{


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>


/// La cadena a la que se asignarán los caracteres

/// </param>


/// La cadena a poner en cadena1

/// </param>



/// </param>

/// <param name="length"></param>

static public void Mid(ref string cadena, string cadena2, int

start, int length)

{


{

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);

}

2012

Página 22

/// <summary>



/// con una longitud de <paramref name="length"/> y pone

/// el contenido de <paramref name="cadena2"/>

/// </summary>



/// </param>



/// </param>


/// El número de caracteres que se sustituirán

/// </param>



/// </param>

static public void Mid(ref string cadena, int start, int

length, string cadena2)

{

Mid(ref cadena, cadena2, start, length);

}

/// <summary>



/// y pone el contenido de <paramref name="cadena2"/>

/// </summary>



/// </param>



/// </param>



/// </param>

static public void Mid(ref string cadena, string cadena2, int

start)

{

Mid(ref cadena, start, cadena2);

}

/// <summary>



/// y pone el contenido de <paramref name="cadena2"/>

/// </summary>



/// </param>



/// </param>



/// </param>

static public void Mid(ref string cadena, int start, string

cadena2)

{

2012

Página 23

Mid(ref cadena, cadena2, start, cadena2.Length);

}

}

}

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

System.Collections.Generic

al0-e04 - equivalencias entre vb y cs funciones estandar

Documents