Inicializar lista em C# (Como funciona para desenvolvedores)

Inicialização básica de lista

Para inicializar uma lista, comece criando uma instância da classe List<t>, onde T é o tipo de elementos na lista. O tipo mais comum é string, mas você pode usar qualquer 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

No exemplo acima, criamos uma lista vazia e adicionamos elementos usando o método Add. O List<string> representa uma lista de strings, e usamos o método Add para preenchê-la com valores.

Usando a sintaxe de inicialização de coleção

C# oferece uma maneira mais concisa de inicializar uma lista usando a sintaxe de inicialização de coleção. Isso permite que você preencha a lista diretamente quando ela for criada, sem precisar chamar repetidamente o 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 alcança o mesmo resultado que o exemplo anterior, mas de forma mais compacta. Os inicializadores de coleção permitem inicializar uma lista com valores em uma única instrução, tornando seu código mais legível.

Inicializadores de objetos e inicialização de listas

A sintaxe de inicialização de objetos é outra maneira de inicializar listas, principalmente ao trabalhar com objetos personalizados. Aqui está um exemplo de como os inicializadores de objetos funcionam com 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
	}
}

Neste exemplo, criamos uma lista de objetos Person usando inicializadores de objeto. A classe Person possui duas propriedades: Name e Age, às quais são atribuídos valores explicitamente quando a lista é criada.

Criando uma lista com um tamanho inicial

Embora as listas tenham tamanho dinâmico, você pode especificar uma capacidade inicial se souber aproximadamente quantos elementos a lista irá conter. Isso pode melhorar o desempenho, reduzindo o número de realocações de memória.

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

Isso cria uma lista vazia com capacidade inicial de 10 elementos. Embora não adicione elementos, aloca memória suficiente para armazenar até 10 elementos sem redimensionar o array interno.

Inicializando uma lista a partir de um array

Você também pode inicializar uma lista a partir de um array existente usando o construtor de lista que recebe um argumento IEnumerable<t>. Isso é útil quando você tem um array e deseja convertê-lo em uma lista para maior flexibilidade.

// 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)

Aqui, um novo array é criado e então usado para inicializar uma lista. Isso converte o array fruitArray em uma lista. Qualquer IEnumerable<t>, incluindo arrays, pode ser passado para o construtor da lista para inicialização.

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)

Inicializando uma lista com objetos personalizados

Ao inicializar uma lista de objetos personalizados, você pode combinar inicializadores de objeto com inicializadores de coleção para criar estruturas de dados complexas em uma única expressão.

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
	}
}

Essa técnica permite criar e inicializar uma lista de objetos em uma única instrução, tornando o código conciso e fácil de ler.

Inicialização de listas com métodos de extensão

Você também pode implementar um método de extensão para inicializar uma lista de forma personalizada. Os métodos de extensão fornecem um mecanismo para aprimorar tipos existentes com novas funcionalidades sem alterar sua estrutura 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");

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")

Aqui, definimos um método de extensão, InitializeWith, que adiciona elementos à lista e retorna a própria lista. Isso permite encadear a inicialização e o preenchimento da lista.

IronPDF: Biblioteca PDF em C

Se você tiver uma lista, como uma lista de frutas, pode transformá-la rapidamente em uma tabela HTML e renderizá-la como um PDF usando o IronPDF , tudo com apenas algumas linhas de código. O processo é simples: inicialize sua lista, converta-a para HTML e deixe o IronPDF gerar o PDF. Eis um exemplo:

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 uma lista, cria uma tabela HTML a partir dela e usa o IronPDF para gerar um arquivo PDF. É uma maneira simples e direta de gerar PDFs a partir de suas coleções de dados.

Conclusão

A inicialização de listas em C# é um conceito fundamental que todo engenheiro de software deve dominar. Quer você esteja trabalhando com listas simples de strings ou listas complexas de objetos, o C# oferece diversos métodos para inicializar e preencher listas de forma eficiente. Desde a inicialização básica até inicializadores de objetos e coleções, essas técnicas ajudam você a escrever um código limpo, conciso e de fácil manutenção.

A IronPDF oferece um período de teste gratuito que permite experimentar o produto sem fazer um investimento inicial. Quando tiver certeza de que atende às suas necessidades, as licenças estão disponíveis a partir de $799.