Was ist eine Pair-Klasse in C#?

Eine Pair-Klasse in C# ist eine einfache Datenstruktur, die entwickelt wurde, um zwei verwandte Werte zu halten. Sie ermöglicht einen einfachen Zugriff auf ihre Eigenschaften als öffentliche Felder und ist eine bequeme Alternative zu Tupeln, wenn Kapselung keine Priorität hat.

Wie unterscheidet sich die Pair-Klasse von einem Tuple in C#?

Die Pair-Klasse unterscheidet sich von einem Tuple dadurch, dass sie ihre Objektverweise direkt über öffentliche Felder offenlegt, was die Lesbarkeit und Flexibilität erhöht. Tupel hingegen sind unveränderlich und greifen über Eigenschaften wie Item1 und Item2 auf ihre Elemente zu.

Was sind die Vorteile der Verwendung der Pair-Klasse gegenüber Tupeln?

Die Vorteile der Verwendung der Pair-Klasse im Vergleich zu Tupeln sind eine verbesserte Code-Lesbarkeit durch die Verwendung beschreibender Eigenschaftsnamen anstelle von Item1 und Item2 sowie die Möglichkeit, die Werte zu ändern, da Paare veränderlich sind.

Kann ich die Pair-Klasse verwenden, um Schlüssel-Wert-Paare zu speichern?

Ja, die Pair-Klasse ist besonders nützlich, um Schlüssel-Wert-Paare in einer lesbareren Weise im Vergleich zu Tupeln zu speichern, da sie durch öffentliche Felder direkten Zugriff auf Werte bietet.

Was sind einige häufige Szenarien für die Verwendung der Pair-Klasse in C#?

Häufige Szenarien für die Verwendung der Pair-Klasse umfassen das Speichern von Koordinaten, das Zurückgeben mehrerer Werte aus einer Methode und das Verwalten von Schlüssel-Wert-Paar-Associationen in einem lesbaren Format.

Warum würde ein Entwickler die IronPDF-Bibliothek verwenden?

Ein Entwickler könnte die IronPDF-Bibliothek nutzen, um PDFs aus HTML-Inhalten zu erstellen. Sie stellt sicher, dass das ursprüngliche Layout und der Stil erhalten bleiben, was die Erstellung professioneller Dokumente wie Berichte und Rechnungen vereinfacht.

Wie kann ich ein PDF aus einer HTML-Datei in C# erstellen?

Sie können ein PDF aus einer HTML-Datei in C# mit der IronPDF-Bibliothek erstellen. Sie bietet Methoden wie RenderHtmlAsPdf zum Umwandeln von HTML-Strings und -Dateien in hochwertige PDF-Dokumente.

Was ist der Vorteil der Verwendung einer Bibliothek zur PDF-Erstellung?

Die Verwendung einer Bibliothek wie IronPDF zur PDF-Erstellung bietet vereinfachte Prozesse zur Erstellung hochwertiger PDF-Dokumente und stellt sicher, dass Layouts und Stile aus verschiedenen Inhaltsquellen genau beibehalten werden.

Welche Rollen spielen die Pair-Klasse und die IronPDF-Bibliothek im Werkzeugkasten eines Entwicklers?

Die Pair-Klasse und die IronPDF-Bibliothek erweitern den Werkzeugkasten eines Entwicklers, indem sie eine effiziente Datenstrukturverwaltung mit Paaren und zuverlässige Dokumentenerstellungsmöglichkeiten mit IronPDF bieten, was sie wertvoll für den Umgang mit komplexen Daten und Dokumenten-Workflows macht.

What alternatives exist to using the Dictionary class for key-value pairs in C#?

Alternative options include `ConcurrentDictionary ` for thread-safe dictionary operations and `ImmutableDictionary ` for scenarios that require immutability. Custom key-value pair classes can also be created for specific needs.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# Pair-Klasse (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 23. April 2026

Ein Paar ist eine einfache Datenstruktur, die zwei verwandte Werte hält. Es bietet eine bequeme Möglichkeit, zwei unterschiedliche Datenelemente zusammenzubundeln. Paare werden häufig verwendet, wenn eine Methode zwei Werte zurückgeben muss oder bei der Arbeit mit Schlüssel-Wert-Zuordnungen.

In C# greifen Entwickler oft auf die Verwendung von Tupeln (Tuple<T1, T2>) zurück, um Werte zu paaren. Allerdings sind Tupel unveränderlich, und auf ihre Elemente wird über Eigenschaften wie Item1 und Item2 zugegriffen, was bei häufiger Verwendung zu weniger lesbarem Code führen kann. Hier kommt eine benutzerdefinierte Pair-Klasse ins Spiel.

