As listas fazem parte do namespace System.Collections.Generic e são versáteis para manipular coleções de dados. Em C#, as listas são dinâmicas, o que significa que seu tamanho pode mudar em tempo de execução. Essa flexibilidade é muito útil em diversos cenários de engenharia de software onde o número de elementos não é conhecido antecipadamente. Vamos explorar diferentes maneiras de inicializar uma lista em C#. Vamos abordar técnicas básicas, sintaxe de inicialização de objetos, inicializadores de coleção e a biblioteca IronPDF .
Para inicializar uma lista, comece criando uma instância da classe List<t>, onde T é o tipo dos 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);
}
}
}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 ModuleNo 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 preencher com valores.
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 é criada sem chamar repetidamente o 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 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.
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 }
};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 tem duas propriedades: Name e Age, que são explicitamente atribuídas valores quando a lista é criada.
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 10Dim fruits As New List(Of String)(10) ' Initial size of 10Isso 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.
Você também pode inicializar uma lista a partir de um array existente usando o construtor de lista que aceita 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
Dim fruitArray() As String = { "Apple", "Banana", "Cherry" }
Dim fruits As New List(Of String)(fruitArray)Aqui, um novo array é criado e depois usado para inicializar uma lista. Isso converte o array fruitArray em uma lista. Qualquer IEnumerable<t>, incluindo arrays, pode ser passado ao construtor da lista para inicialização.
Se você tiver uma coleção existente de itens, pode usar o método AddRange para adicionar múltiplos elementos a uma lista de uma vez.
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)Neste exemplo, começamos com uma lista contendo dois elementos e adicionamos múltiplos novos itens de um array usando AddRange. Esse método pode melhorar o desempenho adicionando elementos em lote, pois minimiza a necessidade de múltiplas realocações.
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 }
};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.
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");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.
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.");
}
}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 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.
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 você estiver confiante de que atende às suas necessidades, as licenças estão disponíveis a partir de $999.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
