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

Basische Listeninitialisierung

Um eine Liste zu initialisieren, beginnen Sie mit der Erstellung einer Instanz der List-Klasse, wobei T der Typ der Listenelemente ist. Der häufigste 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);
        }
    }
}

Im obigen Beispiel haben wir eine leere Liste erstellt und Elemente mithilfe der Add-Methode hinzugefügt. Die List<string> repräsentiert eine Liste von Zeichenfolgen, und wir haben die Add-Methode 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 bei der Erstellung zu fü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" };
}

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

In diesem Beispiel erstellen wir eine Liste von Person-Objekten mithilfe von Objektinitialisierern. Die Person-Klasse 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

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 vorhandenen Array initialisieren, indem Sie den Listen-Konstruktor verwenden, der ein IEnumerable-Argument annimmt. 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);

Hier wird ein neues Array erstellt und dann verwendet, um eine Liste zu initialisieren. Dies konvertiert das fruitArray-Array in eine Liste. Jede IEnumerable, einschließlich Arrays, kann dem Listen-Konstruktor 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);

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

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

Hier definieren wir eine Erweiterungsmethode InitializeWith, die der Liste Elemente 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.");
    }
}

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 überzeugt sind, dass es Ihren Anforderungen entspricht, sind Lizenzen ab $799 verfügbar.