Wenn Sie eine Struktur benötigen, um zwei verwandte Objekte zu halten und die Datenverbergung keine Priorität hat, können Sie die Pair-Klasse in Ihrem Code verwenden. Die Pair-Klasse kapselt ihre Objekt-Referenzen nicht. Stattdessen macht sie sie direkt für alle aufrufenden Codes als öffentliche Klassenfelder zugänglich.

Diese Designentscheidung ermöglicht einen direkten Zugriff auf die enthaltenen Objekte ohne den Aufwand der Kapselung. Außerdem werden wir am Ende des Artikels erkunden, wie IronPDF for PDF Generation von Iron Software Overview zur Erstellung eines PDF-Dokuments verwendet werden kann.

Tupel

C# 7.0 führte Verbesserungen in der Tupel-Syntax ein, die die Arbeit mit Tupeln noch einfacher machen. So können Sie Tupel deklarieren und initialisieren:

// Tuple declaration
var person = (name: "John", age: 30);

// Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}");

// Tuple deconstruction
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}");

// Tuple declaration
var person = (name: "John", age: 30);

// Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}");

// Tuple deconstruction
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}");

' Tuple declaration
Dim person = (name:= "John", age:= 30)

' Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}")

' Tuple deconstruction
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
var(name, age) = person
Console.WriteLine($"Name: {name}, Age: {age}")

' Tuple declaration
Dim person = (name:= "John", age:= 30)

' Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}")

' Tuple deconstruction
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
var(name, age) = person
Console.WriteLine($"Name: {name}, Age: {age}")

Vorteile von Tupeln

Korrekte Syntax

Tupel ermöglichen es, komplexe Datenstrukturen mit einer prägnanten Syntax auszudrücken, ohne benutzerdefinierte Klassen oder Strukturen definieren zu müssen.

Leichtgewichtig

Tupel sind leichtgewichtige Datenstrukturen und eignen sich daher für Szenarien, in denen Sie temporäre oder Zwischenablagen für Daten benötigen.

Implizite Namensgebung

Mit der Tupel-Syntax können Sie Tupel-Elemente implizit benennen, was die Lesbarkeit des Codes verbessert und den Bedarf an Kommentaren verringert.

Mehrere Werte von Methoden zurückliefern

public (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return (quotient, remainder);
}

var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}");

public (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return (quotient, remainder);
}

var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}");

Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Quotient As Integer, Remainder As Integer)
	Dim quotient As Integer = dividend \ divisor
	Dim remainder As Integer = dividend Mod divisor
	Return (quotient, remainder)
End Function

Private result = Divide(10, 3)
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}")

Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Quotient As Integer, Remainder As Integer)
	Dim quotient As Integer = dividend \ divisor
	Dim remainder As Integer = dividend Mod divisor
	Return (quotient, remainder)
End Function

Private result = Divide(10, 3)
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}")

Vereinfachung von Methodensignaturen

public (string Name, string Surname) GetNameAndSurname()
{
    // Retrieve name and surname from a data source
    return ("John", "Doe");
}

var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");

public (string Name, string Surname) GetNameAndSurname()
{
    // Retrieve name and surname from a data source
    return ("John", "Doe");
}

var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");

Public Function GetNameAndSurname() As (Name As String, Surname As String)
	' Retrieve name and surname from a data source
	Return ("John", "Doe")
End Function

'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
var(name, surname) = GetNameAndSurname()
Console.WriteLine($"Name: {name}, Surname: {surname}")

Public Function GetNameAndSurname() As (Name As String, Surname As String)
	' Retrieve name and surname from a data source
	Return ("John", "Doe")
End Function

'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
var(name, surname) = GetNameAndSurname()
Console.WriteLine($"Name: {name}, Surname: {surname}")

Gruppierung verwandter Daten

var point = (x: 10, y: 20);
var color = (r: 255, g: 0, b: 0);
var person = (name: "Alice", age: 25);

var point = (x: 10, y: 20);
var color = (r: 255, g: 0, b: 0);
var person = (name: "Alice", age: 25);

Dim point = (x:= 10, y:= 20)
Dim color = (r:= 255, g:= 0, b:= 0)
Dim person = (name:= "Alice", age:= 25)

Dim point = (x:= 10, y:= 20)
Dim color = (r:= 255, g:= 0, b:= 0)
Dim person = (name:= "Alice", age:= 25)

Einschränkungen und Überlegungen

Während C# 7.0 Tupel erhebliche Vorteile bieten, gibt es einige Einschränkungen und Überlegungen zu beachten:

