Wie initialisiere ich eine Tupel-Liste?

c# 7.0 können Sie dies tun:

  var tupleList = new List<(int, string)>
  {
      (1, "cow"),
      (5, "chickens"),
      (1, "airplane")
  };

Wenn Sie nicht brauchen, ein Listsondern nur ein array, können Sie tun:

  var tupleList = new(int, string)[]
  {
      (1, "cow"),
      (5, "chickens"),
      (1, "airplane")
  };

Und wenn Sie nicht wie "Element1" und "Element2", die Sie tun können:

  var tupleList = new List<(int Index, string Name)>
  {
      (1, "cow"),
      (5, "chickens"),
      (1, "airplane")
  };

oder

  var tupleList = new (int Index, string Name)[]
  {
      (1, "cow"),
      (5, "chickens"),
      (1, "airplane")
  };

können Sie tun: tupleList[0].Index und tupleList[0].Name

Rahmen 4.6.2 und unten

Müssen Sie installieren System.ValueTuple aus dem Nuget-Paket-Manager.

Rahmen 4.7 und höher

Es ist gebaut in den Rahmen. Tun nicht installieren System.ValueTuple. In der Tat, entfernen Sie es und löschen Sie es aus dem bin-Verzeichnis.

Hinweis: Im wirklichen Leben, ich wäre nicht in der Lage zu wählen zwischen Kuh, Hühner oder Flugzeug. Ich wäre echt hin und her gerissen.

InformationsquelleAutor der Antwort toddmo

C# 6 gibt es eine neue Funktion, die nur für diese: Erweiterung Methoden Hinzufügen. Dies war schon immer möglich VB.net aber das ist jetzt in C# verfügbar.

Jetzt müssen Sie nicht haben, hinzufügen Add() Methoden, um Ihre Klassen, die Sie direkt umsetzen können Sie als Erweiterung Methoden. Wenn sich alle aufzählbaren Typ mit einer Add() Methode, werden Sie in der Lage, es zu benutzen in auflistungsinitialisierer Ausdrücken. So dass Sie nicht haben, um eine Ableitung von Listen, die explizit mehr (wie bereits erwähnt in einer anderen Antwort), können Sie einfach erweitern.

public static class TupleListExtensions
{
    public static void Add<T1, T2>(this IList<Tuple<T1, T2>> list,
            T1 item1, T2 item2)
    {
        list.Add(Tuple.Create(item1, item2));
    }

    public static void Add<T1, T2, T3>(this IList<Tuple<T1, T2, T3>> list,
            T1 item1, T2 item2, T3 item3)
    {
        list.Add(Tuple.Create(item1, item2, item3));
    }

    //and so on...
}

Wird diese ermöglichen es Ihnen, dies zu tun für jede Klasse, die implementiert IList<>:

var numbers = new List<Tuple<int, string>>
{
    { 1, "one" },
    { 2, "two" },
    { 3, "three" },
    { 4, "four" },
    { 5, "five" },
};
var points = new ObservableCollection<Tuple<double, double, double>>
{
    { 0, 0, 0 },
    { 1, 2, 3 },
    { -4, -2, 42 },
};

Natürlich sind Sie nicht beschränkt auf die Ausweitung Kollektionen von Tupeln, kann es sein, für die Sammlungen der eine bestimmte Art, die Sie wollen, dass die spezielle syntax für.

public static class BigIntegerListExtensions
{
    public static void Add(this IList<BigInteger> list,
        params byte[] value)
    {
        list.Add(new BigInteger(value));
    }

    public static void Add(this IList<BigInteger> list,
        string value)
    {
        list.Add(BigInteger.Parse(value));
    }
}

var bigNumbers = new List<BigInteger>
{
    new BigInteger(1), //constructor BigInteger(int)
    2222222222L,       //implicit operator BigInteger(long)
    3333333333UL,      //implicit operator BigInteger(ulong)
    { 4, 4, 4, 4, 4, 4, 4, 4 },               //extension Add(byte[])
    "55555555555555555555555555555555555555", //extension Add(string)
};

C# 7 wird das hinzufügen von Unterstützung für Personen gebaut, die in die Sprache, obwohl Sie von einem anderen Typ (System.ValueTuple statt). Also, es wäre gut, hinzufügen überladungen für Wert-Tupeln, so dass Sie die Möglichkeit haben, den Sie als gut. Leider gibt es keine impliziten Konvertierungen definiert zwischen den beiden.

public static class ValueTupleListExtensions
{
    public static void Add<T1, T2>(this IList<Tuple<T1, T2>> list,
        ValueTuple<T1, T2> item) => list.Add(item.ToTuple());
}

Diese Weise die Liste der Initialisierung Aussehen wird noch schöner.

var points = new List<Tuple<int, int, int>>
{
    (0, 0, 0),
    (1, 2, 3),
    (-1, 12, -73),
};

Aber anstatt zu gehen durch alle diese Probleme, vielleicht ist es einfach besser zu dem Schalter ValueTuple ausschließlich.

var points = new List<(int, int, int)>
{
    (0, 0, 0),
    (1, 2, 3),
    (-1, 12, -73),
};

InformationsquelleAutor der Antwort Jeff Mercado

Alte Frage, aber das ist, was ich normalerweise tun, um die Dinge ein bisschen mehr lesbar:

Func<int, string, Tuple<int, string>> tc = Tuple.Create;

var tupleList = new List<Tuple<int, string>>
{
    tc( 1, "cow" ),
    tc( 5, "chickens" ),
    tc( 1, "airplane" )
};

InformationsquelleAutor der Antwort Asad Saeeduddin

Einer Technik, die ich denke, ist ein wenig einfacher und die, die noch nicht erwähnt wurde hier:

var asdf = new [] { 
    (Age: 1, Name: "cow"), 
    (Age: 2, Name: "bird")
}.ToList();

Ich denke, das ist ein bisschen sauberer als:

var asdf = new List<Tuple<int, string>> { 
    (Age: 1, Name: "cow"), 
    (Age: 2, Name: "bird")
};

InformationsquelleAutor der Antwort Alex Dresko