Delen via

Tuples en deconstructie

Aanbeveling

Nieuw bij het ontwikkelen van software? Beginnen met de Aan de slag-zelfstudies. Er treden tuples op wanneer u meerdere waarden van een methode of groepswaarde moet retourneren zonder een benoemd type te definiëren.

Ervaren in een andere taal? C#-tuples zijn waardetypen die vergelijkbaar zijn met tuples in Python of Swift, maar met optionele benoemde elementen en volledige destructieondersteuning. Skim de deconstructie en gelijkheidssecties voor C#-specifieke patronen.

Een tuple groepert meerdere waarden in één lichtgewicht structuur zonder dat u een benoemd type hoeft te definiëren. Tuples zijn waardetypen die u inline kunt declareren, retourneren uit methoden en gedeconstrueerd in afzonderlijke variabelen. Gebruik tuples wanneer u een snelle, tijdelijke groepering van gerelateerde waarden nodig hebt. Als u bijvoorbeeld meerdere resultaten van een methode retourneert of een coördinaatpaar opslaat.

In het volgende voorbeeld wordt een tuple gemaakt met benoemde elementen en wordt elk element op naam geopend:

var location = (Latitude: 47.6062, Longitude: -122.3321);
Console.WriteLine($"Location: {location.Latitude}, {location.Longitude}");
// Output: Location: 47.6062, -122.3321

Tuples werken goed voor groeperingen met korte levensduur waarbij het definiëren van een klasse, struct of record onnodige ceremonie zou toevoegen. Voor langlevende domeinconcepten of -typen met gedrag geeft u de voorkeur aan records, klassen of structs. Zie Kiezen welk type type u wilt gebruiken voor een vergelijking van wanneer u deze wilt gebruiken.

Tuples declareren en initialiseren

Declareer een tuple door de elementtypen tussen haakjes weer te geven. U kunt desgewenst elk element een naam geven om de code beter leesbaar te maken:

// Tuple with named elements
(string Name, int Age) person = ("Alice", 30);
Console.WriteLine($"{person.Name} is {person.Age} years old");

// Tuple with default element names (Item1, Item2)
(string, int) unnamed = ("Bob", 25);
Console.WriteLine($"{unnamed.Item1} is {unnamed.Item2} years old");

// Tuple declared with var and inline names
var city = (Name: "Seattle", Population: 749_256);
Console.WriteLine($"{city.Name}: population {city.Population}");

Als u geen namen opgeeft, gebruiken elementen standaardnamen Item1, Item2enzovoort. Benoemde elementen maken uw code zelfdocumenteren zonder dat hiervoor een afzonderlijke typedefinitie is vereist.

Namen van afgeleide elementen

De compiler leidt elementnamen af van variabelenamen of eigenschapsnamen die u gebruikt om de tuple te vormen. Deze functie voorkomt redundantie wanneer de namen overeenkomen:

var name = "Carol";
var age = 28;

// The compiler infers element names from the variable names
var person = (name, age);
Console.WriteLine($"{person.name} is {person.age}");
// Output: Carol is 28

Afgeleide namen houden uw code beknopt. Als u een andere elementnaam nodig hebt, geeft u dit expliciet op.

Meerdere waarden retourneren uit een methode

Een van de meest voorkomende toepassingen voor tuples is het retourneren van meerdere waarden uit een methode. In plaats van een klasse te definiëren of parameters te gebruiken out , retourneert u een tuple met benoemde elementen:

static (double Minimum, double Maximum, double Average) ComputeStats(List<double> values)
{
    var min = values.Min();
    var max = values.Max();
    var avg = values.Average();
    return (min, max, avg);
}

Benoemde tuple-elementen maken de retourwaarden leesbaar op zowel de aanroepsite als de methodehandtekening. De aanroeper heeft toegang tot elke waarde op naam zonder dat u positionele volgorde hoeft te onthouden.

Tuples deconstrueren

Met de deconstruction worden de elementen van een tuple in afzonderlijke variabelen in één instructie uitgepakt. U kunt tuples op verschillende manieren deconstrueren:

var point = (X: 3, Y: 7);

// Deconstruct with var (infer all types)
var (x, y) = point;
Console.WriteLine($"x={x}, y={y}");

// Deconstruct with explicit types
(int px, int py) = point;
Console.WriteLine($"px={px}, py={py}");

// Deconstruct into existing variables
int a, b;
(a, b) = point;
Console.WriteLine($"a={a}, b={b}");

// Deconstruct a method return value directly
List<double> data = [10.0, 20.0, 30.0];
var (min, max, avg) = ComputeStats(data);
Console.WriteLine($"Min: {min}, Max: {max}, Avg: {avg}");

