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

Einführung

C# ist unter den vielen verfügbaren Programmiersprachen eine beliebte und anpassungsfähige Option für Entwickler geworden. Die Idee der Sammlungen ist der Kern der umfangreichen Bibliothek und der Frameworks von C#, die einen der Hauptvorteile der Sprache darstellen. In C# ist eine Auflistung für die effektive Speicherung und Organisation von Daten unerlässlich. Sie bieten Entwicklern eine breite Palette effektiver Werkzeuge zur Lösung anspruchsvoller Programmieraufgaben. In diesem Beitrag werden wir uns näher mit Sammlungen befassen und ihre Funktionen, Typen und optimalen Nutzungsstrategien erläutern.

Verwendung von C# Sammlungen

1. Erstellen Sie ein neues Console App-Projekt.

2. Erstellen Sie ein Objekt für die Sammlung in C#.

3. Fügen Sie die Werte zur Auflistungsklasse hinzu, die mehrere Objektgruppen speichern kann.

4. Verarbeiten Sie die Wertoperationen wie Hinzufügen, Entfernen, Sortieren, usw.,

5. Zeigen Sie das Ergebnis an und entsorgen Sie das Objekt.

C#: Sammlungen verstehen

Collections in C# sind Container, mit denen Programmierer mit Objektklassen arbeiten und diese speichern können. Diese Objekte sind flexibel und können an viele Programmierumgebungen angepasst werden, und sie können von gleicher oder unterschiedlicher Art sein. Die meisten Sammlungsklassen implementieren Komponenten des Systems in C#, was das Importieren von Namespaces wie System.Collections und System.Collections.Generic bedeutet, die verschiedene Sammlungsklassen bieten, die sowohl generisch als auch nicht-generisch sind. Sammlungen ermöglichen auch die dynamische Speicherzuweisung, das Hinzufügen, Suchen und Sortieren der Elemente in den Sammlungsklassen.

Nicht-generische Sammlungsarten

ArrayList, Hashtable und Queue sind einige der nicht-generischen Auflistungsklassen, die in C# verfügbar sind und in den ersten Iterationen der Sprache enthalten waren. Diese Sammlungen bieten eine Alternative zur expliziten Festlegung der Dinge, die Sie behalten und mit denen Sie arbeiten möchten. Entwickler entscheiden sich jedoch häufig für generische Sammlungen, weil diese leistungsfähiger und typsicherer sind.

Generische Sammlungen

Spätere Iterationen von C# enthielten generische Sammlungen, um die Nachteile nicht-generischer Sammlungen zu überwinden. Sie bieten Typsicherheit während der Kompilierung und ermöglichen Entwicklern den Umgang mit eng typisierten Daten. Die generischen Sammlungsklassen List, Dictionary<TKey, TValue>, Queueund Stacksind einige, die häufig verwendet werden. Diese Sammlungen sind die erste Wahl in der modernen C#-Entwicklung, da sie eine bessere Leistung und eine Typüberprüfung zur Kompilierzeit bieten.

Schlüssel C# Auflistungstypen

Liste

Eine dynamische Array, die eine schnelle und einfache Einfügung und Entfernung von Elementen ermöglicht, ist die List<T>-Klasse. Sie ist eine flexible Option für Situationen, in denen eine in der Größe veränderbare Sammlung benötigt wird, da sie Möglichkeiten zum Filtern, Suchen und Manipulieren von Komponenten bietet.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6); // adds element '6' to the end
numbers.Remove(3); // removes all the items that are '3'

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6); // adds element '6' to the end
numbers.Remove(3); // removes all the items that are '3'

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
numbers.Add(6) ' adds element '6' to the end
numbers.Remove(3) ' removes all the items that are '3'

2. Dictionary<TKey, TValue>

