.NET-HILFE

C# Pair Class (Wie es für Entwickler funktioniert)

Veröffentlicht 6. Juni 2024

Teilen Sie:

Einführung

Ein Paar ist eine einfache Datenstruktur, die zwei zusammengehörige Werte enthält. Sie bietet eine bequeme Möglichkeit, zwei unterschiedliche Daten zu bündeln. Paare werden üblicherweise verwendet, wenn eine Methode zwei Werte zurückgeben muss oder wenn mit Schlüssel-Wert-Zuordnungen gearbeitet wird.

In C# greifen Entwickler häufig auf Tupel zurück(tupel<T1, T2>) für Paarungswerte. Tupel sind jedoch unveränderlich, und auf ihre Elemente wird über Eigenschaften wie Item1 und Item2 zugegriffen, was bei extensiver Verwendung zu weniger lesbarem Code führen kann. In diesem Fall ist eine benutzerdefinierte Pair-Klasse sehr nützlich.

Wenn Sie eine Struktur benötigen, um zwei zusammengehörige Objekte zu speichern, und das Ausblenden von Daten keine Priorität hat, können Sie die Klasse Pair in Ihrem Code verwenden. Die Klasse Pair kapselt ihre Objektreferenzen nicht. Stattdessen werden sie allen aufrufenden Codes direkt als öffentliche Klassenfelder zur Verfügung gestellt.

Diese Designentscheidung ermöglicht einen einfachen Zugriff auf die enthaltenen Objekte ohne den Overhead der Kapselung. Außerdem werden wir am Ende des Artikels untersuchen, wieIronPDF für die PDF-Erstellung vonIron Software Übersicht kann zur Erstellung eines PDF-Dokuments verwendet werden.

Tupel

Mit C# 7.0 wurde die Tupel-Syntax verbessert, wodurch die Arbeit mit Tupeln noch einfacher wird. So können Sie Tupel deklarieren und initialisieren:

// Tuple declaration
var person = (name: "John", age: 30);
// Accessing tuple elements
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
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
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 Tuples

Prägnante Syntax

Mit Tupeln können Sie komplexe Datenstrukturen mit einer prägnanten Syntax ausdrücken, ohne dass Sie eigene Klassen oder Strukturen definieren müssen.

Leichtgewicht

Tupel sind leichtgewichtige Datenstrukturen und eignen sich daher für Szenarien, in denen Daten vorübergehend oder zwischengespeichert werden müssen.

Implizite Benennung

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

Rückgabe mehrerer Werte von Methoden

public (int, int) 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.Item1}, Remainder: {result.Item2}");

public (int, int) 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.Item1}, Remainder: {result.Item2}");

Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Integer, 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.Item1}, Remainder: {result.Item2}")

Vereinfachung der Methodensignaturen

public (string, string) GetNameAndSurname()
{
    // Retrieve name and surname from a data source
    return ("John", "Doe");
}
var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");

public (string, string) 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 (String, 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)

Beschränkungen und Überlegungen

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

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

Benutzerdefinierte Klasse paaren

public class Pair<T1, T2>
{
    public T1 First { get; set; }
    public T2 Second { get; set; }
    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; }
    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
	Public Sub New(ByVal first As T1, ByVal second As T2)
		Me.First = first
		Me.Second = second
	End Sub
End Class

Hier werden die Typen zum Zeitpunkt der Verwendung definiert und die beiden Eigenschaften werden als öffentliche Eigenschaften offengelegt.

Verwendung der Paarklasse

Lassen Sie uns nun im folgenden Beispiel einige häufige Anwendungsfälle untersuchen, in denen die Klasse Pair von Nutzen sein kann:

1. Speichern von Koordinaten

Pair<int, int> coordinates = new Pair<int, int>(10, 20); // new instance
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

Pair<int, int> coordinates = new Pair<int, int>(10, 20); // new instance
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

Dim coordinates As New Pair(Of Integer, Integer)(10, 20) ' new instance
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}")

2. Rückgabe mehrerer Werte aus einer Methode

public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

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
Private result As Pair(Of Integer, Integer) = Divide(10, 3)
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}")

3. Speichern von Schlüssel-Werte-Paaren

Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

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, Daten zu verknüpfen. In C# ist das Hauptwerkzeug für die Arbeit mit Schlüssel-Wert-Paaren die Klasse "Dictionary<TKey, TValue>", 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 Verknüpfung ermöglicht eine effiziente Abfrage und Bearbeitung von Daten auf der Grundlage ihrer eindeutigen Kennung. In C# werden Schlüssel-Wert-Paare häufig für Aufgaben wie Caching, Konfigurationsmanagement und Datenspeicherung verwendet.

wörterbuch<TKey, TValue>" in C#;

Die Klasse Dictionary<TKey, TValue> in C# ist eine generische Sammlung, die Schlüssel-Wert-Paare speichert. Sie bietet schnelle Nachschlagemöglichkeiten auf der Grundlage der Schlüssel und wird häufig für die Verwaltung assoziativer Daten verwendet.

Erstellen und Auffüllen eines Wörterbuchs

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
ages["Bob"] = 35;
ages["Charlie"] = 25;

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
ages["Bob"] = 35;
ages["Charlie"] = 25;

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

Zugriff auf Werte nach Schlüssel

Console.WriteLine($"Alice's age: {ages["Alice"]}");

Console.WriteLine($"Alice's age: {ages["Alice"]}");

Console.WriteLine($"Alice's age: {ages("Alice")}")

