Hasta ahora hemos trabajado con variables que almacenan un único dato: un título, un número de páginas, un booleano. Pero en la práctica, casi cualquier programa necesita manejar varios datos del mismo tipo a la vez —por ejemplo, todos los títulos de libros de BiblioTech— y necesita también manipular texto de forma más avanzada que un simple Console.WriteLine. En esta lección aprenderás a trabajar con arrays (una y varias dimensiones), a recorrerlos con foreach/for, y a explotar toda la potencia de la clase string: concatenación, interpolación, y sus métodos más habituales. Cerraremos con StringBuilder, la herramienta adecuada cuando se concatena texto de forma repetida dentro de un bucle.

1. Arrays de una dimensión
2. Arrays de varias dimensiones
3. Arrays de tamaño fijo frente a List<T>
4. Recorrer un array con foreach y con for
5. La clase string: inmutabilidad, concatenación e interpolación
6. Métodos habituales de string
7. StringBuilder para concatenación eficiente

Un array es una colección de elementos del mismo tipo, almacenados de forma contigua y accesibles mediante un índice numérico que empieza en 0. Se declara indicando el tipo de los elementos seguido de corchetes []:

También se puede declarar e inicializar en un solo paso, indicando directamente los valores:

Una característica fundamental de los arrays en C# es que su tamaño se fija al crearlos y no puede cambiar después. Para saber cuántos elementos contiene, se usa la propiedad Length:

Intentar acceder a un índice que no existe (por ejemplo, titulosLibros[5] en un array de 3 elementos) no da un error al compilar, pero sí provoca un error en tiempo de ejecución (una excepción de tipo IndexOutOfRangeException, que estudiaremos en el Módulo 2 al ver el manejo de excepciones). Por eso siempre hay que asegurarse de que el índice usado esté entre 0 y Length - 1.

Además de los arrays de una dimensión (una simple lista de elementos), C# permite arrays de varias dimensiones, útiles para representar datos organizados en forma de tabla o cuadrícula. El caso más común es el array bidimensional (filas y columnas):

También se pueden inicializar directamente con sus valores:

Para conocer el número de filas y columnas de un array bidimensional se usa el método GetLength, indicando la dimensión (0 para filas, 1 para columnas):

En este curso los arrays multidimensionales aparecerán de forma puntual; la mayoría de los ejemplos usarán arrays de una dimensión, que son con diferencia los más habituales en el día a día.

Como hemos visto, un array tiene un tamaño fijo: una vez creado con, por ejemplo, 3 elementos, no se puede añadir un cuarto título de libro sin crear un array completamente nuevo. En muchos escenarios reales (como ir añadiendo libros al catálogo de BiblioTech a medida que se registran) esta limitación resulta incómoda.

Para esos casos, .NET ofrece List<T>, una colección cuyo tamaño puede crecer y encogerse de forma dinámica, con métodos como Add (añadir un elemento) o Remove (quitarlo). Aquí solo la mencionamos de pasada: List<T> y el resto de colecciones de .NET se estudian en profundidad en el Módulo 4 ("Colecciones"), junto con LINQ, la potente herramienta de consulta que usaremos para explorar el catálogo completo de BiblioTech. Por ahora, quédate con esta idea:

Para procesar todos los elementos de un array, uno a uno, existen dos bucles principales. Aunque los bucles se estudian en profundidad en el Módulo 2 ("Bucles"), aquí veremos su uso básico aplicado a arrays, ya que es una combinación tan habitual que conviene conocerla desde ya.

foreach recorre todos los elementos de una colección, uno detrás de otro, sin necesidad de gestionar manualmente un índice:

Este código imprime, uno por línea, cada título del array. foreach es la opción más clara y recomendable cuando simplemente necesitas leer o procesar cada elemento, sin necesitar su posición (índice).

Cuando sí necesitas el índice (por ejemplo, para numerar los libros, o para modificar el propio array durante el recorrido), se usa el bucle for, que da control explícito sobre un contador:

Este ejemplo imprime cada título precedido de su posición en la lista, empezando en 1 (sumando 1 al índice, que empieza en 0):

Una string en C# es inmutable: una vez creada, su contenido no puede modificarse. Cualquier operación que "parezca" cambiar una cadena (como concatenarla con otro texto) realmente crea una cadena nueva en memoria, dejando la original intacta:

Esta propiedad tiene implicaciones importantes de rendimiento cuando se concatenan muchas cadenas dentro de un bucle, como veremos más adelante en la sección de StringBuilder.

Concatenar significa unir dos o más cadenas en una sola. La forma más básica es con el operador +:

La interpolación es una forma mucho más legible de construir cadenas que combinan texto fijo con valores de variables. Se antepone el símbolo $ antes de las comillas, y las variables (o incluso expresiones) se insertan directamente entre llaves { }:

Resultado:

Dentro de las llaves { } de una cadena interpolada se pueden escribir incluso pequeñas expresiones, no solo variables sueltas:

En este curso preferiremos la interpolación siempre que combinemos texto con variables, por su claridad.

La clase string incluye numerosos métodos ya construidos para las tareas más habituales de manipulación de texto. Estos son los más usados:

Vamos a verlos aplicados a un ejemplo realista de BiblioTech: procesar una línea de texto con varios datos de un libro separados por comas, tal y como podría venir de un archivo de importación (algo que trataremos en profundidad en el Módulo 5, "Entrada/Salida de Archivos").

Fíjate en que cada uno de estos métodos no modifica la cadena original (recuerda: las cadenas son inmutables), sino que devuelve una cadena nueva con el resultado. Por eso siempre asignamos el resultado a una variable (o lo usamos directamente), en lugar de esperar que la variable original cambie por sí sola.

Un caso de uso muy habitual al buscar en un catálogo (como el de BiblioTech) es comparar texto sin que importen las mayúsculas o minúsculas. Para ello se pueden convertir ambas cadenas al mismo caso antes de comparar, o usar el método Equals con una opción específica:

Como cada string es inmutable, concatenar cadenas repetidamente dentro de un bucle (por ejemplo, para construir un informe con todos los títulos del catálogo) crea, en cada iteración, una cadena nueva completa en memoria, descartando la anterior. Para pocos elementos esto no supone ningún problema, pero si el bucle se repite muchas veces (miles de libros, por ejemplo), puede afectar notablemente al rendimiento.

Para estos casos, .NET ofrece la clase StringBuilder, pensada específicamente para construir cadenas de texto de forma eficiente mediante sucesivas modificaciones, sin crear una cadena nueva completa en cada paso. Se encuentra en el espacio de nombres System.Text.

Resultado:

No profundizaremos más en StringBuilder en este módulo introductorio; es una herramienta que irá apareciendo de forma natural más adelante en el curso, especialmente cuando trabajemos con grandes catálogos de libros y generación de informes.

• Acceder a un índice fuera de rango: recuerda que los índices de un array van de 0 a Length - 1. Acceder a array[Length] es un error muy común y provoca una excepción en tiempo de ejecución.
• Esperar que un array cambie de tamaño: los arrays tienen tamaño fijo. Si necesitas añadir o quitar elementos dinámicamente, necesitarás List<T> (Módulo 4), no un array. Créar un array de mayor tamaño y copiar los datos es posible, pero engorroso y poco habitual en la práctica.
• Olvidar que las cadenas son inmutables: escribir titulo.ToUpper(); sin asignar el resultado a ninguna variable no modifica titulo; hay que hacer titulo = titulo.ToUpper(); (o usar el resultado directamente donde se necesite).
• Usar concatenación con + dentro de bucles grandes: para pocos elementos no pasa nada, pero si el bucle procesa muchísimos elementos, es preferible StringBuilder.
• Confundir Split sin limpiar espacios: al dividir texto con Split, cada fragmento puede llevar espacios sobrantes; conviene aplicar Trim() a cada uno, como hicimos en el ejemplo de importación de datos.
• Consejo: cuando trabajes con texto que combine variables, prioriza siempre la interpolación ($"...") sobre la concatenación con +: el código resultante es mucho más legible y menos propenso a errores.