Eine Sammlung von Schlüssel-Wert-Paaren wird durch die Klasse Dictionary<TKey, TValue> dargestellt, die eine schnelle Suche ermöglicht. Sie wird häufig in Situationen eingesetzt, in denen ein schneller Zugriff auf Daten über einen speziellen Schlüsselwert entscheidend ist. Dieser Schlüssel wird für den Zugriff auf Elemente innerhalb des Wörterbuchs verwendet.

Dictionary<string, int> ageMap = new Dictionary<string, int>();
ageMap.Add("John", 25); // the string "John" is the key that can access the value 25
ageMap["Jane"] = 30; // setting the key "Jane" to hold the value 30

Dictionary<string, int> ageMap = new Dictionary<string, int>();
ageMap.Add("John", 25); // the string "John" is the key that can access the value 25
ageMap["Jane"] = 30; // setting the key "Jane" to hold the value 30

Dim ageMap As New Dictionary(Of String, Integer)()
ageMap.Add("John", 25) ' the string "John" is the key that can access the value 25
ageMap("Jane") = 30 ' setting the key "Jane" to hold the value 30

3. Queueund Stack

Die First-In-First-Out-Sammlung (FIFO) und die Last-In-First-Out (LIFO)-Paradigmen werden jeweils von den generischen Klassen Queueund Stackimplementiert. Sie können verwendet werden, um Elemente in einer bestimmten Reihenfolge zu verwalten, die den Anforderungen der Anwendung entspricht.

Queue<string> tasks = new Queue<string>(); // creating a queue class
tasks.Enqueue("Task 1"); // adding to the queue
tasks.Enqueue("Task 2");
Stack<double> numbers = new Stack<double>(); // creating a stack class
numbers.Push(3.14); // adding to the stack
numbers.Push(2.71);

Queue<string> tasks = new Queue<string>(); // creating a queue class
tasks.Enqueue("Task 1"); // adding to the queue
tasks.Enqueue("Task 2");
Stack<double> numbers = new Stack<double>(); // creating a stack class
numbers.Push(3.14); // adding to the stack
numbers.Push(2.71);

Dim tasks As New Queue(Of String)() ' creating a queue class
tasks.Enqueue("Task 1") ' adding to the queue
tasks.Enqueue("Task 2")
Dim numbers As New Stack(Of Double)() ' creating a stack class
numbers.Push(3.14) ' adding to the stack
numbers.Push(2.71)

HashSet

Einzigartige Elemente, die in einer ungeordneten Sammlung angeordnet sind, werden durch die HashSet<T>-Klasse dargestellt. Es bietet effektive Möglichkeiten zur Durchführung von Mengenoperationen wie Differenz, Vereinigung und Schnittmenge.

HashSet<int> setA = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> setB = new HashSet<int> { 3, 4, 5, 6 };
HashSet<int> unionSet = new HashSet<int>(setA);
unionSet.UnionWith(setB); // combining setA and setB

HashSet<int> setA = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> setB = new HashSet<int> { 3, 4, 5, 6 };
HashSet<int> unionSet = new HashSet<int>(setA);
unionSet.UnionWith(setB); // combining setA and setB

Dim setA As New HashSet(Of Integer) From {1, 2, 3, 4}
Dim setB As New HashSet(Of Integer) From {3, 4, 5, 6}
Dim unionSet As New HashSet(Of Integer)(setA)
unionSet.UnionWith(setB) ' combining setA and setB

IronPDF

Eine C#-Bibliothek namens IronPDF vereinfacht es, PDF-Dokumente in .NET-Anwendungen zu erstellen, zu bearbeiten und anzuzeigen. Es bietet zahlreiche Lizenzierungsmöglichkeiten, plattformübergreifende Kompatibilität, hochwertiges Rendering und die Umwandlung von HTML in PDF. Die benutzerfreundliche API von IronPDF erleichtert den Umgang mit PDFs und macht es zu einem wertvollen Werkzeug für C#-Entwickler.

