En este post voy a presentar las GRANDES diferencias que presenta Visual Basic y C# a la hora de manipular arreglos.
En primer lugar hay que destacar que en Visual Basic se utiliza parenteis "(" y ")" para encerrar los subíndices de un arreglo, en cambio en C# se utiliza corchetes "[" y "]", lo que realmente me complica la vida porque tengo asumido que los paréntesis se usan en las fuciones para encerrar la lista de parámetros.
Las formas en que se declaran presentan una diferencia importante, en C# es necesario "crear" el arreglo mientras que en Visual Basic es el compilador el que realiza esta tarea.
Dim numeros(10) As Integer
int[] numeros = new int[10];
Otra cuestión muy importante es que en la declaración o creación se indica el tamaño o dimensión del arreglo, este valor se supone indica cuantos elementos hay en el arreglo.
Hay que recordar que los subíndices de los arreglos en ambos lenguajes comienzan en 0 (cero), de manera que en C# se puede acceder a las posiciones 0, 1, 2, ..., 9; sin embargo en Visual Basic se puede acceder a las posiciones 0, 1, 2, ..., 9, 10 lo que agrega un elemento más al arreglo.
A continuación tenemos un ejercicio del curso de Programación .NET de Becas Control+F, en ambos lenguajes se utiliza un procediminto para mostrar el arreglo (el código está más adelante)
en C#
/// <summary>
/// Utilice la estructura de repetición For Next para inicializar los elementos
/// de un array entero de diez elementos, e imprima el arreglo en formato tabular
/// Inicialice con números pares
/// Inicialice con números impares
/// Inicialice con múltiplos de tres
/// </summary>
static void Ejercicio1()
{
Console.Clear();
Console.WriteLine("Laboratorio 3 - Ejercicio 1");
int[] numeros = new int[10];
for (int i = 0; i < 10; ++i)
{
numeros[i] = (i + 1) * 2;
}
MostrarArray("Pares ", numeros);
for (int i = 0; i < 10; ++i)
{
numeros[i] = (i + 1) * 2 - 1;
}
MostrarArray("Impares ", numeros);
for (int i = 0; i < 10; ++i)
{
numeros[i] = (i + 1) * 3;
}
MostrarArray("Multiplos de tres", numeros);
Console.ReadKey();
}
Es importante destacar que el subindice que recorre el arreglo comienza en 0 (cero) y se mantienen en el bucle mientras sea menor que 10 (diez) que resulta ser la dimensión del arreglo.
en Visual Basic
''' <summary>
''' Utilice la estructura de repetición For Next para inicializar los elementos
''' de un array entero de diez elementos, e imprima el arreglo en formato tabular
''' Inicialice con números pares
''' Inicialice con números impares
''' Inicialice con múltiplos de tres
''' </summary>
Sub Ejercicio1()
Console.Clear()
Console.WriteLine("Laboratorio 3 - Ejercicio 1")
Dim numeros(10) As Integer
Dim i As Integer
For i = 0 To 10
numeros(i) = (i + 1) * 2
Next
MostrarArray("Pares ", numeros)
For i = 0 To 10
numeros(i) = (i + 1) * 2 - 1
Next
MostrarArray("Impares ", numeros)
For i = 0 To 10
numeros(i) = (i + 1) * 3
Next
MostrarArray("Multiplos de tres", numeros)
Console.ReadKey()
End Sub
Más allá de las diferencias en la sentencia de control For ... Next del Visual Basic con el for(...; ...; ...) de C#, el código es bastante parecido.
Pero es importante destacar que el For ... Next de Visual Basic va desde el valor inicial hasta (incluido) el valor final en este caso desde 0 (cero) hasta 10 (diez) lo que resulta en 11 (once) posiciones.
Esto lo podemos solucionar bastante facil; NOS OLVIDAMOS QUE HAY UN ELEMENTO EN LA POSICIÓN 0 (CERO) y entonces manipulamos 10 (diez) elementos desde las posiciones 1 (uno) hasta la 10 (diez) como si fuese Pascal 
.
El problema lo tenemos ahora en el procedimiento que muestra el arreglo. Resulta que al utilizar una estructura FOR EACH ... NEXT de Visual Basic o foreach( ... ) de C# no se puede indicar a partir de qué elemento procesamos el arreglo, los procesa todos.
en Visual Basic
''' <summary>
''' Muestra un arreglo de enteros
''' </summary>
''' <param name="mensaje">Mensaje o rótulo a mostrar</param>
''' <param name="arreglo">arreglo de enteros</param>
Sub MostrarArray(ByVal mensaje As String, ByVal arreglo() As Integer)
Console.Write("{0}: ", mensaje)
For Each num As Integer In arreglo
Console.Write("{0,4}", num)
Next
Console.WriteLine()
End Sub
en C#
/// <summary>
/// Muestra un arreglo de enteros
/// </summary>
/// <param name="mensaje">Mensaje o rótulo a mostrar</param>
/// <param name="arreglo">arreglo de enteros</param>
static void MostrarArray(string mensaje, int[] arreglo)
{
Console.Write("{0}: ", mensaje);
foreach (int num in arreglo)
{
Console.Write("{0,4}", num);
}
Console.WriteLine();
}
Como pueden ver el código de MostrarArray (salvo las diferencias del lenguaje) es semánticamente identico, muestra todos los elementos que hay en el arreglo
El inconveniente es que al declarar en Visual Basic y en C# el tamaño del arreglo para 10 (diez) elementos, en Visual Basic nos agrega uno más.
Esto no es un error, es simplemente una cuestión que presenta el Visual Basic para mantener compatibilidad con las versiones anteriores de este lenguaje. De todos modos es muy molesto.