Řazené kolekce členů a dekonstrukce

Návod

Začínáte s vývojem softwaru? Začněte s návody Začínáme. S n-ticemi se setkáte, když potřebujete vrátit více hodnot z metody nebo vytvořit skupiny hodnot bez definování pojmenovaného typu.

Máte zkušenosti v jiném jazyce? C# n-tice jsou hodnotové typy podobné n-ticím v Pythonu nebo Swiftu, ale s volitelnými pojmenovanými prvky a plnou podporou rozkladu. Přeskočte oddíly dekonstrukce a rovnosti pro vzory specifické pro jazyk C#.

Řazená kolekce členů seskupí více hodnot do jedné zjednodušené struktury, aniž byste museli definovat pojmenovaný typ. N-tice jsou hodnotové typy, které můžete deklarovat uvnitř, vracet z metod a dekonstruovat do jednotlivých proměnných. Použijte n-tice v případě, že potřebujete rychlé a dočasné seskupení souvisejících hodnot. Když například vrátíte více výsledků z metody nebo uložíte dvojici souřadnic.

Následující příklad vytvoří n-tici s pojmenovanými prvky a přistupuje k jednotlivým prvkům podle jména:

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

n-tice fungují dobře pro krátkodobá seskupení, kde by definování třídy, struktury nebo záznamu přidalo zbytečné složitosti. U dlouhodobých konceptů nebo typů domén s chováním upřednostňujte záznamy, třídy nebo struktury. Porovnání toho, kdy jednotlivé typy použít, najdete v tématu Volba typu.

Deklarace a inicializace n-tic

Deklarujte n-tici výpisem typů prvků v závorkách. Volitelně můžete každý prvek pojmenovat, aby byl kód čitelnější:

// 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}");

Pokud nezadáte názvy, prvky používají výchozí názvy Item1atd Item2. Pojmenované prvky tvoří vlastní dokumentování kódu, aniž by vyžadovaly samostatnou definici typu.

Odvozené názvy elementů

Kompilátor odvodí názvy prvků z názvů proměnných nebo názvů vlastností, které používáte k inicializaci řazené kolekce členů. Tato funkce zabraňuje redundanci, když se názvy shodují:

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

Odvozené názvy udržují kód stručný. Pokud potřebujete jiný název elementu, zadejte ho explicitně.

Vrácení více hodnot z metody

Jedním z nejběžnějších použití desek je vrácení více hodnot z metody. Místo definování třídy nebo použití out parametrů vraťte n-tici s pojmenovanými elementy:

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);
}

Pojmenované prvky n-tice zajišťují, že návratové hodnoty jsou čitelné jak na místě volání, tak v podpisu metody. Volající má přístup ke každé hodnotě podle názvu, aniž by si museli pamatovat pořadí umístění.

Rozložení turblice

Dekonstrukce rozloží prvky n-tice do samostatných proměnných v jednom příkazu. Můžete rozložit n-tice několika způsoby:

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

Dekonstrukce je zvlášť užitečná, když dostanete n-tici z volání metody a okamžitě potřebujete pracovat s jejími jednotlivými hodnotami.

N-tice můžete dekonstruovat přímo ve smyčce foreach, což zjednodušuje iteraci kolekcí hodnot.

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

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

Pokud nepotřebujete každý prvek, použijte místo každé hodnoty, kterou chcete ignorovat, zahodit (_). Pro každou zahozenou pozici použijte samostatný _ objekt:

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

Další informace o použití zahození v různých kontextech najdete v tématu Zahození.

Rovnost n-tice

Můžete porovnat n-tice pomocí == a !=. Tyto operátory porovnávají jednotlivé prvky po řadě, takže dvě n-tice jsou stejné, pokud jsou všechny jejich odpovídající prvky stejné.

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

Rovnost n-tic používá operátor == definovaný pro každý typ prvku, což znamená, že porovnání funguje správně pro řetězce, čísla a další typy, které mají definovaný ==. Názvy elementů nemají vliv na rovnost – záleží jenom na hodnotách a pozicích.

Nedestruktivní mutace s with

Výraz with vytvoří kopii n-tice s jedním nebo více změněnými prvky a původní zůstane nezměněná.

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

Tento vzor je užitečný, když chcete variaci existující n-tice, aniž byste změnili původní n-tici. Výraz with funguje na tuplicatech stejně jako na záznamech.

Tupy ve slovnících a vyhledávání

n-tice se hodí jako hodnoty ve slovníku, pokud potřebujete spojit klíč s více částmi dat:

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

Řazené kolekce členů fungují také jako klíče slovníku a poskytují složený klíč bez definování vlastního typu. Vzhledem k tomu, že n-tice implementují strukturální rovnost, vyhledávání se provádí na základě kombinovaných hodnot všech prvků:

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

Tento model nevyžaduje samostatnou třídu pro jednoduché vyhledávání s více klíči nebo mapování párů klíč-více hodnot.

Řazené kolekce členů vs. anonymní typy

n-tice jsou preferovanou volbou, když potřebujete lehkou a nepojmenovanou datovou strukturu. Anonymní typy zůstávají dostupné pro scénáře stromů výrazů a kód, který vyžaduje referenční typy, ale třídy tupů nabízejí lepší výkon, podporu dekonstrukce a flexibilnější syntaxi. Další informace o anonymních typech najdete v tématu Volba mezi anonymními typy a typy n-tic.

Viz také

  • Last updated on