如何轻松地初始化元组列表?

小开

集合初始化式的{}语法适用于任何IEnumerable 类型，它具有具有正确数量参数的添加方法。不用担心在被窝里是怎么工作的，这意味着你可以简单地扩展List< T>，添加一个自定义add方法来初始化你的 T， and you are done!

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

小开

您可以通过每次调用构造函数来实现这一点

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

小开

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)。因此，为值元组添加重载是很好的，这样你也可以选择使用它们。不幸的是，在这两者之间没有定义隐式转换。

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

小开

老问题了，但这是我通常做的事情，让事情更具可读性:

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

小开

    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>

小开

最佳答案

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包管理器中安装System.ValueTuple。

框架4.7及以上

它被内置到框架中。执行不安装System.ValueTuple。事实上，将它从bin目录中删除。

注意:在现实生活中，我无法在牛、鸡和飞机之间做出选择。我真的会很纠结。

小开

我认为有一个技巧比较简单，但之前没有提到过:

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

小开

超级老我知道，但我会在使用Linq和使用c# 7的方法上添加我的部分。在类中重用时，我尝试使用命名元组替换dto和匿名投影。是的，对于模拟和测试，你仍然需要类，但是内联做事情和在类中传递是很好的，有这个更新的选项。您可以实例化它们

直接实例化

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

现在您可以返回类型良好的元组，类似于匿名投影的方式。

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

稍后使用分组方法重用这些元组，或者使用其他逻辑中的方法内联构造它们:

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