Te pongo el pseudocódigo de lo que podría ser la estructura de una pila. Tu luego lo transformas a código NET, y después creas la interfaz para usarla...

Es mejor separar siempre que sea posible, el objeto que se crea de la operatoria que haga el cliente con ese objeto.

Entonces crea un nuevo proyecto, llámale  como quieras, luego añade una clase y llámala Pîla


Éste pseudocódigo es un sencillo código pero completo para una pila. Incluso contiene dos métodos para consultar el estado de la pila (estaLlena y EstaVacia), que no son imprescindibles, pero internamente las vamos a usar, así que por que no hacerlos públicos...

Cómo usarla ?:
La pila es limitada, al valor que se le indica cuando se contruye una instancia de la clase. Es decir, tú puedes hacer uso de la pila por ejemplo desde una ventana o desde otra clase, lo mejor para probarlo es crear unos botones en un formulario y unas cajas de texto, los botones podrían ser 'crear()', Meter(), Sacar:  (los paréntesis en Crear y Meter, indican que requieren un parámetro que podría tomarlo de una caja de texto asociado a dicho botón.

Crear una instancia de la pil:

Esta pila tiene varias limitaciones, no solo la cantidad de elemntos que puede contener (las pilas en general se diseñan para contener pequeñas cantidades, no cientos de millones, rara vez se necesitará un pila muy grande, un ejemplo de esas excepciones son precisamente los programas compiladores.
Bueno, otra limitación de esta pila es que la hemos limitado al tipo de datos entero. como es un proyecto de prueba, es suficiente, pero podrías hacerla de cualquier tipo incluso para admitir cualquier tipo...

Una Pila, es una estructura para guardar elementos y luego obtenerlos en orden inverso a como se metieron, es decir, la forma lógica de verlo, es imaginandose poner un libro en el suelo y lueo otro encima y luego otro y luego otro... esto es: "apilar libros"... directamente solo puedes coger el último, el que está arriba en  la cima, para coger otro más abajo, debes primero retirar los que tienes encima. Las pilas, por esto mismo se usan en casos donde se requiere precisamente mantener ese orden (inverso al que se ha metido).

Apilar datos:

Probar los métodos y propiedades:

Retirar datos:

etc....

Si tienes alguna duda, pregunta...

p.d.: no te conformes con ejecutar el proyecto a "saco" (F5, run), si no paso a paso (F11, debug... no recuerdo si en C# es también esa tecla F11 )

Lo siento, pero todos esos 'millones' que tú dices es insignificancia... Se pueden gestionar ficheros de hasta gigabytes de tamaño con cierta soltura.

Split, está pensado para cadenas de texto pequeñas, si tienes que manejar archivos muy grandes entonces hay que trabajar a un nivel mucho más bajo, manipulando bytes, aunque tampoco hace falta llegar al ensamblador.

...pero es que ni siquiera te has molestado en explicar si tus datos tienen o no un formato fijo y estricto, ni mucho menos el formato del 'fichero gigante' que dices tener... Pero tú mismo, si no quieres hacerlo eficiente, es cosa tuya... Perder el tren por llegar tarde es una cosa, perderlo por orgullo, es tontería.

No. La base puedes considerarlo la parte común a todos los lenguajes e independiente de ellos. Toca un poco todos los palos.
Y basta que sea a nivel conceptual, aunque al menos la parte matemática debe quedar muy clara. Con una buena base, luego es muy asequible avanzar, sin la base es frecuente tropezar casi con cada cosa que tenga algo de complejidad.

Busca algún libro sobre "fundamentos de programación"... No te preocupes si al principio, no entiendes demasiado, a medida que avances y lo leas 3 o 4 veces, lo verás todo bastante claro, es cuestión de que puedas atar cabos, mientras habrá cabos sueltos por todos lados, cuando logres empezar a atarlos, la complejidad desaparece y todo lo que queda es el trato del inglés...

No entiendo nada.
Si quieres programar, y dedicarte a esto, lo primero e imprescindible es aprender lo básico y elemental, al margen de cualquier lenguaje de programación.

Tienes que saber operar con números, tienes que entender los números negativos y las bases binaria, hexadeciaml y octal (la decimal se supone que uno lo tiene).
Tienes que saber que son las operaciones lógicas, aritméticas, qué son los condicionales y las bifurcaciones, que son las funciones, propiedades, variables, secciones de código...
Tienes que saber la diferencia entre la ejecución compilada e interpretada y por lo mismo que es depurar/'debugar' un programa.
Tienes que conocer las estructuras básicas de datos: array, estructuras, listas enlazadas, pilas (FIFO), colas (LIFO), árboles, ficheros y de las bases de datos al menos algo somero...

...y todo sin profundizar, lo básico al menos. Solo entonces es cuando puedes decantarte por un lenguaje y avanzar en profundidad, si todo lo básico lo conoces, nada en un lenguaje va a ser tan complejo que te resulte incomprensible.

Sin un conocimiento básico, es perder el tiempo. Es como querer arreglar un avión cuando no conoces ni como funciona una bicicleta.

Es impòsible poder prestar ayuda útil a alguien que carece de conocimientos básicos... ¿qué baldosa puedo decirte que pises si tu no la conoces y yo ignoro lo que tu desconoces?. Cuando alguien se pone a programar se le supone que sabe lo básico y si no es así, su prioridad no debe ser otra que adquirir esa base... se torna absurdo querer conbstruir un avión, cuando uno no sabe lo que es un ala, ni un motor a reacción ni siquiera un tobera de escape, ni una hélice. ¿¿¿Cómo se supone que vas a hacer algo que no sabes ni cómo es, ni de qué piezas se compone????.

Vaya... es que eres duro de mollera. Se te ha explicado de todas las maneras posibles y sigues sin entenderlo. Y eso de llegar a nada, lo siento, solucion se te ha dado, otra cosa es que tu desistas de usarlas...

Eso es lo que se ha dicho una y otra vez... y no que no se pueda si no que las soluciones no son eficaces.


FALSO. Ya te comenté eso, otra cosa es que en tu ignorancia no sepas verlo...

Tu problema más elemental se traduce en que no aclaras (ni aún a estas alturas), para que rayos necesitas hacer eso, porque es fijo que hay una manera óptima de tratar los datos, pero tu te cierras en banda en querer usar un array mutidimensional porque sí, y solo si... (y además sin usar un bucle para volcarlo). Es como si alguien dice que quiere ir a la Luna, y contrata a una empresa aeroespacial, pero al final resulta que "quiere ir con su motocicleta y no admite ninguna otra cosa". Pues va a ser que así solo irás al pueblito de al lado o a otra ciudad... pero jamás a la Luna.

Si quieres y realmente lo necesitas, explica como tienes los datos en ¿el fichero?, y explica pará que vas a usarlos y por tanto qué datos son precisos y olvida la parte de cómo o de qué manera hay que tratarlo, eso ya se te aclara... deja abierto que te sugieran como tratar los datos, no te obceques en querer hacer algo de una manera específica. Es seguro que hay mucha maneras de hacerlo óptimo, pero 'usando tu moto, forzosamente', nadie se va a comprometer a que sea óptimo...

A ver, yo personalmente no critico a nadie... la idea de responder es ayudar...

Igual que señalo fallos en el código, señalo fallos en el programador. Pero porque a veces el fallo está en el código y a veces el fallo está en el programador.

Si Elektro te puso el código que cumple tus necesidades y tu luego copias y pegas y añades código superfluo, ahora demuestras que el fallo está en el programador, luego señalo el fallo encontrado...

Si el fallo está en el código, pués señalo por donde puedes avanzar, con código y más a menudo con pseudocódigo. y si el fallo está en el programador, también señalo como avanzar o como evitar o solucionar el tema. De hecho mi mensaje previo está repleto de instrucciones y alternativas, que puedes seguir...

Si tú solo crees que los fallos están el código y que tu no debes 'corregirte' entonces seguirás siempre en la 'oscuridad' sin aprender nada, si no tras tropecientos mil intentos...

No te lo tomes a mal, nadie está aquí para molestar, aprende y sigue adelante...

claro que te entendí... el código y explicaciones que pusiste (y que repito aquí debajo) son suficientemente claro:

' tengo esta variable llamada cadena que es igual a
dim cadena as string = "0-1-2-3-4-5-6-7-8-9"
' y declaro una matriz de 1x10 así
dim matriz(1,9) as string
 
' quiero hacer split y que el resultado sea almacenado en la posicion 0 hasta 10 de la matriz sin hacer esto
dim vector() as string
 
vector=split(cadena,"-")
for x=0 to 9
   matriz(0,x)=vector(x)
next
 
' ... quiero guardar el vector en una fila de la matriz ... y quiero ahorrarme el ciclo
 

Sin embargo, eres tú quien parece no haberme entendido...
Ningún lenguaje se dedica a crear funciones peregrinas para resolver un único caso que se va a usar 1 vez cada 5 años por parte de algún programador... máximo, cuando lo mismo puede hacerse con 3 líneas de código y para colmo a cambio de una complejidad extrema (sería preciso para que fuera útil del todo declarar que partes del array deberían mantenerse, lo que exigiría copias posteriores que lo harían lento).
Pero el principal problema por el que ningún lenguaje ha hecho ni hará jamás (salvo que lo formen chiflados), es crear una función cuyo resultado a priori se desconozca, y por tanto que deba crear y redimensionar un array y que en vez de ello, derive a un array administrado por 'el usuario', para volcar el contenido, pero antes redimensionarlo y J0D35L3 el contenido actual, o a cambio de una complejidad extrema donde declare que partes exigen ser mantenidas... y la función deba restaurar esas partes previas verificaciones de si el nuevo tamaño, lo va a permitir (ajustado a la perfeccción), si va a sobrtar contenido nuevo, o si se va a destruir contenido existente...

- Cuando vas a hacer Split, de entrada no sabes cuantas apariciones habrá, por eso en un primer momento han de contarse (si se quieren guardar en un array), para luego redimensionar el array a la cantidad encontrada y en otro paso volcar ahí los datos. Si en vez de un array se usara por ejemplo una lista enlazada, podría hacerse todo en un solo paso, pero la ventaja de los arrays recae en la contigüidad de sus elementos, y de ahí la facilidad de encontrar la dirección de memoria del elemento 'x'... y con ello la velocidad de acceso.

- Si tu tienes un array ya declarado con más de una dimensión, ese array ya está definido a tener 'x' dimensiones por 'y' elementos en cada dimensión (suponiendo uno de 2 dimensiones). Un Split, podría hacer una de dos cosas sobre un array así: Redimensionarlo de nuevo para que tenga el tamaño que encuentre el 'splitado', o bien usar el espacio actual que tenga el array no redimensionándolo en ningún caso y en tal situación que queden ocurrencias sin copia. ó indices sin una reocupación (con basura del contenido previo). ambas situaciones son una chapuza.... peroooooooooo... si ese es tu caso, YA te puse código para una función que hace eso, luego no vengas con que no te entendí.... prueba la función más arriba y dime si lo hace o no (que desde luego lo hace, porque la he probado).

- Pero el problema es que tu ya tienes ese array, en cambio Split, devuelve un array que Split crea. Split no admite (en ninguna sobrecarga) como parámetro de entrada un array tuyo donde volcar el contenido. Luego Split, no hace lo que tu pides (cierto es que no he probado aún VS-2017, pero dudo mucho que hagan eso ni ahora ni nunca. Es más si a alguien se le ocurriera tamaña patraña, creo que lo despidirían ese mismo día).

- Te decía también, que es posible tras obtener el array que devuelve split, volcar en contenido en tu array (sin usar un bucle), haciendo uso de Marshalling, para operar con punteros de dirección y hacer un: copyMemory(ptrDestino, ptrOrigen, NumBytesACopiar)...
...pero francamente el código necesario en NET para esto, es mucho más que las 3 PUT45 líneas sencillas de un bucle (en vb6 sería solo la línea de código de la llamada a la función, pero en NET al operar con memoria administrada se requiere más código aunque luego compilado no difiera mucho).

- Y en cuanto a la velocidad de copia, creo que estás subestimando los procesadores.... trata de hacer pruebas de velocidad de asignación entre bucles y demuéstrame que es lento, dime cuantos millones de índices por segundo es capaz de transferir tu equipo entre 2 arrays... sin conocer nada de tu equipo, apuesto que más de 20millones por segundo, así que tu aseveración de que 'es lento' es pueril e injustificada.

---------
p.d.: En programación se puede hacer cualquier cosa, pero eso no significa que sea admisible hacer cualquier cosa, hay aberraciones y esta que propones (por no usar un bucle) es una de ellas. Francamente eso dice muy poco a tu favor como programador...

Desde el momento en que se deba realojar memoria para copiar datos y deba modificarse una infinidad y la complejidad lo haga costoso, será relativamente más sencillo proveer una array adicional que se crea en el momento preciso y se destruye cuando ya no se requiera, y se deje el resto 'en paz'.... en general esta ecuación suele ser casi siempre cierta: Mayor sencillez = mayor velocidad.

En fin si no entiendes todo esto que te digo, es que tu madurez como programador aún está muy verde...

Una de las primeras pelis, de ese tipo fue la de Superman III (1983), donde el actor Richard Prior, encarnaba al hacker malandrín que hacía de las suyas para sacarse un dinerito... y eso que al inicio era un prongadillo en la programación...  



p.d.: No es ni de lejos, la mejor actuación como hacker, pero si que influenció a muchísima gente para meterse en el mundillo de la informática e hizo soñar a otra mucha, con lo que se podía lograr hacer con un ordenador...

La llamada a esta función con el array de valores: 1, 2, 2, 3, 3, 4, 4 devolvería un array con 3 elementos y estos serían sus valores: m(0) = 4 , m(1) = 3 , m(2) = 2

Nota sin embargo que esta solución al usar parcialmente el algoritmo counting, tiene algunas serias limitaciones:
 --- solo vale para números, no para cadenas.
 --- solo vale para enteros, no para decimales (no es dle todo cierto, pero sería costoso multiplicar todos los números para convertirlos en enteros)
 --- si el valor mayor del array es gigante, será costoso en memoria, ya se necesita memoria auxilair del array de contar presencia de cada valor desde 0 hasta el mayor valor hallado en el array. por ejemplo si tienes un array de 5 elementos y sus valores son estos: 5,6,76543210,16,84, exige crear un array de 76543211 elementos...
 --- si hay valores negativos, es costoso, exige buscar el valor menor, sumar ese valor a todos, para hacer el menor igual a 0, y al final restar ese valor al consignar los valores en el array 'm'...


Ahora bien, si es algo simple como el ejemplo que has puesto cumple perfectamente tus necesidades...

-----------------------------------------
p.d.: modificado, para indicar la salida que daría la función con tus datos de ejemplo como entrada. OJO: Solo indica los valores de moda, no la frecunecia alcanzada en la moda. Si fuere preciso esto, podría devolverse dicho valor en un índice más (el último en el array)... y los cambios al código serían estos:

y...
  y finalmente la salida sería entonces:
  array con 4 elementos y estos serían sus valores: m(0) = 4 , m(1) = 3 , m(2) = 2 y la cuenta de moda: m(3) = 3

No sé yo si entiendes la idea de 'bucle'.

La solución, pasa sí o sí, por hacer bucles. Otra cosa es que el bucle lo realices tú explícitamente o delegues en algún método interno.

Split, no entrega el contenido donde tu desees, si no en la posición de memoria de un array. Si quieres que Split, entregue el resultado en otro lado, tienes que manejar el puntero del array. Básicamente falsificando la dirección del array 'vector', para hacerle creer que su dirección es en realidad la dirección del índice en Matriz(0,0). Ahora bien, esto supone un problema irresoluble aquí... ya que Split, redimensiona automáticamente el array, pero al pasarle una dirección de array falsa, la estructura (SafeArray) del array (Matriz), no va a coincidir en nada con el de 'Vector', por lo que en algún punto va a cantar un error...

No hay buenas noticias para ti, que conste que en VB no existe solución a lo que tu esperas (ni en ningún lenguaje), porque exige sí o sí, redimensionar siempre el array en el que se vuelca, y si el array ya está redimensionado hacerlo de nuevo, sin duda borraría el contenido previo, pero puedes enfangarte y hacer algo...

Lo mejor es que ya que se requiere usar bucles (sí o sí), implementes tu propia función Split ... (aquí simplificada en parámetros)

''' <summary>
''' Entrecorta un texto, por un carácter que se busca y el resultado lo aloja en un array.
''' </summary>
''' <param name="Texto">El Texto origen del procesado</param>
''' <param name="Delimitador">El carácter (ojo, no un texto), por el que se busca entrecortar.</param>
''' <returns>Un array con los resultados hallados.</returns>
''' <remarks>Si delimitador se quiere que sea una cadena y no un texto, debe modificarse la búsqueda (el condicional dentro del bucle).</remarks>
Public Function Split(ByRef Texto As String, Optional ByRef Delimitador As String = " ") As String()
        Dim cd() As String
        Dim ct1 As UInt32, ct2 As UInt32, k As UInt32, n As UInt32
 
        ' Buscar cuantas coincidencias se localizan...
        While (k < Texto.Length)
            If Texto.Chars(k) = Delimitador Then
                ct1 += 1
            End If
            k += 1
        End While
 
        ReDim cd(0 To ct1)
 
        ct2 = 0 : n = 0 ' a cero, por si se usaran antes...
        If (ct1 > 0) Then ' número de subdivisiones, si no se encontró, no recorremos de nuevo el texto...
            k = 0
            While (k < Texto.Length)
                If Texto.Chars(k) = Delimitador Then
                    cd(ct2) = Texto.Substring(n, k - n)
                    ct2 += 1 : n = k + 1
                End If
                k += 1
            End While
        End If
        ' queda la subcadena final, puede ser el texto original si no se encontró nada.
        cd(ct2) = Texto.Substring(n, k - n)
 
        Return cd
End Function
 

Bien, ahora que hay una función que opera conforme a como se espera (esto es casi igual que hace el Split de VB, digo casi, porque el delimitador aquí debe ser un solo carácter, queda a tu esfuerzo hacer los cambios necesarios que requieras), ahora puedes añadir una sobrecarga con la modificación que tu pedías...
...y hay un pero, bastante gordo... y es que tu array ya debe estar redimensionado y debe poder albergar todos los hallazgos que se encuentren, o generará error... obviamente esto conlleva a preguntar qué necesidad hay de hacer realmente esto, que no va a quedar en condiciones (no deja de ser un poco chapuza), y hace cuestionar lo más importante: ¿Para qué es necesario hacer esto?... porque seguramente existe una alternativa mucho más óptima y razonable, con la que no es posible contar al ignorar el propósito de para qué lo necesitas...

Existen los JaggedArray que pueden solucionar ciertos problemas con arrays multidimensionales donde cada dimensión puede tener diferente cantidad de elementos...

...de todos modos, ya que he perdido el tiempo en ello, lo pongo... aquí el código de la modificación... pero fíjate en las 2 importantes limitaciones de esta 'solución': No puedes redimensionar el array, y el número de elementos de la dimensión final, debe poder alojar todos los hallazgos, o bien añadir un parámetro adicional (como tiene VB), para señalar cuántos elementos desean consignarse en el array (en VB un valor de -1, indica que todos los que haya)... nuevamente queda a tu esfuerzo cualquier cambio que necesites...

''' <summary>
    ''' Entrecorta un texto, por un carácter que se busca y el resultado lo aloja en la dimensión de un array YA ESTABLECIDO.
    ''' </summary>
    ''' <param name="Bolsa">Un array ya dimensionado a un tamaño útil.</param>
    ''' <param name="Dimension">El índice la dimensión donde se van a alojar.</param>
    ''' <param name="Texto">El Texto origen del procesado</param>
    ''' <param name="Delimitador">El carácter (ojo, no un texto), por el que se busca entrecortar.</param>
    ''' <returns>El número de delimitadores hallados</returns>
    ''' <remarks>Si delimitador se quiere que sea una cadena y no un texto, debe modificarse la búsqueda (el condicional dentro del bucle).</remarks>
    Public Function Split(ByRef Bolsa(,) As String, ByVal Dimension As Integer, ByRef Texto As String, Optional ByRef Delimitador As String = " ") As Integer        
        Dim ct1 As UInt32, ct2 As UInt32, k As UInt32, n As UInt32, d As Integer
 
        ' Buscar cuantas coincidencias se localizan...
        While (k < Texto.Length)
            If Texto.Chars(k) = Delimitador Then
                ct1 += 1
            End If
            k += 1
        End While
 
        ct2 = 0 : n = 0 ' a cero, por si se usaran antes...
        If (ct1 > 0) Then ' si no se encontró, no recorremos de nuevo el texto...
            k = 0
            While (k < Texto.Length)
                If Texto.Chars(k) = Delimitador Then
                    Bolsa(Dimension, ct2) = Texto.Substring(n, k - n)
                    ct2 += 1 : n = k + 1
                End If
                k += 1
            End While
        End If
        ' queda la subcadena final, puede ser el texto original si no se encontró nada.
        Bolsa(Dimension, ct2) = Texto.Substring(n, k - n)
 
        Return ct2
End Function
 

Puede sprobar ambas funciones, por ejemplo con esto:

        Dim s As String = "0-1---2-3-4-5-6-7-8-9-"  
        ' otros textos de prueba:"0-1-2-3-4-5-6-7-8-9", "0123456789"
        Dim cd() As String, sd(,) As String
        Dim n As Integer
 
        cd = Strings.Split(s, "-") ' el split de VB, para tras su ejecución y verifica si éste resultado coincide con el que devuelve la función cuyo código se ha creado...
        cd = Me.Split(s, "-")
 
        ReDim sd(0 To 2, 0 To 16)
        n = Me.Split(sd, 1, s, "-") 
        n= n ' pon aquí un punto de parada (tecla F9) , y ejecuta hasta aquí, luego posa el ratón sobre 'sd' y baja a la flechita para ver el contenido del array con el intellisense
 

Y bueno, si nos cuentas para que los quieres se puede analizar una solución más óptima y acorde...

Incluso usando la función Split de VB, una vez obtenido el array podrías copiar el contenido (sin un bucle), nuevamente mediante el uso de punteros a memoria... la función de las API CopyMemory, vale perfectamente para ello, pero con Marshalling (bajo NET), evitarás la problemática de las API con la memoria administrada y no administrada....

p.d.: después de todo lo dicho, espero que reconsideres la opción de usar el bucle para asignarlo en tu array, aunque sea usando copymemory si no quieres usar un bucle (internamente en ensamblador, así se hará. Te guste o no, el bucle es inevitable).