Tuples listesini kolayca nasıl başlatabilirim?

Ben tuples seviyorum . İlgili bilgileri, bir yapı veya sınıf yazmak zorunda kalmadan hızlı bir şekilde gruplandırmanıza olanak tanır. Çok yerelleştirilmiş kodu yeniden düzenlerken bu çok kullanışlıdır.

Ancak bunların bir listesini başlatmak biraz gereksiz görünüyor.

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

Daha iyi bir yol yok mu? Sözlük başlatıcı çizgileri boyunca bir çözüm isterim .

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

Benzer bir sözdizimi kullanamaz mıyız?

c # 7.0 bunu yapmanızı sağlar:

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

Bir Listdiziye değil, sadece bir diziye ihtiyacınız varsa şunları yapabilirsiniz:

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

Ve "Öğe1" ve "Öğe2" yi beğenmediyseniz şunları yapabilirsiniz:

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

veya bir dizi için:

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

hangi yapmanıza izin verir: tupleList[0].IndexvetupleList[0].Name

4.6.2 ve önceki sürümler

Sen yüklemelisiniz System.ValueTupleNuget Paket Yöneticisinden.

Çerçeve 4.7 ve üstü

Çerçeve içine yerleştirilmiştir. Do not yüklemek System.ValueTuple. Aslında, onu kaldırın ve bin dizininden silin.

Not: Gerçek hayatta inek, tavuk veya uçak arasında seçim yapamazdım. Gerçekten paramparça olurdum.

Evet! Bu mümkün .

{} Herhangi çalışır başlatıcısı koleksiyonun sözdizimi IEnumerable bir sahiptir tip Ekleme argümanlar doğru miktarda yöntemi. Yorganın altında nasıl eserlerini rahatsız olmadan, bu araçlar sadece uzanabilir listesi <T> , sizin başlatmak için özel bir Add yöntemi ekleyin T ve bitirdiniz!

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

Bu, aşağıdakileri yapmanızı sağlar:

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

C # 6 sadece bunun için yeni bir özellik ekler: uzantı Yöntem ekle. Bu VB.net için her zaman mümkün olmuştur ancak şimdi C # 'da mevcuttur.

Artık Add()sınıflarınıza doğrudan yöntem eklemek zorunda değilsiniz, bunları uzantı yöntemleri olarak uygulayabilirsiniz. Herhangi bir numaralandırılabilir türü bir Add()yöntemle genişletirken , bunu koleksiyon başlatıcı ifadelerinde kullanabilirsiniz. Dolayısıyla, artık listelerden açıkça türemek zorunda değilsiniz ( başka bir cevapta belirtildiği gibi ), basitçe genişletebilirsiniz.

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

Bu, bunu uygulayan herhangi bir sınıfta yapmanızı sağlar 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 },
};

Elbette tuples koleksiyonlarını genişletmekle sınırlı değilsiniz, özel sözdizimini istediğiniz herhangi bir türden koleksiyonlar için olabilir.

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, dilde yerleşik olan tuples için destek ekleyecek, ancak bunlar farklı bir tür olacak ( System.ValueTuplebunun yerine). Bu nedenle, değer kümeleri için aşırı yükler eklemek iyi olur, böylece bunları da kullanma seçeneğiniz vardır. Ne yazık ki, ikisi arasında tanımlanmış örtük dönüşüm yoktur.

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

Bu şekilde liste başlatma daha da güzel görünecektir.

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

Ancak tüm bu sorunlardan geçmek yerine, sadece kullanmaya geçmek daha iyi olabilir ValueTuple.

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

Yapıcıyı her seferinde biraz daha iyi çağırarak bunu yapabilirsiniz

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

Eski soru, ama genellikle işleri biraz daha okunabilir hale getirmek için yaptığım şey bu:

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 biliyorum ama C # 7 kullanarak yöntemler üzerinde Linq ve devam lambdas kullanarak benim parça eklemek istiyorum. Ben bir sınıfta yeniden kullanıldığında DTOs ve anonim projeksiyonlar yerine olarak adlandırılmış tuples kullanmaya çalışın. Evet, alay etmek ve test etmek için hala sınıflara ihtiyacınız var, ancak bir şeyleri satır içi yapmak ve bir sınıfta dolaşmak, bu yeni seçeneğin IMHO'ya sahip olması güzel. Onları

1. Doğrudan Örnekleme

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

2. Mevcut bir koleksiyonun kapalı ve şimdi anonim projeksiyonların nasıl yapıldığına benzer iyi yazılmış tuples dönebilirsiniz.

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. Tüpleri daha sonra gruplama yöntemleriyle tekrar kullanın veya diğer mantıkta satır içi oluşturmak için bir yöntem kullanın:

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

Neden tuplleri seviyorsun? İsimsiz türlere benzer: isim yok. Verilerin yapısını anlayamıyorum.

Klasik dersleri severim

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

Sanırım bir teknik biraz daha kolay ve bundan daha önce bahsedilmemiş:

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

Bence bu biraz daha temiz:

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>