Tupel sind im Vergleich zu benutzerdefinierten Klassen oder Strukturen in ihrer Ausdruckskraft begrenzt.
Auf Tupel-Elemente wird mit Item1, Item2 usw. zugegriffen, wenn keine expliziten Namen angegeben sind, was die Lesbarkeit des Codes verringern kann.

Benutzerdefinierte Klasse paaren

public class Pair<T1, T2>
{
    public T1 First { get; set; }
    public T2 Second { get; set; }

    // Constructor to initialize the pair
    public Pair(T1 first, T2 second)
    {
        First = first;
        Second = second;
    }
}

public class Pair<T1, T2>
{
    public T1 First { get; set; }
    public T2 Second { get; set; }

    // Constructor to initialize the pair
    public Pair(T1 first, T2 second)
    {
        First = first;
        Second = second;
    }
}

Public Class Pair(Of T1, T2)
	Public Property First() As T1
	Public Property Second() As T2

	' Constructor to initialize the pair
	Public Sub New(ByVal first As T1, ByVal second As T2)
		Me.First = first
		Me.Second = second
	End Sub
End Class

Public Class Pair(Of T1, T2)
	Public Property First() As T1
	Public Property Second() As T2

	' Constructor to initialize the pair
	Public Sub New(ByVal first As T1, ByVal second As T2)
		Me.First = first
		Me.Second = second
	End Sub
End Class

In dieser Klasse werden die Typen zur Nutzungszeit definiert, und die beiden Eigenschaften werden als öffentliche Eigenschaften verfügbar gemacht.

Verwendung der Pair-Klasse

Nun, lassen Sie uns einige häufige Anwendungsfälle erkunden, in denen die Pair-Klasse von Vorteil sein kann:

1. Speichern von Koordinaten

// Creating a new instance of the Pair class to store coordinates
Pair<int, int> coordinates = new Pair<int, int>(10, 20);
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

// Creating a new instance of the Pair class to store coordinates
Pair<int, int> coordinates = new Pair<int, int>(10, 20);
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

' Creating a new instance of the Pair class to store coordinates
Dim coordinates As New Pair(Of Integer, Integer)(10, 20)
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}")

' Creating a new instance of the Pair class to store coordinates
Dim coordinates As New Pair(Of Integer, Integer)(10, 20)
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}")

2. Rückgabe mehrerer Werte aus einer Methode

// Method returning a Pair, representing both quotient and remainder
public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}

// Usage
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

// Method returning a Pair, representing both quotient and remainder
public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}

// Usage
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

' Method returning a Pair, representing both quotient and remainder
Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As Pair(Of Integer, Integer)
	Dim quotient As Integer = dividend \ divisor
	Dim remainder As Integer = dividend Mod divisor
	Return New Pair(Of Integer, Integer)(quotient, remainder)
End Function

' Usage
Private result As Pair(Of Integer, Integer) = Divide(10, 3)
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}")

' Method returning a Pair, representing both quotient and remainder
Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As Pair(Of Integer, Integer)
	Dim quotient As Integer = dividend \ divisor
	Dim remainder As Integer = dividend Mod divisor
	Return New Pair(Of Integer, Integer)(quotient, remainder)
End Function

' Usage
Private result As Pair(Of Integer, Integer) = Divide(10, 3)
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}")

3. das Speichern von Schlüssel-Werte-Paaren

// Storing a key-value pair
Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

// Storing a key-value pair
Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

' Storing a key-value pair
Dim keyValue As New Pair(Of String, Integer)("Age", 30)
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}")

' Storing a key-value pair
Dim keyValue As New Pair(Of String, Integer)("Age", 30)
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}")

Schlüssel-Werte-Paare

Schlüssel-Wert-Paare bieten eine einfache und effiziente Möglichkeit zur Zuordnung von Daten. In C# ist das Hauptwerkzeug zur Arbeit mit Schlüssel-Wert-Paaren die Dictionary<TKey, TValue>-Klasse, ein vielseitiger und leistungsstarker Sammlungstyp.

Schlüssel-Werte-Paare verstehen

Ein Schlüssel-Wert-Paar ist eine Datenstruktur, die einen eindeutigen Schlüssel mit einem Wert verknüpft. Diese Assoziation ermöglicht eine effiziente Abfrage und Manipulation von Daten basierend auf ihrem eindeutigen Bezeichner. In C# werden Schlüssel-Wert-Paare häufig für Aufgaben wie Caching, Konfigurationsmanagement und Datenspeicherung verwendet.

`Dictionary<TKey, TValue>` in C#

