C# Initialize List (Cómo funciona para desarrolladores)

Las listas forman parte delSystem.Collections.Generic la traducción debe ser profesional, preservando la precisión técnica y explicando al mismo tiempo las características y ventajas de estas herramientas para desarrolladores. Las listas en C# son dinámicas, lo que significa que su tamaño puede cambiar en tiempo de ejecución. Esta flexibilidad es muy útil en muchas situaciones de ingeniería de software en las que no se conoce de antemano el número de elementos. Veamos distintas formas de inicializar una lista en C#. Cubriremos las técnicas básicas, la sintaxis de los inicializadores de objetos, los inicializadores de colecciones y la sintaxis de los inicializadores de objetosBiblioteca IronPDF.

Inicialización básica de listas

Para inicializar una lista, comience por crear una instancia de la Listadonde T es el tipo de los elementos de la lista. El tipo más común es string, pero se puede utilizar cualquier tipo.

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // Initialize an empty list
        List<string> fruits = new List<string>();
        // Adding elements to the list
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");
        // Display the list
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // Initialize an empty list
        List<string> fruits = new List<string>();
        // Adding elements to the list
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");
        // Display the list
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Shared Sub Main()
		' Initialize an empty list
		Dim fruits As New List(Of String)()
		' Adding elements to the list
		fruits.Add("Apple")
		fruits.Add("Banana")
		fruits.Add("Cherry")
		' Display the list
		For Each fruit In fruits
			Console.WriteLine(fruit)
		Next fruit
	End Sub
End Class

En el ejemplo anterior, creamos una lista vacía y añadimos elementos utilizando el método Add. La listarepresenta una lista de cadenas, y utilizamos el método Add para rellenarla con valores.

Uso de la sintaxis del inicializador de colecciones

C# ofrece una forma más concisa de inicializar una lista utilizando la sintaxis del inicializador de colecciones. Esto permite rellenar la lista directamente cuando se crea sin tener que llamar repetidamente al método Add.

public void InitializeList()
{
    List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
}

public void InitializeList()
{
    List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
}

Public Sub InitializeList()
	Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}
End Sub

Este código consigue el mismo resultado que el ejemplo anterior, pero de forma más compacta. Los inicializadores de colecciones permiten inicializar una lista con valores en una única sentencia, lo que hace que el código sea más legible.

Inicializadores de objetos e inicialización de listas

La sintaxis del inicializador de objetos es otra forma de inicializar listas, principalmente cuando se trabaja con objetos personalizados. He aquí un ejemplo de cómo funcionan los inicializadores de objetos con listas:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 25 },
    new Person { Name = "Jack", Age = 35 }
};

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 25 },
    new Person { Name = "Jack", Age = 35 }
};

Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class
Private people As New List(Of Person) From {
	New Person With {
		.Name = "John",
		.Age = 30
	},
	New Person With {
		.Name = "Jane",
		.Age = 25
	},
	New Person With {
		.Name = "Jack",
		.Age = 35
	}
}

En este ejemplo, creamos una lista de objetos Persona utilizando inicializadores de objetos. La clase Persona tiene dos propiedades: Nombre y Edad, a las que se asignan valores explícitamente cuando se crea la lista.

Creación de una lista con un tamaño inicial

Aunque el tamaño de las listas es dinámico, se puede especificar una capacidad inicial si se sabe aproximadamente cuántos elementos contendrá la lista. Esto puede mejorar el rendimiento al reducir el número de reasignaciones de memoria.

List<string> fruits = new List<string>(10); // Initial size of 10

List<string> fruits = new List<string>(10); // Initial size of 10

Dim fruits As New List(Of String)(10) ' Initial size of 10

Esto crea una lista vacía con una capacidad inicial de 10 elementos. Aunque no añade elementos, asigna memoria suficiente para albergar hasta 10 elementos sin redimensionar el array interno.

Inicialización de una lista a partir de una matriz

También puede inicializar una lista a partir de una matriz existente utilizando el constructor de lista que toma un IEnumerableargumento. Esto es útil cuando se tiene un array y se quiere convertir en una lista para mayor flexibilidad.

// New String array of fruit
string[] fruitArray = { "Apple", "Banana", "Cherry" };
List<string> fruits = new List<string>(fruitArray);

// New String array of fruit
string[] fruitArray = { "Apple", "Banana", "Cherry" };
List<string> fruits = new List<string>(fruitArray);

' New String array of fruit
Dim fruitArray() As String = { "Apple", "Banana", "Cherry" }
Dim fruits As New List(Of String)(fruitArray)

Aquí, se crea una nueva matriz y luego se utiliza para inicializar una lista. Esto convierte el array fruitArray en una lista. Cualquier IEnumerableel constructor de listas puede inicializarse con cualquier tipo de lista, incluidas las matrices.

Uso del método AddRange

Si dispone de una colección de elementos, puede utilizar el método AddRange para añadir juntos varios elementos a una lista.

List<string> fruits = new List<string> { "Apple", "Banana" };
string[] moreFruits = { "Cherry", "Date", "Elderberry" };
fruits.AddRange(moreFruits);

List<string> fruits = new List<string> { "Apple", "Banana" };
string[] moreFruits = { "Cherry", "Date", "Elderberry" };
fruits.AddRange(moreFruits);

