タプルのリストを簡単に初期化する方法は？

タプル大好きです。これらを使用すると、構造体やクラスを記述しなくても、関連情報をすばやくグループ化できます。これは、非常にローカライズされたコードをリファクタリングするときに非常に役立ちます。

ただし、それらのリストの初期化は少し冗長に思われます。

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

もっと良い方法はありませんか？辞書イニシャライザに沿った解決策が欲しいです。

Dictionary<int, string> students = new Dictionary<int, string>()
{
    { 111, "bleh" },
    { 112, "bloeh" },
    { 113, "blah" }
};

同様の構文を使用できませんか？

c＃7.0ではこれを行うことができます：

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

を必要とせずList、配列だけが必要な場合は、次のようにできます。

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

また、「Item1」と「Item2」が気に入らない場合は、次のようにできます。

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

または配列の場合：

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

これはあなたが行うことができます：tupleList[0].IndexとtupleList[0].Name

フレームワーク4.6.2以下

System.ValueTupleNuget Package Managerからインストールする必要があります。

フレームワーク4.7以降

フレームワークに組み込まれています。インストールしないでくださいSystem.ValueTuple。実際には、それを削除してbinディレクトリから削除してください。

注：実際には、牛、鶏、飛行機のいずれかを選択することはできません。本当に引き裂かれます。

はい！これは可能です。

コレクション初期化子の{}構文は、正しい数の引数 を持つAddメソッドを持つすべてのIEnumerableタイプで機能します。それが内部でどのように機能するかを気にすることなく、つまり、単純にList <T>から拡張し、カスタムのAddメソッドを追加してTを初期化 すれば完了です。

public class TupleList<T1, T2> : List<Tuple<T1, T2>>
{
    public void Add( T1 item, T2 item2 )
    {
        Add( new Tuple<T1, T2>( item, item2 ) );
    }
}

これにより、次のことが可能になります。

var groceryList = new TupleList<int, string>
{
    { 1, "kiwi" },
    { 5, "apples" },
    { 3, "potatoes" },
    { 1, "tomato" }
};

C＃6は、このための新機能を追加します。拡張Addメソッドです。これは常にVB.netで可能でしたが、C＃で利用できるようになりました。

これでAdd()、クラスにメソッドを直接追加する必要がなくなり、拡張メソッドとして実装できます。Add()メソッドを使用して列挙可能な型を拡張すると、コレクション初期化式でその型を使用できるようになります。そのため、リストから明示的に派生する必要はもうありません（別の回答で述べられているように）、単純に拡張できます。

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

これにより、を実装するすべてのクラスでこれを行うことができます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 },
};

もちろん、タプルのコレクションを拡張することに限定されず、特別な構文が必要な特定のタイプのコレクションを対象とすることができます。

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は、言語に組み込まれたタプルのサポートを追加しますが、タイプは異なります（System.ValueTuple代わりに）。そのため、値タプルにオーバーロードを追加して、それらを使用するオプションを追加することをお勧めします。残念ながら、2つの間に定義された暗黙の変換はありません。

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

これにより、リストの初期化がさらに見やすくなります。

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

ただし、このような問題をすべて解決するのではなく、ValueTuple独占的に使用するように切り替える方がよい場合があります。

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

あなたは毎回コンストラクタを呼び出すことでこれを行うことができます

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

古い質問ですが、これは私が物事を少し読みやすくするために通常行うことです：

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

Super Duper Old知っていますが、C＃7を使用して、Linqと継続ラムダをメソッドに追加します。クラスで再利用する場合は、DTOと匿名プロジェクションの代わりに名前付きタプルを使用します。はい、モックとテストにはクラスが必要ですが、インラインでクラス内でやり取りすることは、この新しいオプションIMHOを使用するのに適しています。あなたはそれらをインスタンス化することができます

1. 直接インスタンス化

var items = new List<(int Id, string Name)> { (1, "Me"), (2, "You")};

2. 既存のコレクションから、匿名の射影が行われていた方法と同様に、よく型付けされたタプルを返すことができます。

public class Hold
{
    public int Id { get; set; }
    public string Name { get; set; }
}

//In some method or main console app:
var holds = new List<Hold> { new Hold { Id = 1, Name = "Me" }, new Hold { Id = 2, Name = "You" } };
var anonymousProjections = holds.Select(x => new { SomeNewId = x.Id, SomeNewName = x.Name });
var namedTuples = holds.Select(x => (TupleId: x.Id, TupleName: x.Name));

3. 後でグループ化メソッドでタプルを再利用するか、メソッドを使用して他のロジックでインラインでタプルを構築します。

//Assuming holder class above making 'holds' object
public (int Id, string Name) ReturnNamedTuple(int id, string name) => (id, name);
public static List<(int Id, string Name)> ReturnNamedTuplesFromHolder(List<Hold> holds) => holds.Select(x => (x.Id, x.Name)).ToList();
public static void DoSomethingWithNamedTuplesInput(List<(int id, string name)> inputs) => inputs.ForEach(x => Console.WriteLine($"Doing work with {x.id} for {x.name}"));

var namedTuples2 = holds.Select(x => ReturnNamedTuple(x.Id, x.Name));
var namedTuples3 = ReturnNamedTuplesFromHolder(holds);
DoSomethingWithNamedTuplesInput(namedTuples.ToList());

なぜタプルが好きですか？それは匿名型のようなもので、名前はありません。データの構造を理解できません。

クラシッククラスが好き

class FoodItem
{
     public int Position { get; set; }
     public string Name { get; set; }
}

List<FoodItem> list = new List<FoodItem>
{
     new FoodItem { Position = 1, Name = "apple" },
     new FoodItem { Position = 2, Name = "kiwi" }
};

私が思う1つのテクニックは少し簡単で、これは前にここで言及されていません：

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

私はそれが少しきれいだと思います：

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>