C# Language
tuples

Tupels maken

Tuples worden gemaakt met generieke typen Tuple<T1> - Tuple<T1,T2,T3,T4,T5,T6,T7,T8> . Elk van de typen vertegenwoordigt een tuple die 1 tot 8 elementen bevat. Elementen kunnen van verschillende typen zijn.

// tuple with 4 elements
var tuple = new Tuple<string, int, bool, MyClass>("foo", 123, true, new MyClass());

Tuples kunnen ook worden gemaakt met behulp van statische Tuple.Create methoden. In dit geval worden de typen elementen afgeleid door de C # Compiler.

// tuple with 4 elements
var tuple = Tuple.Create("foo", 123, true, new MyClass());

var tuple = ("foo", 123, true, new MyClass());

(int number, bool flag, MyClass instance) tuple = (123, true, new MyClass());

Toegang tot tuple-elementen

Gebruik de eigenschappen Item1 - Item8 om toegang te krijgen tot tuple-elementen. Alleen de eigenschappen met indexnummer kleiner of gelijk aan tuple zijn beschikbaar (dat wil zeggen dat men geen toegang heeft Item3 eigenschap Tuple<T1,T2> in Tuple<T1,T2> ).

var tuple = new Tuple<string, int, bool, MyClass>("foo", 123, true, new MyClass());
var item1 = tuple.Item1; // "foo"
var item2 = tuple.Item2; // 123
var item3 = tuple.Item3; // true
var item4 = tuple.Item4; // new My Class()

Tuples vergelijken en sorteren

Tuples kunnen worden vergeleken op basis van hun elementen.

Als een voorbeeld, een opsomming waarvan de elementen van het type Tuple kan worden gesorteerd op basis van vergelijkingsoperatoren die op een bepaald element zijn gedefinieerd:

List<Tuple<int, string>> list = new List<Tuple<int, string>>();
list.Add(new Tuple<int, string>(2, "foo"));
list.Add(new Tuple<int, string>(1, "bar"));
list.Add(new Tuple<int, string>(3, "qux"));

list.Sort((a, b) => a.Item2.CompareTo(b.Item2)); //sort based on the string element

foreach (var element in list) {
    Console.WriteLine(element);
}

// Output:
// (1, bar)
// (2, foo)
// (3, qux)

Of om het sorteren om te keren:

list.Sort((a, b) => b.Item2.CompareTo(a.Item2));

Retourneer meerdere waarden van een methode

Tuples kunnen worden gebruikt om meerdere waarden van een methode te retourneren zonder parameters te gebruiken. In het volgende voorbeeld wordt AddMultiply gebruikt om twee waarden te retourneren (som, product).

void Write()
{
    var result = AddMultiply(25, 28);
    Console.WriteLine(result.Item1);
    Console.WriteLine(result.Item2);
}

Tuple<int, int> AddMultiply(int a, int b)
{
    return new Tuple<int, int>(a + b, a * b);
}

Output:

53
700

Nu biedt C # 7.0 een alternatieve manier om meerdere waarden te retourneren van methoden die ValueTuple . Meer informatie over ValueTuple struct .