Einführung in Tupel in C# in 10 Minuten oder weniger

Das Problem: Mehr als einen Wert zurückgeben

[0:18 - 2:50] Tim beginnt mit einer ValidateAddress Methode, die eine Straßenadresse als String akzeptiert. Das Verhalten, das er will, ist einfach: Wenn die Eingabe mit "123 Sesame St" übereinstimmt, geben Sie die richtig formatierte "123 Sesame Street" zurück; andernfalls signalisieren, dass die Adresse ungültig ist. Zwei Informationen müssen von einem einzigen Aufruf zurückkommen, der bereinigte String und das Erfolgsflag.

Die vor-Tuple-Optionen sind beide umständlich. Eine ValidateAddressResult Klasse zu erstellen funktioniert, aber sie lässt einen Ein-Zweck-Typ im Projekt zurück, den kein anderer Code jemals instanziieren wird. Einen out-Parameter zu verwenden, um die formatierte Adresse über die Parameterliste zurückzugeben, funktioniert ebenfalls, aber es vermengt Eingabe und Ausgabe in der Methodensignatur und macht den Aufrufpunkt schwieriger zu lesen. Tuples wurden eingeführt, um diesen Fall zu behandeln, ohne eine der Kosten zu zahlen.

Ein unbenanntes Tuple zurückgeben

[2:50 - 4:01] Die minimale Syntax für einen Tuperückgabetyp umschließt die beiden Typen in Klammern:

public (string, bool) ValidateAddress(string address)
{
    if (address == "123 Sesame St")
    {
        return ("123 Sesame Street", true);
    }
    return (address, false);
}

public (string, bool) ValidateAddress(string address)
{
    if (address == "123 Sesame St")
    {
        return ("123 Sesame Street", true);
    }
    return (address, false);
}

Die Methode gibt jetzt ein (string, bool) Paar zurück. Der Nachteil tritt sofort auf, wenn etwas versucht, es zu verwenden. Ohne zugewiesene Namen für die Mitglieder, zeigt IntelliSense sie als Item1 und Item2 an, was dem nächsten Leser nichts darüber verrät, was jeder Wert darstellt. Tim betont dies als Grund, warum er niemals unbenannte Tupeln veröffentlicht, obwohl die Syntax die kürzeste ist. Die Kosten, result.Item2 sechs Monate später zu lesen, sind höher als die Kosten, einmal einen Namen zu tippen.

Die Tuple-Mitglieder benennen

[4:01 - 6:30] Die Zuweisung von Namen zu jedem Mitglied des Tuples ist eine Änderung in einer Zeile an der Rückgabetyperklärung:

public (string Address, bool IsValid) ValidateAddress(string address)
{
    if (address == "123 Sesame St")
    {
        return ("123 Sesame Street", true);
    }
    return (address, false);
}

public (string Address, bool IsValid) ValidateAddress(string address)
{
    if (address == "123 Sesame St")
    {
        return ("123 Sesame Street", true);
    }
    return (address, false);
}

Jetzt liest die Aufrufstelle sich natürlich:

var result = ValidateAddress("123 Sesame St");

if (result.IsValid)
{
    Console.WriteLine($"Your validated address is {result.Address}");
}
else
{
    Console.WriteLine("That is an invalid address");
}

var result = ValidateAddress("123 Sesame St");

if (result.IsValid)
{
    Console.WriteLine($"Your validated address is {result.Address}");
}
else
{
    Console.WriteLine("That is an invalid address");
}

Das Ausführen des Codes mit "123 Sesame St" druckt die kanonische Form. Das Weglassen der führenden 1, um "23 Sesame St" zu erzeugen, lässt IsValid als falsch zurückkommen und druckt die ungültige Adressnachricht. Der Vertrag der Methode dokumentiert sich jetzt selbst an der Aufrufstelle, ohne dass ein benanntes Tuple eine unterstützende Klassendatei benötigt.

