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 der Klasse collection hinzu, sie kann mehrere Objektgruppen speichern

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 sind in C# Container, in 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 Auflistungsklassen implementieren Komponenten des Systems in C#, d.h. sie importieren Namespaces wie System.Collections und System.Collections.Generic, das verschiedene generische und nicht-generische Sammlungsklassen bietet. 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 Liste, Wörterbuch<TKey, TValue>warteschlangeund Stack sind 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

1. Liste

Ein dynamisches Array, das ein schnelles und einfaches Einfügen und Entfernen von Elementen ermöglicht, ist die Liste 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. Warteschlange und Stack

Die First-in-First-out-Sammlung (FIFO)und Last-in, First-out (LIFO) paradigmen werden jeweils durch die generische Warteschlange und generischer Stack klassen. 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)

4. HashSet

Eindeutige Elemente, die in einer ungeordneten Sammlung angeordnet sind, werden durch das HashSet dargestellt klasse. 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 macht es einfach, 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 nützlichen Werkzeug für C#-Entwickler.

Das herausragende Merkmal von IronPDF ist seine HTML zu PDF fähigkeit, alle Layouts und Stile beizubehalten. 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. Diejenigen, die bereits mit Webentwicklungswerkzeugen vertraut sind und HTML und CSS zur Erstellung von PDFs verwenden möchten, werden dies sehr hilfreich finden.
• 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, so dass die Klarheit und visuelle Integrität der endgültigen Dokumente gewährleistet ist.
• Plattformübergreifende Kompatibilität: IronPDF kann in einer Vielzahl von Anwendungen und auf einer Reihe von Plattformen verwendet werden, da es sowohl mit dem .NET Core als auch mit dem .NET-Framework funktioniert.

• Optimierung der Leistung: Selbst bei der Arbeit mit großen oder komplizierten PDF-Dokumenten ist die Bibliothek darauf ausgelegt, eine effiziente PDF-Produktion und -Rendering zu gewährleisten.

  Weitere Informationen über die IronPDF-Dokumentation finden Sie unter *hier.

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. Es gibt so viele verschiedene Typen, wie z.B. List, Wörterbuch<TKey, TValue>und HashSetkönnen Entwickler die Sammlung auswählen, die ihren Anforderungen am besten entspricht.

Stellen Sie sich vor, Sie müssen einen Bericht erstellen, der eine Liste von Verkaufstransaktionen enthält. Die Daten können mithilfe einer Liste effektiv organisiert werdendie als Grundlage für die 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. Weitere Informationen über den Code finden Sie unter *hier.

Schlussfolgerung

Die Kombination von Sammlungen mit IronPDF bietet eine Fülle 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 $749 Lite-Edition von IronPDF beinhaltet ein Jahr Software-Support, Upgrade-Optionen und eine permanente 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, die Lizenzierung und die kostenlose Testversion von IronPDF zu erfahren, besuchen Sie bitte die Lizenz *Seite. Weitere Informationen über Iron Software finden Sie hier Webseite.