Die Dictionary<TKey, TValue>-Klasse in C# ist eine generische Sammlung, die Schlüssel-Wert-Paare speichert. Sie bietet schnelle Suchvorgänge basierend auf den Schlüsseln und wird häufig zur Verwaltung assoziativer Daten verwendet.

Erstellen und Auffüllen eines Wörterbuchs

Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 35 },
    { "Charlie", 25 }
};

Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 35 },
    { "Charlie", 25 }
};

Dim ages As New Dictionary(Of String, Integer) From {
	{"Alice", 30},
	{"Bob", 35},
	{"Charlie", 25}
}

Dim ages As New Dictionary(Of String, Integer) From {
	{"Alice", 30},
	{"Bob", 35},
	{"Charlie", 25}
}

Zugriff auf Werte nach Schlüssel

// Directly access a value by its key
Console.WriteLine($"Alice's age: {ages["Alice"]}");

// Directly access a value by its key
Console.WriteLine($"Alice's age: {ages["Alice"]}");

' Directly access a value by its key
Console.WriteLine($"Alice's age: {ages("Alice")}")

' Directly access a value by its key
Console.WriteLine($"Alice's age: {ages("Alice")}")

Iterieren über Schlüssel-Werte-Paare

// Iterate over all key-value pairs in the dictionary
foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

// Iterate over all key-value pairs in the dictionary
foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

' Iterate over all key-value pairs in the dictionary
For Each pair In ages
	Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}")
Next pair

' Iterate over all key-value pairs in the dictionary
For Each pair In ages
	Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}")
Next pair

Erweiterte Szenarien

Behandlung von fehlenden Schlüsseln

if (ages.TryGetValue("David", out int age))
{
    Console.WriteLine($"David's age: {age}");
}
else
{
    Console.WriteLine("David's age is not available.");
}

if (ages.TryGetValue("David", out int age))
{
    Console.WriteLine($"David's age: {age}");
}
else
{
    Console.WriteLine("David's age is not available.");
}

Dim age As Integer
If ages.TryGetValue("David", age) Then
	Console.WriteLine($"David's age: {age}")
Else
	Console.WriteLine("David's age is not available.")
End If

Dim age As Integer
If ages.TryGetValue("David", age) Then
	Console.WriteLine($"David's age: {age}")
Else
	Console.WriteLine("David's age is not available.")
End If

Löschen von Einträgen

// Remove an entry given its key
ages.Remove("Charlie");

// Remove an entry given its key
ages.Remove("Charlie");

' Remove an entry given its key
ages.Remove("Charlie")

' Remove an entry given its key
ages.Remove("Charlie")

Wörterbuch-Initialisierung

// Initialize a dictionary with color codes
var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

// Initialize a dictionary with color codes
var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

' Initialize a dictionary with color codes
Dim colors = New Dictionary(Of String, String) From {
	{"red", "#FF0000"},
	{"green", "#00FF00"},
	{"blue", "#0000FF"}
}

' Initialize a dictionary with color codes
Dim colors = New Dictionary(Of String, String) From {
	{"red", "#FF0000"},
	{"green", "#00FF00"},
	{"blue", "#0000FF"}
}

Über das Wörterbuch hinaus: Alternativen und Überlegungen

Während Dictionary<TKey, TValue> ein leistungsstarkes Werkzeug ist, hängen alternative Ansätze und Überlegungen von den spezifischen Anforderungen Ihrer Anwendung ab:

ConcurrentDictionary<TKey, TValue>: Wenn Ihre Anwendung einen thread-sicheren Zugriff auf das Verzeichnis von mehreren Threads erfordert, sollten Sie ConcurrentDictionary<TKey, TValue> in Betracht ziehen.
ImmutableDictionary<TKey, TValue>: Für Szenarien, in denen Unveränderlichkeit gewünscht ist, bietet ImmutableDictionary<TKey, TValue> aus dem System.Collections.Immutable-Namensraum unveränderliche Schlüssel-Wert-Sammlungen.
Benutzerdefinierte Schlüssel-Wert-Paar-Klassen: In Situationen, in denen Sie zusätzliche Funktionalität oder spezifisches Verhalten benötigen, ziehen Sie die Erstellung benutzerdefinierter Schlüssel-Wert-Paar-Klassen in Betracht, die auf Ihre Anforderungen zugeschnitten sind.

IronPDF-Bibliothek

IronPDF von Iron Software Products ist eine hervorragende Bibliothek zur Erstellung von PDF-Dokumenten. Ihre Benutzerfreundlichkeit und Effizienz sind unübertroffen.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

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

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

IronPDF kann aus dem NuGet-Paketmanager installiert werden:

PM > Install-Package IronPdf