Iteration über Schlüssel-Werte-Paare

foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

For Each pair In ages
	Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}")
Next pair

Erweiterte Szenarien

Umgang mit 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

Entfernen von Einträgen

ages.Remove("Charlie");

ages.Remove("Charlie");

ages.Remove("Charlie")

Initialisierung des Wörterbuchs

var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

Dim colors = New Dictionary(Of String, String) From {
	{"red", "#FF0000"},
	{"green", "#00FF00"},
	{"blue", "#0000FF"}
}

Jenseits des Wörterbuchs: Alternativen und Überlegungen

Obwohl "Dictionary<TKey, TValue>" ein leistungsfähiges 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 Wörterbuch von mehreren Threads aus erfordert, sollten SieConcurrentDictionary<TKey, TValue>` verwenden.
immutableDictionary<TKey, TValue>:Für Szenarien, in denen Unveränderlichkeit erwünscht ist, bietet dasImmutableDictionary<TKey, TValue>aus demSystem.Collections.Immutable`-Namensraum unveränderliche Schlüssel-Wert-Sammlungen.
Benutzerdefinierte Schlüssel-Wert-Paar-Klassen: In Situationen, in denen Sie zusätzliche Funktionen oder ein bestimmtes Verhalten benötigen, können Sie benutzerdefinierte Schlüssel-Wert-Paar-Klassen erstellen, die auf Ihre Anforderungen zugeschnitten sind.

IronPDF-Bibliothek

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

IronPDF zeichnet sich aus durchHTML zu PDFKonvertierung, die eine präzise Wahrung der ursprünglichen Layouts und Stile sicherstellt. Es ist perfekt geeignet, um PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen zu erstellen. Mit Unterstützung von HTML-Dateien, URLs und rohen HTML-Zeichenfolgen produziert IronPDF mühelos 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

IronPDF kann über den NuGet-Paketmanager installiert werden:

Install-Package IronPdf

Oder von Visual Studio aus wie folgt:

C#-Paar-Klasse(Wie es für Entwickler funktioniert): Abbildung 1 - Installation von IronPDF mit dem NuGet-Paketmanager

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

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, 3 </p>";
        content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF        
    }
    public static (int, int) Divide(int dividend, int divisor)
    {
        // var count;
        int quotient = dividend / divisor;
        int remainder = dividend % divisor;
        return (quotient, remainder);
    }
}

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, 3 </p>";
        content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF        
    }
    public static (int, int) Divide(int dividend, int divisor)
    {
        // var count;
        int quotient = dividend / divisor;
        int remainder = dividend % divisor;
        return (quotient, remainder);
    }
}

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, 3 </p>"
			content &= $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>"
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			pdf.SaveAs("output.pdf") ' Saves PDF
		End Sub
		Public Shared Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Integer, Integer)
			' var count;
			Dim quotient As Integer = dividend \ divisor
			Dim remainder As Integer = dividend Mod divisor
			Return (quotient, remainder)
		End Function
	End Class
End Namespace

Ausgabe

C#-Paar-Klasse(Wie es für Entwickler funktioniert): Abbildung 2

Testlizenz für IronPDF

Holen Sie sich IhrIronPDF Testlizenz und platzieren Sie die Lizenz in der appsettings.json.

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

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

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPDF.LicenseKey": "<Your Key>"

Schlussfolgerung

In diesem Artikel haben wir uns mit dem Konzept der Paare und der Bedeutung der Klasse "Pair" in C# beschäftigt. Wir haben eine einfache Implementierung der benutzerdefinierten Klasse "Pair" zusammen mit verschiedenen Anwendungsfällen bereitgestellt, die ihre Vielseitigkeit und Nützlichkeit bei alltäglichen Programmieraufgaben demonstrieren.

Ganz gleich, ob Sie mit Koordinaten arbeiten, mehrere Werte aus einer Methode zurückgeben oder Schlüssel-Wert-Zuordnungen speichern möchten, die Klasse Pair kann eine wertvolle Ergänzung Ihrer Programmierkenntnisse sein.

Darüber hinaus muss dieFunktionalität der IronPDF-Bibliothek ist eine großartige Kombinationsmöglichkeit für Entwickler, um PDF-Dokumente je nach Bedarf in Anwendungen zu generieren.

Kannapat Udonpant

Software-Ingenieur

LinkedIn

Bevor er Software-Ingenieur wurde, promovierte Kannapat an der Universität Hokkaido in Japan im Bereich Umweltressourcen. Während seines Studiums wurde Kannapat auch Mitglied des Vehicle Robotics Laboratory, das Teil der Abteilung für Bioproduktionstechnik ist. Im Jahr 2022 wechselte er mit seinen C#-Kenntnissen zum Engineering-Team von Iron Software, wo er sich auf IronPDF konzentriert. Kannapat schätzt an seiner Arbeit, dass er direkt von dem Entwickler lernt, der den Großteil des in IronPDF verwendeten Codes schreibt. Neben dem kollegialen Lernen genießt Kannapat auch den sozialen Aspekt der Arbeit bei Iron Software. Wenn er nicht gerade Code oder Dokumentationen schreibt, kann man Kannapat normalerweise beim Spielen auf seiner PS5 oder beim Wiedersehen mit The Last of Us antreffen.

< PREVIOUS
Internes Schlüsselwort C# (Wie es für Entwickler funktioniert)

NÄCHSTES >
Dapper C# (Wie es für Entwickler funktioniert)