C# Tuple (Meta gruppe)

C# objektorientiert (OOP)4Die Klasse Tuple<T> wurde im .NET Framework

.0 eingeführt. Ein Tupel ist eine Datenstruktur, die eine Sequenz von Elementen mit verschiedenen Datentypen enthält. Es kann verwendet werden, um Datenstrukturen zu speichern, die Objekte mit Eigenschaften enthalten müssen, ohne dass für diese eine separate Typen angelegt werden möchte.

Syntax:1Tuple<T2Tuple<T3Tuple<T4Tuple<T5Tuple<T6Tuple<T7, T

, TRest>

Tuple<int, string, string> person = new Tuple<int, string, string>(1, "Steve", "Jobs");

Im obigen Beispiel haben wir ein Tupel erstellt, das eine Instanz eines Personenverzeichnisses enthält. Wir haben jedem Element einen Typ zugewiesen und Werte an den Konstruktor übergeben. Es ist lästig, jedem Element einen Typ zuzuweisen. C# hat eine statische Hilfsklasse Tuple eingeführt, die Instanzen von Tuple <T> zurückgibt, ohne dass für jedes Element ein Typ angegeben werden muss, wie folgt.

var person = Tuple.Create(1, "Steve", "Jobs");

Ein Tupel kann maximal acht Elemente enthalten. Wenn Sie versuchen, mehr als acht Elemente zu enthalten, wird ein Compilerfehler ausgelöst.

var numbers = Tuple.Create(1,　2,　3,　4,　5,　6,　7,　8);

Zugriff auf Tupel-Elemente

Tupel-Elemente können über die Item < elementnumber > -Eigenschaft erreicht werden, z.B. Item1、 Item2、 Item3u.ä., man kann höchstens Item7Eigenschaft. Item1Eigenschaft zurückgibt das erste Element, Item2Zurückgegeben wird der zweite Element, und so weiter. Das letzte Element (der8Ein Element) wird über die Rest-Eigenschaft zurückgegeben.

var person = Tuple.Create(1, "Steve", "Jobs");
person.Item1;　//　Rückgabe　1
person.Item2;　//　zurück „Steve“
person.Item3;　//　zurück „Jobs“
var numbers = Tuple.Create("Eins",　2,　3, "Vier",　5, "Six",　7,　8);
numbers.Item1;　//　Rückgabe "One"
numbers.Item2;　//　Rückgabe　2
numbers.Item3;　//　Rückgabe　3
numbers.Item4;　//　Rückgabe "Four"
numbers.Item5;　//　Rückgabe　5
numbers.Item6;　//　Rückgabe "Six"
numbers.Item7;　//　Rückgabe　7
numbers.Rest;　//　Rückgabe (8)
numbers.Rest.Item1;　//　Rückgabe　8

Normalerweise, der8Positionen für verschachtelte Tupel, können Sie den Rest-Attribut verwenden, um auf diese Position zuzugreifen.

verschachtelte Tupel

Wenn Sie in einem Tupel mehr als acht Elemente enthalten möchten, können Sie dies durch Einfügen eines weiteren Tupelobjekts als achtes Element erreichen. Der letzte verschachtelte Tupel kann über den Rest-Attribut erreicht werden. Um auf die Elemente eines verschachtelten Tupels zuzugreifen, verwenden Sie Rest.Item1.Item<elelementNumber>-Attribut.

var numbers = Tuple.Create(1,　2,　3,　4,　5,　6,　7, Tuple.Create(8,　9,　10,　11,　12,　13));
numbers.Item1;　//　Rückgabe　1
numbers.Item7;　//　Rückgabe　7
numbers.Rest.Item1;　//Rückgabe (8,9,10,11,12,13)
numbers.Rest.Item1.Item1;　//Rückgabe　8
numbers.Rest.Item1.Item2;　//Rückgabe　9

Sie können verschachtelte Tupelobjekte an jeder Stelle der Sequenz einschließen. Es wird jedoch empfohlen, verschachtelte Tupel am Ende der Sequenz zu platzieren, um den Rest-Attribut verwenden zu können, um auf es zuzugreifen.

var numbers = Tuple.Create(1,　2, Tuple.Create(3,　4,　5,　6,　7,　　8),　9,　10,　11,　12,　13　);
numbers.Item1;　//　Rückgabe　1
numbers.Item2;　//　Rückgabe　2
numbers.Item3;　//　Rückgabe (3,　4,　5,　6,　7,　　8)
numbers.Item3.Item1;　//　Rückgabe　3
numbers.Item4;　//　Rückgabe　9
numbers.Rest.Item1;　//Rückgabe13

Tupel als Methodenparameter

Methoden können Tupel als Parameter übernehmen。

static void Main(string[] args)
{
	var person = Tuple.Create(
}1, "Steve", "Jobs");
　　　　DisplayTuple(person);
}
static void DisplayTuple(Tuple<int,string,string> person)
{
　　　　Console.WriteLine($"Id = { person.Item1
});
　　　　Console.WriteLine($"Vorname = { person.Item2
});
　　　　Console.WriteLine($"Nachname = { person.Item3
});
}

Tupel als Rückgabetyp

Tupel können von Methoden zurückgegeben werden。

static void Main(string[] args)
{
	var person = GetPerson();
}
static Tuple<int, string, string> GetPerson()　
{
	return Tuple.Create(
}1, "Bill", "Gates");
}

Verwendung von Tupeln

Tupel können in folgenden Fällen verwendet werden:

1. Wenn Sie mehrere Werte aus einer Methode zurückgeben möchten, ohne die ref- oder out-Parameter zu verwenden。

2. Wenn Sie mehrere Werte an eine Methode mit einem einzigen Parameter übergeben möchten。

3. Wenn Sie Datenbankzeilen oder bestimmte Werte temporär speichern möchten, ohne eine separate Klasse zu erstellen。

Nachteile von Tuple:

1. Tuple ist ein Referenztyp und kein Werttyp. Es wird auf dem Stapel zugewiesen und kann CPU-intensive Operationen verursachen.

2. Tuple ist auf acht Elemente beschränkt. Wenn mehr Elemente gespeichert werden müssen, muss ein verschachtelter Tuple verwendet werden. Dies kann jedoch zu Ambiguitäten führen.

3. Es kann die Eigenschaft mit dem Namensmuster Item <elementNumber> verwendet werden, um die Elemente von Tuple zu erreichen, was nicht sehr vernünftig ist.
   

C#7ValueTuple wurde eingeführt, um die Beschränkungen von Tuple zu überwinden und die Verwendung von Tuple zu erleichtern. Mehr darüber im nächsten Kapitel.