Tuples 목록을 쉽게 초기화하려면 어떻게 해야 합니까?

Tuples 목록을 쉽게 초기화하려면 어떻게 해야 합니까?

난 튜플이 좋아.이를 통해 관련 정보를 빠르게 그룹화할 수 있으며, 이에 대한 구조나 클래스를 작성할 필요가 없습니다.이것은 매우 현지화된 코드를 리팩터링할 때 매우 유용합니다.

다만, 리스트의 초기화는 다소 장황한 것 같습니다.

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 이하

Nuget Package Manager에서 설치해야 합니다.

프레임워크 4.7 이상

프레임워크에 포함되어 있습니다.인스톨 하지 않다System.ValueTuple. 실제로 삭제한 후 bin 디렉토리에서 삭제합니다.

메모: 현실에서는 소, 닭, 비행기 중 하나를 선택할 수 없습니다.정말 마음이 찢어질 것 같아요.

네! 가능합니다.

컬렉션 이니셜라이저의 { } 구문은 인수 수가 올바른 추가 메서드가 있는 IEnumerable 유형에서 작동합니다.커버 아래에 작동하는 방법을 귀찮게 하지 않으면 목록<<를 확장시킬 수 있습니다.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은 이 확장 방법만 추가 방법을 추가합니다.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());

한 가지 기술은 조금 더 쉽다고 생각합니다만, 그 전에 여기에 언급된 적이 없습니다.

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>

언급URL : https://stackoverflow.com/questions/8002455/how-to-easily-initialize-a-list-of-tuples