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

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, wie IronPDF von Iron Software 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 Tupel

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 pain-Eigenschaften dargestellt

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 wichtigste Werkzeug für die Arbeit mit Schlüssel-Wert-Paaren die Klasse Dictionary<TKey, TValue>, ein vielseitiger und leistungsfähiger 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 Sie ConcurrentDictionary<TKey, TValue> verwenden.
• 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 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 ist eine hervorragende Bibliothek zur Erstellung von PDF-Dokumenten. Seine Benutzerfreundlichkeit und Effizienz sind unübertroffen.

IronPDF kann über den NuGet-Paketmanager installiert werden:

Install-Package IronPdf

Oder von Visual Studio aus wie folgt:

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

Testlizenz für IronPDF

IronPDF. 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 IronPDF bibliothek ist eine großartige Kombinationsmöglichkeit für Entwickler, um PDF-Dokumente je nach Bedarf in den Anwendungen zu erzeugen.