Dim fruits As New List(Of String) From {"Apple", "Banana"}
Dim moreFruits() As String = { "Cherry", "Date", "Elderberry" }
fruits.AddRange(moreFruits)

En este ejemplo, comenzamos con una lista que contiene dos elementos y añadimos varios elementos nuevos desde una matriz utilizando AddRange. Este método puede mejorar el rendimiento al añadir elementos de uno en uno, ya que minimiza la necesidad de múltiples reasignaciones.

Inicialización de una lista con objetos personalizados

Al inicializar una lista de objetos personalizados, puede combinar inicializadores de objetos con inicializadores de colecciones para crear estructuras de datos complejas en una sola expresión.

List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 32 },
    new Person { Name = "Charlie", Age = 40 }
};

List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 32 },
    new Person { Name = "Charlie", Age = 40 }
};

Dim people As New List(Of Person) From {
	New Person With {
		.Name = "Alice",
		.Age = 28
	},
	New Person With {
		.Name = "Bob",
		.Age = 32
	},
	New Person With {
		.Name = "Charlie",
		.Age = 40
	}
}

Esta técnica permite crear e inicializar una lista de objetos en una sola sentencia, lo que hace que el código sea conciso y fácil de leer.

Inicialización de listas con métodos de extensión

También puede implementar un método de extensión para inicializar una lista de forma personalizada. Los métodos de extensión proporcionan un mecanismo para mejorar los tipos existentes con nuevas capacidades sin alterar su estructura original.

public static class ListExtensions
{
    public static List<T> InitializeWith<T>(this List<T> list, params T[] elements)
    {
        list.AddRange(elements);
        return list;
    }
}
// Usage
List<string> fruits = new List<string>().InitializeWith("Apple", "Banana", "Cherry");

public static class ListExtensions
{
    public static List<T> InitializeWith<T>(this List<T> list, params T[] elements)
    {
        list.AddRange(elements);
        return list;
    }
}
// Usage
List<string> fruits = new List<string>().InitializeWith("Apple", "Banana", "Cherry");

Public Module ListExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function InitializeWith(Of T)(ByVal list As List(Of T), ParamArray ByVal elements() As T) As List(Of T)
		list.AddRange(elements)
		Return list
	End Function
End Module
' Usage
Private fruits As List(Of String) = (New List(Of String)()).InitializeWith("Apple", "Banana", "Cherry")

Aquí definimos un método de extensión, InitializeWith, que añade elementos a la lista y devuelve la propia lista. Esto permite encadenar la inicialización y la población de la lista.

IronPDF: C# Biblioteca PDF

Si tiene una lista, por ejemplo de frutas, puede convertirla rápidamente en una Tabla HTML y renderización en PDFutilizandoIronPDFtodo ello en unas pocas líneas de código. El proceso es sencillo: inicialice su lista, conviértala a HTML y deje que IronPDF genere el PDF. He aquí un ejemplo:

using IronPdf;
using System;
using System.Collections.Generic;
using System.Text;
class Program
{
    static void Main()
    {
        // Initialize a list of strings representing data
        List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
        // Convert the list to an HTML table
        StringBuilder htmlContent = new StringBuilder();
        htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>");
        foreach (var fruit in fruits)
        {
            htmlContent.Append($"<tr><td>{fruit}</td></tr>");
        }
        htmlContent.Append("</table>");
        // Render the HTML to PDF using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString());
        // Save the PDF to a file
        PDF.SaveAs("FruitsList.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;
using System.Text;
class Program
{
    static void Main()
    {
        // Initialize a list of strings representing data
        List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
        // Convert the list to an HTML table
        StringBuilder htmlContent = new StringBuilder();
        htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>");
        foreach (var fruit in fruits)
        {
            htmlContent.Append($"<tr><td>{fruit}</td></tr>");
        }
        htmlContent.Append("</table>");
        // Render the HTML to PDF using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString());
        // Save the PDF to a file
        PDF.SaveAs("FruitsList.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Text
Friend Class Program
	Shared Sub Main()
		' Initialize a list of strings representing data
		Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}
		' Convert the list to an HTML table
		Dim htmlContent As New StringBuilder()
		htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>")
		For Each fruit In fruits
			htmlContent.Append($"<tr><td>{fruit}</td></tr>")
		Next fruit
		htmlContent.Append("</table>")
		' Render the HTML to PDF using IronPDF
		Dim Renderer = New ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString())
		' Save the PDF to a file
		PDF.SaveAs("FruitsList.pdf")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class

Este código inicializa una lista, crea una tabla HTML a partir de ella y utiliza IronPDF para crear un archivo PDF. Es una forma sencilla y directa de generar PDFs a partir de tus colecciones de datos.

Conclusión

La inicialización de listas en C# es un concepto fundamental que todo ingeniero de software debe dominar. Tanto si trabaja con listas simples de cadenas como con listas complejas de objetos, C# ofrece varios métodos para inicializar y rellenar listas de forma eficiente. Desde la inicialización básica hasta los inicializadores de objetos y colecciones, estas técnicas le ayudarán a escribir un código limpio, conciso y fácil de mantener.

IronPDF ofrece unprueba gratuita que permita probar el producto sin realizar una inversión inicial. Cuando esté seguro de que satisface sus necesidades, las licencias están disponibles a partir de $749.