1. Declara un array de tipo string[] con al menos 5 títulos de libros de BiblioTech. Recórrelo con foreach y muestra cada título en una línea. Después, recórrelo con un bucle for mostrando cada título numerado, empezando en 1 (por ejemplo: 1. Cien anos de soledad).

2. Dado el array de títulos del ejercicio anterior, escribe código que recorra el array y muestre solo los títulos que contengan la letra "a" (usando el método Contains, y convirtiendo el título a minúsculas con ToLower() antes de comparar, para que la búsqueda no distinga mayúsculas de minúsculas).

3. Usando StringBuilder, construye un informe de texto con todos los títulos del array del ejercicio 1, con el formato:

   === Catalogo BiblioTech ===
   1) <titulo 1>
   2) <titulo 2>
   ...
   

   (Pista: puedes combinar un bucle for con StringBuilder.AppendLine e interpolación de cadenas para construir cada línea numerada).

string[] titulosLibros = { "Cien anos de soledad", "Rayuela", "Ficciones", "El Aleph", "Pedro Paramo" };

// Recorrido con foreach
foreach (string titulo in titulosLibros)
{
    Console.WriteLine(titulo);
}

Console.WriteLine("---");

// Recorrido con for, numerado desde 1
for (int i = 0; i < titulosLibros.Length; i++)
{
    Console.WriteLine($"{i + 1}. {titulosLibros[i]}");
}

string[] titulosLibros = { "Cien anos de soledad", "Rayuela", "Ficciones", "El Aleph", "Pedro Paramo" };

foreach (string titulo in titulosLibros)
{
    if (titulo.ToLower().Contains("a"))
    {
        Console.WriteLine(titulo);
    }
}

Todos los títulos del ejemplo contienen la letra "a" en algún punto (mayúscula o minúscula), por lo que el resultado mostraría los cinco; el ejercicio sirve para practicar la combinación de ToLower() y Contains(), no tanto para obtener un subconjunto reducido con estos datos concretos. Puedes probar con otros títulos que no contengan la letra para comprobar que sí se filtran correctamente.

using System.Text;

string[] titulosLibros = { "Cien anos de soledad", "Rayuela", "Ficciones", "El Aleph", "Pedro Paramo" };

StringBuilder informe = new StringBuilder();
informe.AppendLine("=== Catalogo BiblioTech ===");

for (int i = 0; i < titulosLibros.Length; i++)
{
    informe.AppendLine($"{i + 1}) {titulosLibros[i]}");
}

Console.WriteLine(informe.ToString());

Resultado esperado:

=== Catalogo BiblioTech ===
1) Cien anos de soledad
2) Rayuela
3) Ficciones
4) El Aleph
5) Pedro Paramo

En esta lección has aprendido a trabajar con arrays de una y varias dimensiones, a recorrerlos con foreach y for, y has visto por qué List<T> (que estudiaremos en el Módulo 4) resuelve la limitación del tamaño fijo de los arrays. También has profundizado en la clase string: su inmutabilidad, la concatenación, la interpolación $"", sus métodos más habituales (Split, Trim, Contains, Substring, ToUpper/ToLower) y el uso de StringBuilder para concatenar texto de forma eficiente dentro de bucles.

Con esto se cierra el Módulo 1: Introducción a C#. Ya sabes instalar y configurar tu entorno, escribir y ejecutar programas de consola, aplicar correctamente la sintaxis del lenguaje, declarar variables de distintos tipos y trabajar con arrays y cadenas de texto —todo ello aplicado, paso a paso, al proyecto BiblioTech. En el Módulo 2: Estructuras de Control aprenderás a tomar decisiones en tu código con sentencias condicionales, a repetir acciones con bucles, a organizar múltiples casos con switch, y a manejar errores de forma robusta con excepciones: piezas imprescindibles para que BiblioTech empiece a comportarse como una aplicación real, capaz de reaccionar a distintas situaciones y datos.