Las listas son parte del espacio de nombres System.Collections.Generic y son versátiles para manejar colecciones de datos. 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 muchos escenarios de ingeniería de software donde el número de elementos no se conoce de antemano. Vamos a profundizar en diferentes maneras de inicializar una lista en C#. Cubriremos técnicas básicas, la sintaxis de inicialización de objetos, inicializadores de colecciones, y la biblioteca IronPDF.
Para inicializar una lista, comience creando una instancia de la clase List<t>, donde T es el tipo de elementos en la lista. El tipo más común es string, pero puede usar 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);
}
}
}Imports System
Imports System.Collections.Generic
Module Program
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
End Sub
End ModuleEn el ejemplo anterior, creamos una lista vacía y añadimos elementos usando el método Add. El List<string> representa una lista de cadenas, y utilizamos el método Add para poblarla con valores.
C# ofrece una forma más concisa de inicializar una lista usando la sintaxis de inicialización de colecciones. Esto le permite poblar 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 Sub InitializeList()
Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}
End SubEste código logra el mismo resultado que el ejemplo anterior pero de una forma más compacta. Los inicializadores de colecciones le permiten inicializar una lista con valores en una sola declaración, haciendo su código más legible.
La sintaxis de inicialización de objetos es otra forma de inicializar listas, principalmente cuando se trabaja con objetos personalizados. Aquí hay 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 }
};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 Person utilizando inicializadores de objetos. La clase Person tiene dos propiedades: Name y Age, a las cuales se les asignan valores explícitamente cuando se crea la lista.
Aunque las listas son de tamaño dinámico, puede especificar una capacidad inicial si 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 10Dim fruits As New List(Of String)(10) ' Initial size of 10Esto crea una lista vacía con una capacidad inicial de 10. Aunque no añade elementos, asigna suficiente memoria para contener hasta 10 elementos sin cambiar el tamaño del arreglo interno.
También puede inicializar una lista a partir de un arreglo existente utilizando el constructor de lista que toma un argumento IEnumerable<t>. Esto es útil cuando tiene un arreglo y quiere convertirlo en una lista para flexibilidad.
// 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 un nuevo arreglo y luego se utiliza para inicializar una lista. Esto convierte el arreglo fruitArray en una lista. Cualquier IEnumerable<t>, incluidos arreglos, pueden pasarse al constructor de lista para la inicialización.
Si tiene una colección existente de elementos, puede utilizar el método AddRange para agregar múltiples elementos a una lista juntos.
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 agregamos múltiples elementos nuevos de un arreglo usando AddRange. Este método puede mejorar el rendimiento al añadir elementos en bloque, ya que minimiza la necesidad de múltiples reasignaciones.
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 }
};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 declaración, haciendo el código conciso y fácil de leer.
También puede implementar un método de extensión para inicializar una lista de una manera personalizada. Los métodos de extensión proporcionan un mecanismo para mejorar 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");Imports System.Collections.Generic
Public Module ListExtensions
<System.Runtime.CompilerServices.Extension>
Public Function InitializeWith(Of T)(list As List(Of T), ParamArray elements As T()) As List(Of T)
list.AddRange(elements)
Return list
End Function
End Module
' Usage
Dim 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 lista misma. Esto le permite encadenar la inicialización y población de la lista.
Si tiene una lista, como una lista de frutas, puede convertirla rápidamente en una tabla HTML y renderizarla como un PDF usando IronPDF, todo en solo 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. Aquí hay 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.");
}
}Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Text
Module Program
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
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 Module
Este código inicializa una lista, crea una tabla HTML a partir de ella y usa IronPDF para crear un archivo PDF. Es una forma simple y directa de generar PDFs a partir de sus colecciones de datos.
La inicialización de listas en C# es un concepto fundamental que cada ingeniero de software debería dominar. Ya sea que esté trabajando con listas simples de cadenas o listas complejas de objetos, C# ofrece varios métodos para inicializar y llenar listas de manera eficiente. Desde la inicialización básica hasta los inicializadores de objetos y colecciones, estas técnicas le ayudan a escribir código limpio, conciso y mantenible.
IronPDF ofrece una prueba gratuita que le permite probar el producto sin hacer una inversión inicial. Cuando esté seguro de que satisface sus necesidades, las licencias están disponibles a partir de $999.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
