튜플 목록을 쉽게 초기화하는 방법은 무엇입니까?

나는 튜플을 좋아한다 . 이를 통해 구조체 나 클래스를 작성하지 않고도 관련 정보를 빠르게 그룹화 할 수 있습니다. 매우 현지화 된 코드를 리팩토링하는 동안 매우 유용합니다.

그러나 목록을 초기화하면 약간 중복되는 것처럼 보입니다.

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은이를위한 새로운 기능인 extension 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대신). 따라서 가치 튜플에 과부하를 추가하면 사용할 수있는 옵션이 있습니다. 불행하게도, 둘 사이에 정의 된 암시 적 변환은 없습니다.

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

내가 생각하는 한 가지 기술은 조금 더 쉽고 여기에 언급되지 않은 기술입니다.

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>