Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Pair-Klasse
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

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 Tupel (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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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);
$vbLabelText   $csharpLabel

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;
    }
}
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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 }
};
$vbLabelText   $csharpLabel

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"]}");
$vbLabelText   $csharpLabel

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}");
}
$vbLabelText   $csharpLabel

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.");
}
$vbLabelText   $csharpLabel

Löschen von Einträgen

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

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" }
};
$vbLabelText   $csharpLabel

Ü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 Dictionary von mehreren Threads erfordert, ziehen Sie die Verwendung von ConcurrentDictionary<TKey, TValue> in Betracht.
  • ImmutableDictionary<TKey, TValue>: Für Szenarien, in denen Unveränderlichkeit gewünscht ist, bietet ImmutableDictionary<TKey, TValue> aus dem System.Collections.Immutable-Namespace 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");
    }
}
$vbLabelText   $csharpLabel

IronPDF kann aus dem NuGet-Paketmanager installiert werden:

Install-Package IronPdf

Oder von Visual Studio in dieser Weise:

C# Pair Class (So funktioniert es 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);
        }
    }
}
$vbLabelText   $csharpLabel

Ausgabe

C# Pair Class (So funktioniert es für Entwickler): Abbildung 2

Testlizenz für IronPDF

Holen Sie sich Ihre IronPDF-Testlizenz und legen Sie die Lizenz in appsettings.json ab.

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

Abschluss

In diesem Artikel haben wir das Konzept von Paaren und die Wichtigkeit einer Pair-Klasse in C# untersucht. Wir haben eine einfache Implementierung der benutzerdefinierten Pair-Klasse bereitgestellt sowie verschiedene Anwendungsfälle, 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.

Häufig gestellte Fragen

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.

Jacob Mellor, Chief Technology Officer @ Team Iron
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 führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen