C# Initialize List (Wie es für Entwickler funktioniert)

Listen sind Teil des System.Collections.Generic-Namespaces und vielseitig einsetzbar für die Verwaltung von Datensammlungen. Listen in C# sind dynamisch, d. h. ihre Größe kann sich während der Laufzeit ändern. Diese Flexibilität ist in vielen Softwareentwicklungsszenarien sehr hilfreich, in denen die Anzahl der Elemente nicht im Voraus bekannt ist. Sehen wir uns nun die verschiedenen Möglichkeiten an, eine Liste in C# zu initialisieren. Wir werden grundlegende Techniken, Objektinitialisierer-Syntax, Sammlungsinitialisierer und die IronPDF-Bibliothek behandeln.

Grundlegende Listeninitialisierung

Um eine Liste zu initialisieren, beginnen Sie mit der Erstellung einer Instanz der Klasse List<T>, wobei T der Typ der Elemente in der Liste ist. Der am häufigsten verwendete Typ ist string, aber Sie können jeden Typ verwenden.

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

Im obigen Beispiel haben wir eine leere Liste erstellt und Elemente mit der Add-Methode hinzugefügt. Die Liststellt eine Liste von Zeichenfolgen dar, und wir haben die Add-Methode verwendet, um sie mit Werten zu füllen.

Verwendung der Syntax von Sammlungsinitialisierern

C# bietet eine prägnantere Methode zur Initialisierung einer Liste mit der Syntax für Auflistungsinitialisierungen. So können Sie die Liste direkt bei ihrer Erstellung auffüllen, ohne die Add-Methode wiederholt aufrufen zu müssen.

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

Dieser Code erzielt das gleiche Ergebnis wie das vorherige Beispiel, allerdings in einer kompakteren Form. Auflistungsinitialisierer ermöglichen es Ihnen, eine Liste mit Werten in einer einzigen Anweisung zu initialisieren, wodurch Ihr Code lesbarer wird.

Objektinitialisierer und Listeninitialisierung

Die Objektinitialisierungssyntax ist eine weitere Möglichkeit, Listen zu initialisieren, vor allem bei der Arbeit mit benutzerdefinierten Objekten. Hier ist ein Beispiel dafür, wie Objektinitialisierungen mit Listen funktionieren:

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

In diesem Beispiel erstellen wir eine Liste von Person-Objekten mithilfe von Objektinitialisierern. Die Klasse Person hat zwei Eigenschaften: Name und Alter, denen bei der Erstellung der Liste explizit Werte zugewiesen werden.

Erstellen einer Liste mit einer Anfangsgröße

Während Listen eine dynamische Größe haben, können Sie eine Anfangskapazität angeben, wenn Sie ungefähr wissen, wie viele Elemente die Liste enthalten wird. Dies kann die Leistung verbessern, indem die Anzahl der Speicherneuzuweisungen verringert wird.

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

Dadurch wird eine leere Liste mit einer anfänglichen Kapazität von 10 erstellt. Obwohl es keine Elemente hinzufügt, wird genügend Speicher zugewiesen, um bis zu 10 Elemente zu speichern, ohne die Größe des internen Arrays zu ändern.

Initialisierung einer Liste aus einem Array

Sie können auch eine Liste aus einem bestehenden Array initialisieren, indem Sie den Listen-Konstruktor verwenden, der ein IEnumerable<T>-Argument nimmt. Dies ist nützlich, wenn Sie ein Array haben und es aus Gründen der Flexibilität in eine Liste umwandeln möchten.

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

Hier wird ein neues Array erstellt und dann zur Initialisierung einer Liste verwendet. Dies konvertiert das fruitArray-Array in eine Liste. Jedes IEnumerable, einschließlich Arrays, kann dem Listenkonstruktor zur Initialisierung übergeben werden.

Verwendung der AddRange-Methode

Wenn Sie eine bestehende Sammlung von Elementen haben, können Sie die AddRange-Methode verwenden, um mehrere Elemente zu einer Liste hinzuzufügen.

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)

In diesem Beispiel beginnen wir mit einer Liste, die zwei Elemente enthält, und fügen mit AddRange mehrere neue Elemente aus einem Array hinzu. Diese Methode kann die Leistung verbessern, indem sie Elemente einzeln hinzufügt, da sie die Notwendigkeit einer mehrfachen Neuzuweisung minimiert.

Initialisierung einer Liste mit benutzerdefinierten Objekten

Bei der Initialisierung einer Liste von benutzerdefinierten Objekten können Sie Objektinitialisierer mit Sammlungsinitialisierern kombinieren, um komplexe Datenstrukturen in einem einzigen Ausdruck zu erstellen.

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

Diese Technik ermöglicht es, eine Liste von Objekten in einer einzigen Anweisung zu erstellen und zu initialisieren, wodurch der Code prägnant und leicht zu lesen ist.

Listeninitialisierung mit Erweiterungsmethoden

Sie können auch eine Erweiterungsmethode implementieren, um eine Liste auf eine benutzerdefinierte Weise zu initialisieren. Erweiterungsmethoden bieten einen Mechanismus, um bestehende Typen mit neuen Fähigkeiten zu verbessern, ohne ihre ursprüngliche Struktur zu verändern.

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

Hier definieren wir eine Erweiterungsmethode, InitializeWith, die der Liste Elemente hinzufügt und die Liste selbst zurückgibt. So können Sie die Initialisierung und den Bestand der Liste verketten.

IronPDF: C# PDF-Bibliothek

Wenn Sie eine Liste haben, wie eine Liste von Früchten, können Sie diese schnell in eine HTML-Tabelle umwandeln und als PDF rendern mit IronPDF, und das alles in nur wenigen Zeilen Code. Der Prozess ist einfach: Sie initialisieren Ihre Liste, konvertieren sie in HTML und lassen IronPDF das PDF generieren. Hier ist ein Beispiel:

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

Dieser Code initialisiert eine Liste, erstellt daraus eine HTML-Tabelle und verwendet IronPDF, um eine PDF-Datei zu erstellen. Dies ist ein einfacher und direkter Weg, um PDFs aus Ihren Datensammlungen zu erzeugen.

Schlussfolgerung

Die Initialisierung von Listen in C# ist ein grundlegendes Konzept, das jeder Softwareentwickler beherrschen sollte. Unabhängig davon, ob Sie mit einfachen Listen von Strings oder komplexen Listen von Objekten arbeiten, bietet C# mehrere Methoden, um Listen effizient zu initialisieren und aufzufüllen. Von der grundlegenden Initialisierung bis hin zu Objekt- und Auflistungsinitialisierern - diese Techniken helfen Ihnen, sauberen, präzisen und wartbaren Code zu schreiben.

IronPDF bietet eine kostenlose Testversion an, mit der Sie das Produkt ausprobieren können, ohne eine anfängliche Investition zu tätigen. Wenn Sie sicher sind, dass es Ihren Anforderungen entspricht, sind Lizenzen ab $749 erhältlich.