Ein Tuple kann mehr als zwei Mitglieder tragen. Drei, vier oder fünf arbeiten auf die gleiche Weise. Tim bemerkt, dass, wenn ein Tuple über drei oder vier Mitglieder hinauswächst, normalerweise ein Record oder eine Klasse die klarere Wahl wird, aber für zwei oder drei zusammenhängende Werte aus einer einzigen Methode bleibt das Tuple die leichtere Option.

Das Tuple in separate Variablen zerlegen

[6:30 - 7:39] Manchmal möchte der Anrufer lieber jedes Stück des Ergebnisses in einer eigenen Variablen halten, anstatt in ein einzelnes result zu punkten. C# unterstützt das direkt mit der Dekonstruktion-Syntax:

(string message, bool valid) = ValidateAddress("123 Sesame St");

if (valid)
{
    Console.WriteLine($"Your validated address is {message}");
}

(string message, bool valid) = ValidateAddress("123 Sesame St");

if (valid)
{
    Console.WriteLine($"Your validated address is {message}");
}

Die Variablennamen auf der linken Seite müssen nicht mit den Tuple-Mitgliedsnamen auf der Methode übereinstimmen. Hier ersetzt message Address und valid ersetzt IsValid. Tim weist darauf hin, dass dies ein Destruktor ist, kein Destrukteur; die beiden Wörter klingen ähnlich, beziehen sich jedoch auf völlig unterschiedliche Konzepte. Der Destruktor teilt das Tuple in die lokalen Variablen auf, die der Anrufer tatsächlich benötigt.

Zeichen mit Verwerfen überspringen

[7:41 - 8:54] Wenn dem Anrufer nur ein Teil der zurückgegebenen Werte wichtig ist, verwirft das Discard-Zeichen (_) diejenigen, die er nicht benötigt:

(string message, _) = ValidateAddress("123 Sesame St");
Console.WriteLine(message);

(string message, _) = ValidateAddress("123 Sesame St");
Console.WriteLine(message);

Der Unterstrich sagt dem Compiler "Ich ignoriere diesen Wert absichtlich." Dies ist ausdrucksstärker als einem ungewollten Mitglied einen bedeutungslosen Variablennamen wie unused zuzuweisen, da ein Verwurf Absicht kommuniziert. Jeder, der die Zeile liest, weiß, dass das Ignorieren von IsValid eine bewusste Entscheidung für diese Aufrufstelle ist, kein Versehen.

Abschließendes Fazit: Wenn Tuples ihren Platz verdienen

[8:54 - 9:28] Der primäre Anwendungsfall für Tuples ist es, mehrere Werte aus einer Methode zurückzugeben, ohne eine Klasse zu erstellen, die nur einmal zurückgegeben wird. Den Mitgliedern in der Methodensignatur Namen zu geben, sie an der Aufrufstelle zu dekonstruktieren und diejenigen zu verwerfen, die der Anrufer nicht braucht, sind die drei Muster, die Tuples angenehm machen zu verwenden. Darüber hinaus sind Tuples nützlich für LINQ-Projektionen und Zwischenberechnungen, wo ein schnell gepaartes Wert mehr lesbar ist als ein anonymer Typ.

Abschluss

[9:28 - 9:49] Tuples bieten C# eine kompakte Möglichkeit, mehr als einen Wert aus einer Methode zurückzugeben. Die benannte Form ist die Version, die es wert ist, täglich verwendet zu werden, weil result.Address lesbar ist, während result.Item1 es nicht ist. Dekonstruktion fördert die Teile zurück zu lokalen Variablen, wenn der Anrufer diese Form bevorzugt, und das Verwurfszeichen lässt einen einzelnen Aufruf nur das nehmen, was er benötigt.

Beispieltipp: Wenn Sie beginnen, die gleiche Tuple-Form in drei oder mehr Stellen zu dekontstruieren, ist das das Signal, zu einem Record zu wechseln. Tuples glänzen, wenn die Form lokal für eine Methode ist; in dem Moment, in dem die Form Teil Ihrer Domäne wird, zahlt sich ein benannter Typ aus.

Schauen Sie sich das vollständige Video auf seinem YouTube-Kanal an und gewinnen Sie weitere Einsichten über das Schreiben von modernem, ausdrucksstarkem C# in der 10-Minuten-Trainingsreihe.