C# Initialisierungsliste (Wie es für Entwickler funktioniert)

Grundlegende Listeninitialisierung

Um eine Liste zu initialisieren, erstellen Sie zunächst eine Instanz der Klasse List<T>, wobei T der Typ der Elemente in der Liste ist. Der gebräuchlichste Typ ist string, Sie können aber jeden beliebigen 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 mithilfe der Methode Add hinzugefügt. Der Parameter List<string> stellt eine Liste von Zeichenketten dar, und wir haben die Methode Add verwendet, um sie mit Werten zu füllen.

Verwendung der Syntax von Sammlungsinitialisierern

C# bietet eine kürzere Möglichkeit, eine Liste mithilfe der Syntax für Sammlungsinitialisierer zu initialisieren. Dies ermöglicht es Ihnen, die Liste direkt beim Erstellen zu füllen, ohne die Methode Add 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 dasselbe Ergebnis wie das vorherige Beispiel, jedoch in einer kompakteren Form. Mit Sammlungsinitialisierern können Sie eine Liste mit Werten in einer einzigen Anweisung initialisieren, was Ihren Code besser lesbar macht.

Objektinitialisierer und Listeninitialisierung

Die Syntax für Objektinitialisierer ermöglicht eine einfache Listeninitialisierung, besonders mit benutzerdefinierten Objekten. Hier ist ein Beispiel dafür, wie Objektinitialisierer 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 mithilfe von Objektinitialisierern eine Liste von Person-Objekten. Die Klasse Person hat zwei Eigenschaften: Name und Age, denen beim Erstellen der Liste explizit Werte zugewiesen werden.

Erstellen einer Liste mit einer Anfangsgröße

Obwohl Listen dynamisch in der Größe sind, können Sie eine anfängliche Kapazität angeben, wenn Sie ungefähr wissen, wie viele Elemente die Liste enthalten wird. Dies kann die Leistung verbessern, indem die Anzahl der Speicherneuzuweisungen reduziert 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

Dies erstellt eine leere Liste mit einer anfänglichen Kapazität von 10. Obwohl keine Elemente hinzugefügt werden, wird genügend Speicher zugewiesen, um bis zu 10 Elemente ohne Größenänderung des internen Arrays zu enthalten.

Initialisierung einer Liste aus einem Array

Sie können auch eine Liste aus einem bestehenden Array initialisieren, indem Sie den Listenkonstruktor verwenden, der ein IEnumerable<T> Argument akzeptiert. Dies ist nützlich, wenn Sie ein Array haben und es in eine Liste umwandeln möchten, um Flexibilität zu gewinnen.

// 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 anschließend zur Initialisierung einer Liste verwendet. Dadurch wird das Array fruitArray in eine Liste umgewandelt. Beliebige Objekte IEnumerable<T>, einschließlich Arrays, können dem Listenkonstruktor zur Initialisierung übergeben werden.

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)

Initialisierung einer Liste mit benutzerdefinierten Objekten

Beim Initialisieren einer Liste mit 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, was den Code prägnant und leicht lesbar macht.

Listeninitialisierung mit Erweiterungsmethoden

Sie können auch eine Erweiterungsmethode implementieren, um eine Liste auf benutzerdefinierte Weise zu initialisieren. Erweiterungsmethoden bieten einen Mechanismus, um bestehende Typen mit neuen Funktionen zu verbessern, ohne ihre ursprüngliche Struktur zu ä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 Elemente zur Liste hinzufügt und die Liste selbst zurückgibt. Dadurch können Sie die Initialisierung und Füllung 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, alles mit nur wenigen Codezeilen. Das Verfahren ist unkompliziert: Initialisieren Sie Ihre Liste, konvertieren Sie sie in HTML und lassen Sie 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 eine HTML-Tabelle daraus und verwendet IronPDF, um eine PDF-Datei zu erstellen. Es ist ein einfacher und direkter Weg, PDFs aus Ihren Datensammlungen zu generieren.

Abschluss

Die Listeninitialisierung in C# ist ein grundlegendes Konzept, das jeder Software-Ingenieur beherrschen sollte. Egal, ob Sie mit einfachen Listen von Zeichenfolgen oder komplexen Listen von Objekten arbeiten, C# bietet verschiedene Methoden, um Listen effizient zu initialisieren und zu füllen. Von der grundlegenden Initialisierung bis hin zu Objekt- und Sammlungsinitialisierern helfen Ihnen diese Techniken, sauberen, prägnanten und wartbaren Code zu schreiben.

IronPDF bietet eine kostenlose Testversion, mit der Sie das Produkt ohne anfängliche Investition ausprobieren können. Wenn Sie sicher sind, dass es Ihren Bedürfnissen entspricht, sind Lizenzen ab $999 erhältlich.