Deconstructie is vooral handig wanneer u een tuple van een methodeaanroep ontvangt en onmiddellijk met de afzonderlijke waarden moet werken.

U kunt tuples direct in foreach-lussen deconstrueren, wat het itereren over verzamelingen van gegroepeerde waarden beknopt maakt.

List<(string Name, int Score)> results =
[
    ("Alice", 92),
    ("Bob", 87),
    ("Carol", 95)
];

foreach (var (name, score) in results)
{
    Console.WriteLine($"{name}: {score}");
}

Wanneer u niet elk element nodig hebt, gebruikt u een verwijdering (_) in plaats van elke waarde die u wilt negeren. Gebruik een afzonderlijke _ voor elke vervallen positie:

List<double> values = [5.0, 10.0, 15.0];
var (_, max, _) = ComputeStats(values);
Console.WriteLine($"Only need the max: {max}");
// Output: Only need the max: 15

Zie Discards voor meer informatie over het gebruik van discards in verschillende contexten.

Tuple-gelijkheid

Je kunt tuples vergelijken met behulp van == en !=. Deze operators vergelijken elk element in volgorde, zodat twee tuples gelijk zijn wanneer alle bijbehorende elementen gelijk zijn:

var order1 = (Product: "Widget", Quantity: 5);
var order2 = (Product: "Widget", Quantity: 5);
var order3 = (Product: "Gadget", Quantity: 3);

Console.WriteLine(order1 == order2); // True
Console.WriteLine(order1 == order3); // False

// Element names don't affect equality—only values matter
var named = (X: 1, Y: 2);
var different = (A: 1, B: 2);
Console.WriteLine(named == different); // True

Tuple-gelijkheid maakt gebruik van de ==-operator die is gedefinieerd op elk elementtype, wat betekent dat de vergelijking correct werkt voor tekenreeksen, getallen en andere typen waarvoor == is gedefinieerd. Elementnamen hebben geen invloed op gelijkheid, alleen waarden en posities zijn belangrijk.

Niet-destructieve mutatie met with

Met with de expressie wordt een kopie van een tuple gemaakt waarbij een of meer elementen zijn gewijzigd, waardoor het oorspronkelijke element ongewijzigd blijft:

var original = (Name: "Widget", Price: 19.99m, InStock: true);
var discounted = original with { Price = 14.99m };

Console.WriteLine($"Original: {original.Name} at {original.Price:C}");
Console.WriteLine($"Discounted: {discounted.Name} at {discounted.Price:C}");
// Output:
// Original: Widget at $19.99
// Discounted: Widget at $14.99

Dit patroon is handig als u een variatie van een bestaande tuple wilt zonder het origineel te wijzigen. De with expressie werkt op dezelfde manier op tuples als bij records.

Tuples in woordenboeken en opzoekingen

Tuples maken handige woordenlijstwaarden wanneer u een sleutel aan meerdere gegevens moet koppelen:

var sizeChart = new Dictionary<string, (int Min, int Max)>
{
    ["Small"] = (0, 50),
    ["Medium"] = (51, 100),
    ["Large"] = (101, 200)
};

if (sizeChart.TryGetValue("Medium", out var range))
{
    Console.WriteLine($"Medium: {range.Min}–{range.Max}");
}
// Output: Medium: 51–100

Tuples werken ook als woordenlijstsleutels, waardoor u een samengestelde sleutel krijgt zonder een aangepast type te definiëren. Omdat tuples structurele gelijkheid implementeren, komen zoekacties overeen met de gecombineerde waarden van alle elementen:

var grid = new Dictionary<(int Row, int Column), string>
{
    [(0, 0)] = "Origin",
    [(1, 3)] = "Sensor A",
    [(2, 5)] = "Sensor B"
};

var target = (Row: 1, Column: 3);
if (grid.TryGetValue(target, out var label))
{
    Console.WriteLine($"({target.Row}, {target.Column}): {label}");
}
// Output: (1, 3): Sensor A

Dit patroon voorkomt dat u een afzonderlijke klasse nodig hebt voor eenvoudige zoekopdrachten met meerdere sleutels of sleutel-naar-meerdere-waardetoewijzingen.

Tuples versus anonieme typen

Tuples zijn de voorkeurskeuze wanneer u een lichtgewicht, niet-benoemde gegevensstructuur nodig hebt. Anonieme typen blijven beschikbaar voor expressiestructuurscenario's en voor code waarvoor referentietypen zijn vereist, maar tuples bieden betere prestaties, deconstructieondersteuning en flexibelere syntaxis. Zie Kiezen tussen anonieme typen en tupletypen voor meer informatie over anonieme typen.

Zie ook

  • Last updated on