Die herausragende Funktion von IronPDF ist seine HTML-zu-PDF-Konvertierungs-Fähigkeit, die alle Layouts und Stile beibehält. Es generiert PDFs aus Webinhalten und eignet sich damit hervorragend für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können mühelos in PDFs umgewandelt werden.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Die wichtigsten Funktionen von IronPDF sind:

• HTML in PDF umwandeln: Mit IronPDF können Programmierer PDF-Dokumente aus HTML-Text, einschließlich CSS und JavaScript, erstellen. Dies ist besonders nützlich für diejenigen, die bereits mit Webentwicklungswerkzeugen vertraut sind und HTML und CSS zur Erstellung von PDFs verwenden möchten.
• PDF-Erzeugung und -Manipulation: Die Bibliothek bietet die Möglichkeit, PDF-Dokumente von Grund auf programmatisch zu erstellen. Darüber hinaus erleichtert es die Bearbeitung bereits vorhandener PDFs und ermöglicht Vorgänge wie die Extraktion von Text, das Hinzufügen von Wasserzeichen, das Teilen von PDFs und vieles mehr.
• Überlegenes Rendering: IronPDF verwendet eine Rendering-Engine, um eine PDF-Ausgabe von höchstem Niveau zu erzeugen, die sicherstellt, dass die endgültigen Dokumente klar und visuell einwandfrei sind.
• Plattformübergreifende Kompatibilität: IronPDF ist so konzipiert, dass es sowohl mit dem .NET Core als auch mit dem .NET Framework funktioniert, so dass es in verschiedenen Anwendungen und auf einer Reihe von Plattformen verwendet werden kann.

• Optimierung der Leistung: Selbst bei der Arbeit mit großen oder komplizierten PDF-Dokumenten ist die Bibliothek so konzipiert, dass sie eine effiziente PDF-Produktion und -Rendering ermöglicht.

  Um mehr über die IronPDF-Dokumentation zu erfahren, konsultieren Sie die IronPDF-Dokumentation.

Installation von IronPDF

Installieren Sie zunächst die IronPDF-Bibliothek über die Paketverwaltungskonsole oder den NuGet-Paketmanager:

Install-Package IronPdf

Eine weitere Möglichkeit besteht darin, mit dem NuGet Package Manager nach dem Paket "IronPDF" zu suchen. Aus dieser Liste können wir das benötigte Paket aus allen mit IronPDF verbundenen NuGet-Paketen auswählen und herunterladen.

Dokumentenerstellung mit Sammlungen mit IronPDF

Bevor wir uns mit der Schnittstelle zu IronPDF befassen, ist es wichtig zu verstehen, welche Rolle Sammlungen in Datenstrukturen und -organisation spielen. Entwickler können mit Hilfe von Sammlungen Gruppierungen von Dingen in organisierter Weise speichern, abrufen und ändern. Mit so vielen verschiedenen Typen verfügbar, wie List, Dictionary<TKey, TValue> und HashSet, können Entwickler die Sammlung auswählen, die am besten zu ihren Anforderungen passt.

Stellen Sie sich vor, Sie müssen einen Bericht erstellen, der eine Liste von Verkaufstransaktionen enthält. Die Daten können effektiv mit einer Listeorganisiert werden, die als Grundlage für weitere Verarbeitung und Anzeige dient.

public class Transaction
{
    public string ProductName { get; set; }
    public decimal Amount { get; set; }
    public DateTime Date { get; set; }
}
List<Transaction> transactions = new List<Transaction>
{
    new Transaction { ProductName = "Product A", Amount = 100.50m, Date = DateTime.Now.AddDays(-2) },
    new Transaction { ProductName = "Product B", Amount = 75.20m, Date = DateTime.Now.AddDays(-1) },
    // Add more transactions as needed
};

