Equivalencias entre Visual Basic para .NET y C# (2)

Más equivalencias entre Visual Basic y C#

Publicado el 22/Jul/2006
Actualizado el 06/Ago/2006

Esta es la segunda página con equivalencias de las instrucciones entre los dos lenguajes más usados de .NET Framework: Visual Basic para .NET y C#. En la página anterior (y siguiente) puedes encontrar más equivalencias y algunas consideraciones que debes tener en cuenta a la hora de convertir código de Visual Basic a C# o viceversa.

1- Declarar variables por referencia y asignar un valor

Para declarar variables por referencia y al mismo tiempo crearla, en C# solo se puede hacer de una forma, pero en Visual Basic podemos hacerlo de dos formas, una como la de C# y la otra que es exclusiva de VB.

En C# hay que declarar la variable y asignar el valor:

StringBuilder sb = new StringBuilder();

En Visual Basic también lo podemos hacer de esa forma:

Dim sb As StringBuilder = New StringBuilder()

Pero Visual Basic permite otra que es declarando la variable directamente pero con la instrucción New:

Dim sb As New StringBuilder()

Nota:
En Visual Basic no es necesario usar los paréntesis cuando se crea un objeto, al menos si no se le pasan parámetros.

2- Arrays: declararlas, con y sin tamaño, cambiar el tamaño...

En Visual Basic, los arrays son tipos "casi" especiales, bueno, en realidad son datos como en el resto de lenguajes, pero la forma de declararlos es especial, al menos cuando ya tenemos la variable declarada (con Dim) y le queremos cambiar el tamaño o asignarle el tamaño inicial.

Veamos las equivalencias entre Visual Basic y C# a la hora de definir los arrays:

Visual Basic / C#

Declarar arrays sin indicar el tamaño

VB:

Dim nombres() As String

Dim nombres As String()

C#:

string[] nombres;

Declarar arrays con un tamaño inicial

VB:

Dim nombres(10) As String

En Visual Basic 2005 también se puede hacer:

Dim nombres(0 To 10) As String

C#:

string[] nombres = new string[11];

Hay que tener en cuenta que cuando indicamos el número de elementos de un array, en Visual Basic siempre se indica el índice superior del array, mientras que en C# lo que se indica es el número de elementos.
En el ejemplo anterior los arrays tienen 11 elementos: desde cero hasta 10.

Cambiar el tamaño de un array (después de haberlo declarado)

VB:

Dim nombres() As String

ReDim nombres(10)

C#:

string[] nombres;

nombres = new string[11];

Cambiar el tamaño de un array sin perder los datos

VB:

Dim nombres() As String

ReDim nombres(10)

ReDim Preserve nombres(25)

C#:

En las versiones 2002 y 2003 (C# 1.x)
No existe equivalencia, salvo copiando previamente el array en otro array y después volviéndolo a asignar.

En Visual Basic existe una instrucción para cambiar el tamaño de un array sin perder el contenido, (Preserve), sin embargo C# no tiene ese tipo de instrucción.
Pero desde la versión 2.0 de .NET Framework, podemos usar el método Resize de la clase Array.

Cambiar el tamaño de un array sin perder los datos (usando clases de .NET Framework 2.0)

VB:

Dim nombres(0 To 10) As String

Array.Resize(nombres, 15)

C#:

string[] nombres = new string[11];

Array.Resize(ref nombres, 15);

Aunque si estás acostumbrado a usar Visual Basic, debes saber que con Resize le indicas el nuevo tamaño del array, que será desde cero hasta uno menos del valor indicado, es decir, en VB es lo mismo:
Array.Resize(array, 15) que ReDim Preserve array(14).

Crear un array y asignarle los valores

VB:

Dim nombres() As String = New String() {"Pepe", "Juan", "Luisa"}

Dim nombres() As String = {"Pepe", "Juan", "Luisa"}

C#:

string[] nombres = new string[] {"Pepe", "Juan", "Luisa"};

string[] nombres = {"Pepe", "Juan", "Luisa"};

Nota:
En C# los arrays se cambian de tamaño usando new <tipo>[<tamaño>].
En Visual Basic solo se puede usar New <Tipo>() si no se indica el tamaño.

3- Propiedades por defecto o indizadores

En Visual Basic para .NET podemos definir una propiedad "por defecto", es decir, una propiedad de una clase que la podamos usar sin necesidad de usar el nombre. Esto mismo, en C# es lo que se conoce como indizador.

La forma de usar estas "propiedades" es como si estuviésemos accediendo a un array, por ejemplo, los controles de tipo lista, tienen una propiedad llamada Items que se usa para acceder a los elementos de esa lista, esa propiedad (o colección) tiene una propiedad por defecto, llamada Item, que al menos desde Visual Basic se puede acceder usando ese nombre o sin usarla. Sin embargo en C# esa propiedad Item no existe, sino que es el "indizador".
La forma de usar esa propiedad por defecto o indizador será:
En VB: variable = lista.Items(10).ToString o también con: lista.Items.Item(10).ToString
En C#: variable = lista[10].ToString();

Para definir este tipo de propiedades en nuestras clases con Visual Basic, tendremos que definir una propiedad con el modificador Default, mientras que en C# ese tipo de propiedad se define usando como nombre "this".

Visual Basic

Default Public Property Item(ByVal index As Integer) As Integer
    Get
        ...
    End Get
    Set(ByVal value As Integer)
        ...
    End Set
End Property
 
Default Public Property Item(ByVal index As Integer, ByVal tipo As Integer) As Integer
    Get
        ...
    End Get
    Set(ByVal value As Integer)
        ...
    End Set
End Property

public int this[int index]
{
    get { ... }
    set { ... }
}
public int this[int index, int tipo]
{
    get { ... }
    set { ... }
}

Es importante que sepas que este tipo de propiedades siempre debe tener como mínimo un parámetro, si no tiene parámetro el compilador dará error, por tanto, en Visual Basic ese parámetro no se puede declarar como Optional.

También se pueden crear sobrecargas de las propiedades por defecto (o indizadores), e incluso el o los parámetros pueden ser de distinto tipo, al igual que el valor devuelto, es decir, la sobrecarga funciona como de costumbre.

Nota:
En Visual Basic las propiedades pueden tener parámetros y no tienen porqué ser propiedades por defecto, para que la propiedad en realidad sea una propiedad por defecto hay que usar la instrucción Default.
En C# no se pueden definir propiedades que reciban parámetros, salvo en el caso mostrado del indizador.

4- Constructores y destructores

Los constructores en Visual Basic se definen como métodos de tipo Sub que se llaman New.
En C# los constructores se definen también como métodos, pero usando el mismo nombre de la clase.

Public Class Prueba
    Public Sub New()
        ...
    End Sub
End Class

public class Prueba
{
    public Prueba()
    {
        ...
    }
}

Los constructores permiten parámetros y por tanto pueden crearse con sobrecarga.
Si no se define un constructor, los compiladores se encargarán de hacerlo, pero será uno sin parámetros.
Si definimos un constructor con parámetros, y no definimos el que no tiene parámetros, solo podremos crear nuevas clases usando los constructores que hayamos definido.
Si queremos que además de constructores con parámetros, nuestra clase también tenga uno sin parámetros, debemos definirlo nosotros, aunque no escribamos código dentro.

Nota:
Si un constructor lo definimos como privado, no se podrán crear nuevas instancias de esa clase, por tanto, esa clase debería definir métodos y propiedades compartidas (o estáticas), de forma que podamos acceder a ellas sin necesidad de tener que crear un nuevo objeto.

En Visual Basic lo podemos hacer usando la instrucción Shared en cada miembro a compartir. O bien definiendo esos métodos en un Module, ya que de los módulos no se pueden crear nuevas instancias.

En C# indicaremos cada uno de los miembros compartidos con la isntrucción static.

En C# 2.0 podemos definir la clase como static, de esa forma, además de "obligarnos" a que todos los miembros también sean estáticos (o compartidos), no podremos usar esa clase para crear nuevas instancias.

Los destructores, en C# se definen con el nombre de la clase pero precedida del signo ~
En Visual Basic no hay destructor, al menos no como instrucción, ya que si queremos implementar uno, lo que tenemos que hacer es redefinir o sobrecargar el método Finalize.
En C#, el destructor en realidad hace una llamada al método Finalize de la clase base (o de Object si no está derivada).

La recomendación es definir un método Dispose para que se encargue de la finalización del objeto, sobre todo si nuestra clase va a usar recursos o si queremos que esa clase se use por medio de la instrucción using (Using en Visual Basic 2005).
Aunque en ese caso, se debe implementar ese método por medio de la interfaz IDisposable.

5- Llamar a otro constructor desde un constructor (incluso al de la clase base)

Desde un constructor podemos llamar a otro constructor, pero la forma de hacerlo será diferente dependiendo de si lo hacemos en Visual Basic o en C#.

En Visual Basic simplemente usaremos New e indicaremos los parámetros a pasar (o ninguno), también podemos usar Me.New, que es más recomendable, por aquello de que facilita la lectura.
Esa llamada se hará dentro de la definición del método:

Public Sub New(ByVal valor As Integer)
    Me.New()
End Sub

En C# para llamar a otro constructor de la misma clase hay que usar la instrucción this en la que indicaremos la sobrecarga que queremos utilizar.
Pero esa llamada se hará después de la definición del constructor, separándolo con dos puntos y NO debe estar dentro de las llaves que define el constructor:

public Prueba(int valor) : this()
{
}

Por supuesto si al constructor que queremos llamar tiene parámetros, esos argumentos debemos también indicarlos entre los paréntesis, esto es lo habitual, ya que en realidad son "casi" como métodos que no devuelven valores.

El constructor que llamemos puede ser de los definidos en la propia clase o bien uno que esté definido en la clase base.
En el caso de que sea al de la clase base, en Visual Basic usaremos MyBase.New y en C# usaremos la instrucción base.
Esa llamada se hará en el mismo sitio que para llamar a los constructores definidos en la propia clase, es decir, en Visual Basic se hará dentro del procedimiento y en C# después de la declaración del constructor y separándolo con dos puntos.

Public Sub New(ByVal valor As Integer, valor2 As Integer)
    MyBase.New(valor)
End Sub

public Prueba2(int valor, int valor2) : base(valor)
{
}

- Equivalencias VB / C#