Bagaimana cara mudah menginisialisasi daftar Tuples?

Saya suka tuple . Mereka memungkinkan Anda untuk dengan cepat mengelompokkan informasi yang relevan bersama tanpa harus menulis struct atau kelas untuk itu. Ini sangat berguna saat refactoring kode yang sangat lokal.

Menginisialisasi daftar mereka tampaknya agak berlebihan.

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

Apakah tidak ada cara yang lebih baik? Saya ingin solusi di sepanjang baris penginisialisasi Kamus .

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

Tidak bisakah kita menggunakan sintaksis yang sama?

c # 7.0 memungkinkan Anda melakukan ini:

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

Jika Anda tidak membutuhkan List, tetapi hanya sebuah array, Anda dapat melakukannya:

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

Dan jika Anda tidak menyukai "Item1" dan "Item2", Anda dapat melakukannya:

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

atau untuk sebuah array:

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

yang memungkinkan Anda melakukannya: tupleList[0].IndexdantupleList[0].Name

Kerangka 4.6.2 dan di bawah

Anda harus menginstal System.ValueTupledari Package Manager Nuget.

Kerangka 4.7 dan di atas

Itu dibangun ke dalam kerangka kerja. Jangan tidak menginstal System.ValueTuple. Bahkan, hapus dan hapus dari direktori bin.

Catatan: Dalam kehidupan nyata, saya tidak akan bisa memilih antara sapi, ayam atau pesawat. Saya akan benar-benar terkoyak.

Iya! Ini mungkin .

The {} sintaks dari koleksi initializer bekerja pada setiap IEnumerable jenis yang memiliki Tambah metode dengan jumlah yang benar argumen. Tanpa mempedulikan cara kerjanya di balik sampul, itu berarti Anda cukup memperluas dari Daftar <T> , menambahkan metode Tambahkan kustom untuk menginisialisasi T Anda , dan Anda selesai!

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

Ini memungkinkan Anda melakukan hal berikut:

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

C # 6 menambahkan fitur baru hanya untuk ini: ekstensi Tambahkan metode. Ini selalu dimungkinkan untuk VB.net tetapi sekarang tersedia dalam C #.

Sekarang Anda tidak perlu menambahkan Add()metode ke kelas secara langsung, Anda dapat menerapkannya sebagai metode ekstensi. Saat memperluas jenis enumerable apa pun dengan Add()metode, Anda akan dapat menggunakannya dalam ekspresi initializer koleksi. Jadi, Anda tidak harus menurunkan daftar lagi secara eksplisit ( seperti yang disebutkan dalam jawaban lain ), Anda dapat memperpanjangnya.

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

Ini akan memungkinkan Anda untuk melakukan ini pada kelas apa pun yang mengimplementasikan 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 },
};

Tentu saja Anda tidak dibatasi untuk memperluas koleksi tupel, itu bisa untuk koleksi jenis tertentu yang Anda inginkan untuk sintaks khusus.

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 akan menambahkan dukungan untuk tuple yang dibangun ke dalam bahasa, meskipun mereka akan dari jenis yang berbeda ( System.ValueTuplesebagai gantinya). Jadi, sebaiknya tambahkan kelebihan untuk tuple nilai sehingga Anda memiliki opsi untuk menggunakannya juga. Sayangnya, tidak ada konversi implisit yang ditentukan di antara keduanya.

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

Dengan cara ini, inisialisasi daftar akan terlihat lebih bagus.

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

Tetapi alih-alih melalui semua masalah ini, mungkin lebih baik beralih ke menggunakan ValueTuplesecara eksklusif.

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

Anda dapat melakukan ini dengan memanggil konstruktor setiap kali dengan sedikit lebih baik

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

Pertanyaan lama, tapi inilah yang biasanya saya lakukan untuk membuat hal-hal sedikit lebih mudah dibaca:

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 Tua Saya tahu tetapi saya akan menambahkan bagian saya tentang menggunakan Linq dan kelanjutan lambdas tentang metode dengan menggunakan C # 7. Saya mencoba menggunakan tuple bernama sebagai pengganti untuk DTO dan proyeksi anonim ketika digunakan kembali di kelas. Ya untuk mengejek dan menguji Anda masih perlu kelas tetapi melakukan hal-hal inline dan berkeliling di kelas bagus untuk memiliki opsi IMHO ini lebih baru. Anda dapat membuat instantiate dari

1. Instansiasi langsung

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

2. Di luar koleksi yang ada, dan sekarang Anda dapat mengembalikan tupel yang diketik dengan baik, mirip dengan bagaimana proyeksi anonim dulu dilakukan.

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. Gunakan kembali tupel nanti dengan metode pengelompokan atau gunakan metode untuk membangunnya sesuai logika lain

//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());

Mengapa suka tupel? Ini seperti jenis anonim: tidak ada nama. Tidak dapat memahami struktur data.

Saya suka kelas klasik

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

Satu teknik yang saya pikir sedikit lebih mudah dan itu belum disebutkan sebelumnya di sini:

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

Saya pikir itu sedikit lebih bersih daripada:

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>