Jakie są podstawowe metody inicjalizacji listy w C#?

W C# można zainicjalizować listę, tworząc instancję klasy List<T> , gdzie T jest typem elementów. Na przykład, List<string> fruits = new List<string>(); to podstawowy sposób inicjalizacji listy.

Jak składnia inicjalizatora kolekcji może poprawić inicjalizację listy w C#?

Składnia inicjalizatora kolekcji pozwala na wypełnienie listy bezpośrednio podczas jej tworzenia, co sprawia, że kod jest bardziej zwięzły. Na przykład: List<string> fruits = new List<string> { 'Apple', 'Banana', 'Cherry' }; .

Jaki jest cel składni inicjalizatora obiektu podczas inicjalizacji list?

Składnia inicjalizatora obiektu jest użyteczna do inicjalizacji list z niestandardowymi obiektami, pozwala na ustawienie wartości właściwości podczas tworzenia listy. Na przykład: new Person { Name = 'John', Age = 30 }; w liście.

Czy można ustawić początkową pojemność listy i dlaczego jest to pomocne?

Tak, ustawienie początkowej pojemności listy może poprawić wydajność, zmniejszając potrzebę realokacji pamięci w miarę wzrostu listy. Przykład: List<string> fruits = new List<string>(10); .

Jak można zainicjalizować listę z istniejącej tablicy w C#?

Można zainicjalizować listę z tablicy używając konstruktóra listy, który akceptuje IEnumerable<T> . Przykład: List<string> fruits = new List<string>(fruitArray); .

Jaką rolę odgrywa metoda AddRange w inicjalizacji listy?

Metoda AddRange dodaje wiele elementów z kolekcji do listy jednocześnie, optymalizując wydajność poprzez minimalizację realokacji. Przykład: fruits.AddRange(moreFruits); .

Jak można inicjalizować niestandardowe obiekty w liście za pomocą inicjalizatorów?

Niestandardowe obiekty można inicjalizować w liście, używając kombinacji inicjalizatorów obiektów i kolekcji, co pozwala na utworzenie listy w pojedynczym wyrażeniu. Przykład: new List<Person> { new Person { Name = 'Alice', Age = 28 } }; .

Czym są metody rozszerzające i jaki mają związek z inicjalizacją list?

Metody rozszerzające pozwalają na dodanie nowych funkcjonalności do istniejących typów. Na przykład, metody rozszerzające takie jak InitializeWith mogą być napisane, aby usprawnić inicjalizację i wypełnianie list.

Jak można konwertować listy na PDF w C#?

Używając IronPDF, można przekonwertować listę na tabelę HTML i wyrenderować ją jako PDF, upraszczając proces generowania PDF-ów z kolekcji danych w C#.

Czy dostępna jest wersja próbna do generowania PDF-ów z kolekcji danych?

Tak, IronPDF oferuje wersję próbną, umożliwiającą przetestowanie możliwości generowania PDF-ów z kolekcji danych bez początkowego zakupu.

Biblioteka PDF dla C#

Explore IronPDF Bezpłatna próba

HTML do PDF

Online Demo Zobacz wszystkie przykłady kodu %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

AKTUALNOŚCI DLA PROGRAMISTÓW

C# Inicjalizacja listy (Jak to działa dla programistów)

Jacob Mellor

Updated: 21 kwietnia 2026

Listy są częścią przestrzeni nazw System.Collections.Generic i są wszechstronne w obsłudze zbiorów danych. Listy w języku C# są dynamiczne, co oznacza, że ich rozmiar może się zmieniać w czasie wykonywania. Ta elastyczność jest bardzo pomocna w wielu scenariuszach inżynierii oprogramowania, w których liczba elementów nie jest znana z góry. Przyjrzyjmy się różnym sposobom inicjalizacji listy w języku C#. Omówimy podstawowe techniki, składnię inicjalizatora obiektów, inicjalizatory kolekcji oraz bibliotekę IronPDF.

Inicjalizacja listy podstawowej

Aby zainicjowac liste, nalezy najpierw utworzyc instancje klasy List<t>, gdzie T jest typem elementow w liscie. Najczesciej uzywanym typem jest string, ale mozna uzyc dowolnego typu.

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

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 Module

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 Module

W powyzszym przykladzie utworzylismy pusta liste i dodalismy elementy za pomoca metody Add. List<string> reprezentuje liste lancuchow znakow, a my uzylismy metody Add, aby ja wypelnic wartosciami.

Korzystanie ze składni inicjalizatora kolekcji

Język C# oferuje bardziej zwięzły sposób inicjalizacji listy przy użyciu składni inicjalizatora kolekcji. To pozwala wypelnic liste bezposrednio podczas tworzenia, bez koniecznosci wielokrotnego wywolywania metody 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

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

Ten kod osiąga ten sam wynik co poprzedni przykład, ale w bardziej zwięzłej formie. Inicjalizatory kolekcji pozwalają zainicjować listę wartości w jednym wyrażeniu, dzięki czemu kod staje się bardziej czytelny.