Install-Package IronPdf

Oder von Visual Studio in dieser Weise:

C#-Pair-Klasse (Funktionsweise für Entwickler): Abbildung 1 - Installation von IronPDF mit dem NuGet-Paketmanager

Um ein Dokument mit einem Tupelbeispiel zu erstellen, können wir den folgenden Code verwenden:

using IronPdf;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // var pattern
            var content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!";
            content += "<h2>Demo C# Pair with Tuples</h2>";

            var result = Divide(10, 3);
            Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}");
            content += $"<p>When we divide 10 by 3:</p>";
            content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content);
            pdf.SaveAs("output.pdf"); // Saves PDF
        }

        // Method to demonstrate division using tuples
        public static (int Quotient, int Remainder) Divide(int dividend, int divisor)
        {
            int quotient = dividend / divisor;
            int remainder = dividend % divisor;
            return (quotient, remainder);
        }
    }
}

using IronPdf;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // var pattern
            var content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!";
            content += "<h2>Demo C# Pair with Tuples</h2>";

            var result = Divide(10, 3);
            Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}");
            content += $"<p>When we divide 10 by 3:</p>";
            content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content);
            pdf.SaveAs("output.pdf"); // Saves PDF
        }

        // Method to demonstrate division using tuples
        public static (int Quotient, int Remainder) Divide(int dividend, int divisor)
        {
            int quotient = dividend / divisor;
            int remainder = dividend % divisor;
            return (quotient, remainder);
        }
    }
}

Imports IronPdf

Namespace IronPatterns
	Friend Class Program
		Shared Sub Main()
			Console.WriteLine("-----------Iron Software-------------")
			Dim renderer = New ChromePdfRenderer() ' var pattern
			Dim content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!"
			content &= "<h2>Demo C# Pair with Tuples</h2>"

			Dim result = Divide(10, 3)
			Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}")
			content &= $"<p>When we divide 10 by 3:</p>"
			content &= $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>"

			Dim pdf = renderer.RenderHtmlAsPdf(content)
			pdf.SaveAs("output.pdf") ' Saves PDF
		End Sub

		' Method to demonstrate division using tuples
		Public Shared Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Quotient As Integer, Remainder As Integer)
			Dim quotient As Integer = dividend \ divisor
			Dim remainder As Integer = dividend Mod divisor
			Return (quotient, remainder)
		End Function
	End Class
End Namespace

Imports IronPdf

Namespace IronPatterns
	Friend Class Program
		Shared Sub Main()
			Console.WriteLine("-----------Iron Software-------------")
			Dim renderer = New ChromePdfRenderer() ' var pattern
			Dim content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!"
			content &= "<h2>Demo C# Pair with Tuples</h2>"

			Dim result = Divide(10, 3)
			Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}")
			content &= $"<p>When we divide 10 by 3:</p>"
			content &= $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>"

			Dim pdf = renderer.RenderHtmlAsPdf(content)
			pdf.SaveAs("output.pdf") ' Saves PDF
		End Sub

		' Method to demonstrate division using tuples
		Public Shared Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Quotient As Integer, Remainder As Integer)
			Dim quotient As Integer = dividend \ divisor
			Dim remainder As Integer = dividend Mod divisor
			Return (quotient, remainder)
		End Function
	End Class
End Namespace

Ausgabe

C#-Pair-Klasse (Funktionsweise für Entwickler): Abbildung 2

Testlizenz für IronPDF

Holen Sie sich Ihre IronPDF-Testlizenz und platzieren Sie die Lizenz im appsettings.json.

{
    "IronPdf.LicenseKey": "<Your Key>"
}

{
    "IronPdf.LicenseKey": "<Your Key>"
}

JSON

Abschluss

In diesem Artikel haben wir das Konzept von Paaren und die Bedeutung einer Pair-Klasse in C# untersucht. Wir haben eine einfache Implementierung der benutzerdefinierten Pair-Klasse zusammen mit verschiedenen Anwendungsfällen bereitgestellt, die ihre Vielseitigkeit und Nützlichkeit in alltäglichen Programmieraufgaben demonstrieren.

Ob Sie mit Koordinaten arbeiten, mehrere Werte aus einer Methode zurückgeben oder Schlüssel-Wert-Zuordnungen speichern, die Pair-Klasse kann eine wertvolle Ergänzung Ihres Programmierungs-Sets sein.

Zusätzlich dazu ist die IronPDF-Bibliotheksfunktionalität eine großartige Kombination von Fähigkeiten, die Entwickler haben sollten, um bei Bedarf PDF-Dokumente in Anwendungen zu erstellen.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...