public class Transaction
{
    public string ProductName { get; set; }
    public decimal Amount { get; set; }
    public DateTime Date { get; set; }
}
List<Transaction> transactions = new List<Transaction>
{
    new Transaction { ProductName = "Product A", Amount = 100.50m, Date = DateTime.Now.AddDays(-2) },
    new Transaction { ProductName = "Product B", Amount = 75.20m, Date = DateTime.Now.AddDays(-1) },
    // Add more transactions as needed
};

Public Class Transaction
	Public Property ProductName() As String
	Public Property Amount() As Decimal
	Public Property [Date]() As DateTime
End Class
Private transactions As New List(Of Transaction) From {
	New Transaction With {
		.ProductName = "Product A",
		.Amount = 100.50D,
		.Date = DateTime.Now.AddDays(-2)
	},
	New Transaction With {
		.ProductName = "Product B",
		.Amount = 75.20D,
		.Date = DateTime.Now.AddDays(-1)
	}
}

In der PDF-Datei erstellen wir eine einfache Tabelle, in der der Produktname, der Transaktionsbetrag und das Datum für jedes Produkt aufgeführt sind.

var pdfDocument = new IronPdf.HtmlToPdf();
// HTML content with a table populated by data from the 'transactions' list
string htmlContent = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>";
foreach (var transaction in transactions)
{
    htmlContent += $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>";
}
htmlContent += "</table>";
// Convert HTML to PDF
PdfDocument pdf =  pdfDocument.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(pdfFilePath);

var pdfDocument = new IronPdf.HtmlToPdf();
// HTML content with a table populated by data from the 'transactions' list
string htmlContent = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>";
foreach (var transaction in transactions)
{
    htmlContent += $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>";
}
htmlContent += "</table>";
// Convert HTML to PDF
PdfDocument pdf =  pdfDocument.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(pdfFilePath);

Dim pdfDocument = New IronPdf.HtmlToPdf()
' HTML content with a table populated by data from the 'transactions' list
Dim htmlContent As String = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>"
For Each transaction In transactions
	htmlContent &= $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>"
Next transaction
htmlContent &= "</table>"
' Convert HTML to PDF
Dim pdf As PdfDocument = pdfDocument.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs(pdfFilePath)

Die Entwickler haben die Möglichkeit, das PDF-Dokument auf der Festplatte zu speichern oder es den Benutzern zu zeigen, sobald es erstellt wurde. IronPDF bietet mehrere Ausgabemöglichkeiten, darunter Browser-Streaming, Dateispeicherung und die Integration von Cloud-Speichern.

Der obige Bildschirm zeigt die mit dem obigen Code erzeugte Ausgabe. Um mehr über den Code zu erfahren, siehe Beispiel für die Verwendung von HTML zur Erstellung eines PDF.

Schlussfolgerung

Durch die Kombination von Collections mit IronPDF ergeben sich eine Vielzahl von Möglichkeiten für die dynamische Dokumentenerstellung. Entwickler können Daten effektiv verwalten und organisieren, indem sie Sammlungen verwenden, und IronPDF macht es einfach, visuell schöne PDF-Dokumente zu erstellen. Die kombinierte Leistung von IronPDF und Collections bietet eine zuverlässige und anpassungsfähige Lösung für die Produktion dynamischer Inhalte in C#-Anwendungen, unabhängig von der Art des Dokuments, das Sie erstellen - Rechnungen, Berichte oder andere Dokumente.

Die Lite-Edition von IronPDFs $749 umfasst ein Jahr Software-Support, Upgrade-Optionen und eine dauerhafte Lizenz. Die Nutzer haben außerdem die Möglichkeit, das Produkt während der mit einem Wasserzeichen versehenen Testphase unter realen Bedingungen zu testen. Um mehr über die Kosten, Lizenzierung und die kostenlose Testversion von IronPDF zu erfahren, besuchen Sie bitte die IronPDF Licensing Information. Weitere Informationen zu Iron Software finden Sie auf der Iron Software Website.