Comment initialiser une liste de Tuples?

c# 7.0 vous permet de faire cela:

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

Si vous n'avez pas besoin d'un List, mais juste un tableau, vous pouvez le faire:

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

Et si vous n'aimez pas "Élément1" et "Item2", vous pouvez le faire:

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

ou

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

qui vous permet de le faire: tupleList[0].Index et tupleList[0].Name

Cadre 4.6.2 ci-dessous et

Vous devez installer System.ValueTuple à partir du Gestionnaire de Package Nuget.

Cadre de 4,7 et au-dessus de

Il est intégré dans le cadre. Ne pas installer System.ValueTuple. En fait, supprimer et le supprimer à partir du répertoire bin.

remarque: Dans la vraie vie, je ne serais pas capable de choisir entre de vache, des poules ou en avion. Je serais vraiment déchiré.

C# 6 ajoute une nouvelle fonctionnalité pour cette: extension d'Ajouter des méthodes. Cela a toujours été possible pour VB.net mais il est maintenant disponible en C#.

Maintenant, vous n'avez pas à ajouter Add() méthodes des classes directement, vous pouvez les mettre en œuvre que les méthodes d'extension. Lors de l'extension de toute énumérable type avec un Add() méthode, vous serez capable de l'utiliser dans la collecte de l'initialiseur d'expressions. Si vous n'avez pas à dériver à partir des listes explicitement plus (comme mentionné dans une autre réponse), vous pouvez simplement l'étendre.

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...
}

Cela vous permettra de faire sur n'importe quel classe qui implémente 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 },
};

Bien sûr, vous n'êtes pas limité à l'extension des collections de tuples, il peut être pour les collections de tout type spécifique que vous souhaitez la syntaxe spéciale pour.

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 sera l'ajout du support pour les tuples construit dans la langue, bien qu'ils soient d'un type différent (System.ValueTuple à la place). Donc, il serait bon d'ajouter des surcharges pour une valeur de n-uplets de sorte que vous avez la possibilité de les utiliser ainsi. Malheureusement, il n'existe pas de conversion implicite entre les deux.

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

Cette façon, la liste d'initialisation sera d'autant plus agréable.

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

Mais au lieu de passer par toutes ces difficultés, c'est peut-être mieux de passer à l'utilisation ValueTuple exclusivement.

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

Vieille question, mais c'est ce que je faire pour rendre les choses un peu plus lisible:

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

Une technique je pense, est un peu plus facile et qui n'a pas été mentionné avant ici:

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

Je pense que c'est un peu plus propre que:

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

    var colors = new[]
{
new { value = Color.White, name = "White" },
new { value = Color.Silver, name = "Silver" },
new { value = Color.Gray, name = "Gray" },
new { value = Color.Black, name = "Black" },
new { value = Color.Red, name = "Red" },
new { value = Color.Maroon, name = "Maroon" },
new { value = Color.Yellow, name = "Yellow" },
new { value = Color.Olive, name = "Olive" },
new { value = Color.Lime, name = "Lime" },
new { value = Color.Green, name = "Green" },
new { value = Color.Aqua, name = "Aqua" },
new { value = Color.Teal, name = "Teal" },
new { value = Color.Blue, name = "Blue" },
new { value = Color.Navy, name = "Navy" },
new { value = Color.Pink, name = "Pink" },
new { value = Color.Fuchsia, name = "Fuchsia" },
new { value = Color.Purple, name = "Purple" }
};
foreach (var color in colors)
{
stackLayout.Children.Add(
new Label
{
Text = color.name,
TextColor = color.value,
});
FontSize = Device.GetNamedSize(NamedSize.Large, typeof(Label))
}
this is a Tuple<Color, string>