Inicjalizatory obiektów i inicjalizacja list

Składnia inicjalizatora obiektów to kolejny sposób inicjalizacji list, głównie podczas pracy z obiektami niestandardowymi. Oto przykład działania inicjalizatorów obiektów w przypadku list:

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

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

W tym przykladzie tworzymy liste obiektow Person uzywajac inicjalizatorow obiektow. Klasa Person ma dwie wlasciwosci: Name i Age, ktorym wyraznie przypisuje sie wartosci podczas tworzenia listy.

Tworzenie listy o początkowej wielkości

Chociaż listy mają dynamiczny rozmiar, można określić początkową pojemność, jeśli wiadomo, ile elementów będzie zawierała lista. Może to poprawić wydajność poprzez zmniejszenie liczby realokacji pamięci.

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

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

Powoduje to utworzenie pustej listy o początkowej pojemności 10. Chociaż nie dodaje ona elementów, przydziela wystarczającą ilość pamięci, aby pomieścić do 10 elementów bez zmiany rozmiaru wewnętrznej tablicy.

Inicjalizacja listy z tablicy

Mozesz rowniez zainicjowac liste z istniejacej tablicy, uzywajac konstruktora listy, ktory przyjmuje argument IEnumerable<t>. Jest to przydatne, gdy masz tablicę i chcesz przekształcić ją w listę, aby uzyskać większą elastyczność.

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

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

Tutaj, nowa tablica jest tworzona i nastepnie uzywana do inicjalizacji listy. To przeksztalca tablice fruitArray w liste. Dowolna IEnumerable<t>, wlaczajac tablice, moze byc przekazana do konstruktora listy do inicjalizacji.

Korzystanie z metody AddRange

Jesli masz istniejaca kolekcje elementow, mozesz uzyc metody AddRange, aby dodac do listy wiele elementow naraz.

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)

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

W tym przykladzie zaczynamy od listy zawierajacej dwa elementy i dodajemy kilka nowych elementow z tablicy za pomoca AddRange. Metoda ta może poprawić wydajność poprzez dodawanie elementów zbiorczo, ponieważ minimalizuje potrzebę wielokrotnego przydzielania pamięci.

Inicjalizacja listy z obiektami niestandardowymi

Podczas inicjalizacji listy obiektów niestandardowych można łączyć inicjalizatory obiektów z inicjalizatorami kolekcji, aby tworzyć złożone struktury danych w jednym wyrażeniu.

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

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

Technika ta pozwala na tworzenie i inicjalizację listy obiektów w jednym wyrażeniu, dzięki czemu kod jest zwięzły i łatwy do odczytania.

Inicjalizacja listy za pomocą metod rozszerzeń

Można również zaimplementować metodę rozszerzenia, aby zainicjować listę w niestandardowy sposób. Metody rozszerzeń zapewniają mechanizm ulepszania istniejących typów o nowe możliwości bez zmiany ich pierwotnej struktury.

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

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

Tutaj, definiujemy metode rozszrzenia, InitializeWith, ktora dodaje elementy do listy i zwraca sama liste. Pozwala to na połączenie inicjalizacji i wypełniania listy.

IronPDF: biblioteka PDF dla języka C#

C# Initialize List (Jak to dziala dla deweloperow): Rysunek 1 - IronPDF: Biblioteka PDF w C#

Jeśli masz listę, na przykład listę owoców, możesz szybko przekształcić ją w tabelę HTML i wygenerować plik PDF za pomocą IronPDF — wszystko to za pomocą zaledwie kilku wierszy kodu. Proces jest prosty: zainicjuj swoją listę, przekonwertuj ją na HTML i pozwól IronPDF wygenerować plik PDF. Oto przykład:

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

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

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

C# Initialize List (Jak to dziala dla deweloperow): Rysunek 2 - Przykladowe wyjscie

Ten kod inicjuje listę, tworzy na jej podstawie tabelę HTML i wykorzystuje IronPDF do utworzenia pliku PDF. Jest to prosty i bezpośredni sposób generowania plików PDF na podstawie zbiorów danych.

Wnioski

Inicjalizacja listy w języku C# to podstawowa koncepcja, którą powinien opanować każdy inżynier oprogramowania. Niezależnie od tego, czy pracujesz z prostymi listami ciągów znaków, czy złożonymi listami obiektów, język C# oferuje kilka metod pozwalających na wydajną inicjalizację i wypełnianie list. Od podstawowej inicjalizacji po inicjalizatory obiektów i kolekcji — techniki te pomagają pisać przejrzysty, zwięzły i łatwy w utrzymaniu kod.

IronPDF oferuje bezpłatną wersję próbną, która pozwala wypróbować produkt bez konieczności ponoszenia początkowych kosztów. Kiedy jestes pewien, ze spelnia twoje potrzeby, licencje sa dostepne od $999.

Jacob Mellor

Czat z zespołem inżynierów teraz

Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.

...

Czytaj więcej