元组类中的命名比“Item1”、“Item2”更好

Question

有没有办法使用 Tuple 类，但提供其中项目的名称？

例如：

public Tuple<int, int, int int> GetOrderRelatedIds()

返回 OrderGroupId、OrderTypeId、OrderSubTypeId 和 OrderRequirementId 的 id。

如果能让我的方法的用户知道哪个是哪个，那就太好了。 （当你调用该方法时，结果是 result.Item1、result.Item2、result.Item3、result.Item4。目前尚不清楚哪个是哪个。）

（我知道我可以创建一个类来保存所有这些 Id ，但如果这些 Id 已经有自己的类，那么为这个方法的返回值创建一个类似乎很愚蠢。）

Answer 1

在 C# 7.0 (Visual Studio 2017) 中，有一个新的构造可以做到这一点：

(string first, string middle, string last) LookupName(long id)

Answer 2

在 C# 7.0 之前，除了定义自己的类型之外，没有其他方法可以做到这一点。

Answer 3

复制我在这篇帖子中的答案，因为它更适合这里。

从 C# v7.0 开始，现在可以命名元组属性，之前默认使用 Item1、Item2 等名称。

命名元组文字的属性：

var myDetails = (MyName: "Foo", MyAge: 22, MyFavoriteFood: "Bar");
Console.WriteLine($"Name - {myDetails.MyName}, Age - {myDetails.MyAge}, Passion - {myDetails.MyFavoriteFood}");

控制台上的输出：

Name - Foo, Age - 22, Passion - Bar

从方法返回元组（具有命名属性）：

static void Main(string[] args)
{
    var empInfo = GetEmpInfo();
    Console.WriteLine($"Employee Details: {empInfo.firstName}, {empInfo.lastName}, {empInfo.computerName}, {empInfo.Salary}");
}

static (string firstName, string lastName, string computerName, int Salary) GetEmpInfo()
{
    //This is hardcoded just for the demonstration. Ideally this data might be coming from some DB or web service call
    return ("Foo", "Bar", "Foo-PC", 1000);
}

控制台上的输出：

Employee Details: Foo, Bar, Foo-PC, 1000

创建元组列表具有命名属性

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

foreach (var tuple in tupleList)
    Console.WriteLine($"{tuple.Index} - {tuple.Name}");

控制台输出：

1 - cow  
5 - chickens  
1 - airplane

注意：本文中的代码片段使用 C# v6 的字符串插值功能，详细信息 此处。

Answer 4

这是您所问问题的一个过于复杂的版本：

class MyTuple : Tuple<int, int>
{
    public MyTuple(int one, int two)
        :base(one, two)
    {

    }

    public int OrderGroupId { get{ return this.Item1; } }
    public int OrderTypeId { get{ return this.Item2; } }

}

为什么不直接制作一个类？

Answer 5

TL：DR-> System.ValueTuple 可以具有自定义字段名称，而 System.Tuple 则不能。

澄清一下，C# 7.0 及更高版本中有 2 种不同类型的元组。在此之前，只有 1 种单一类型的元组可用。

System.Tuple （这是C# 7 之前存在的元组的原始类型）
和
System.ValueTuple（元组类型已在 C# 中添加 7)

当您通过 Tuple<...> 类声明一个元组时：

public Tuple<int, string, int> GetUserInfo();

您正在声明一个元组 对象数据类型。

当您通过括号声明元组时：

public (int id, string name, int age) GetUserInfo();

您正在声明 ValueTuple value 数据类型。

每一种的功能和行为都不同。在您的问题中，您的方法返回一个 System.Tuple 对象。

不幸的是，通过 System.Tuple 类创建的 Tuple 对象没有内置功能来为每个属性提供自定义名称。它们始终默认为 ItemN，具体取决于它们包含的属性数量。

另一方面，System.ValueTuple 值可以包含自定义命名字段。

有关更多信息，您可以参考 元组类型（C# 参考） 和/或上面每个类的链接。但本质上，文档强调的两种不同类型元组的一些主要区别是：

由 System.ValueTuple 类型支持的 C# 元组是不同的
来自由 System.Tuple 类型表示的元组。主要
区别如下：

• System.ValueTuple 类型是值类型。 System.Tuple 类型是引用类型。
• System.ValueTuple 类型是可变的。 System.Tuple 类型是不可变的。
• System.ValueTuple 类型的数据成员是字段。 System.Tuple 类型的数据成员是属性。

因此，如果您的方法需要返回 System.Tuple 对象或者您更希望该类型对象的行为，那么在编写本文时，您将无法实现您想要的。但是，如果您的方法可以返回 System.ValueTuple 值，那么您可以在返回值中为其提供自定义命名字段。

Answer 6

使用.net 4，您也许可以查看 ExpandoObject<但是，不要将它用于这种简单的情况，因为编译时错误会变成运行时错误。

class Program
{
    static void Main(string[] args)
    {
        dynamic employee, manager;

        employee = new ExpandoObject();
        employee.Name = "John Smith";
        employee.Age = 33;

        manager = new ExpandoObject();
        manager.Name = "Allison Brown";
        manager.Age = 42;
        manager.TeamSize = 10;

        WritePerson(manager);
        WritePerson(employee);
    }
    private static void WritePerson(dynamic person)
    {
        Console.WriteLine("{0} is {1} years old.",
                          person.Name, person.Age);
        // The following statement causes an exception
        // if you pass the employee object.
        // Console.WriteLine("Manages {0} people", person.TeamSize);
    }
}
// This code example produces the following output:
// John Smith is 33 years old.
// Allison Brown is 42 years old.

---

其他值得一提的是方法内的匿名类型 ，但是如果你想返回它，你需要创建一个类。

var MyStuff = new
    {
        PropertyName1 = 10,
        PropertyName2 = "string data",
        PropertyName3 = new ComplexType()
    };

Answer 7

MichaelMocko 回答得很好，

但我想添加一些我必须在

(string first, string middle, string last) LookupName(long id)

上面弄清楚的事情，如果您使用 .net Framework ，Line 会给您编译时错误 4.7

因此，如果您有一个使用 .net 框架的项目 4.7 并且您仍然想使用 ValueTuple，而不是安装 this NuGet 包

更新：

从方法返回命名元组并使用它的示例

public static (string extension, string fileName) GetFile()
{
    return ("png", "test");
}

使用它

var (extension, fileName) = GetFile();

Console.WriteLine(extension);
Console.WriteLine(fileName);

Answer 8

只是添加到 @MichaelMocko 答案。元组目前有几个问题：

您不能在 EF 表达式树中使用它们

示例：

public static (string name, string surname) GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        // Selecting as Tuple
        .Select(person => (person.Name, person.Surname))
        .First();
}

这将无法编译，并出现“表达式树可能不包含元组文字”错误。不幸的是，当将元组添加到语言中时，表达式树 API 并未扩展对元组的支持。

跟踪（并投票）此问题的更新：https://github.com/dotnet/roslyn/ issues/12897

要解决这个问题，您可以先将其转换为匿名类型，然后将值转换为元组：

// Will work
public static (string name, string surname) GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        .Select(person => new { person.Name, person.Surname })
        .ToList()
        .Select(person => (person.Name, person.Surname))
        .First();
}

另一种选择是使用 ValueTuple.Create：

// Will work
public static (string name, string surname) GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        .Select(person => ValueTuple.Create(person.Name, person.Surname))
        .First();
}

引用：

• https://www.damirscorner.com/blog/posts/20181207-NoSupportForTuplesInExpressionTrees.html

  
  

• <一href="https://stackoverflow.com/questions/43400071/convert-anonymous-type-to-new-c-sharp-7-tuple-type">将匿名类型转换为新的 C# 7 元组类型< /p>

你不能在 lambda 中解构它们

有一个添加支持的建议：https://github.com/dotnet/csharplang/issues/258

示例：

public static IQueryable<(string name, string surname)> GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        .Select(person => ValueTuple.Create(person.Name, person.Surname));
}

// This won't work
ctx.GetPersonName(id).Select((name, surname) => { return name + surname; })

// But this will
ctx.GetPersonName(id).Select(t => { return t.name + t.surname; })

参考文献：

• C# 7 元组和 lambda

它们不会很好地序列化

using System;
using Newtonsoft.Json;

public class Program
{
    public static void Main() {
        var me = (age: 21, favoriteFood: "Custard");
        string json = JsonConvert.SerializeObject(me);

        // Will output {"Item1":21,"Item2":"Custard"}
        Console.WriteLine(json); 
    }
}

元组字段名称仅在编译时可用，并在运行时完全消失。

参考文献：

• 使值元组属性名称在运行时可解析 (CSharpLang)
  
• C#7 元组支持 (Newtonsoft.Json)

Answer 9

到今天为止，事情就这么简单。 使用 this代替 Tuple 关键字

public Tuple<int, int, int int> GetOrderRelatedIds()

。

public (int alpha, int beta, int candor) GetOrderRelatedIds()

获取这样的值。

var a = GetOrderRelatedIds();
var c = a.alpha;

Answer 10

不，您不能命名元组成员。

中间的方法是使用 ExpandoObject 而不是元组。

Answer 11

如果你的物品类型都不同，这里是我制作的一个类，可以更直观地获取它们。

该类的用法：

var t = TypedTuple.Create("hello", 1, new MyClass());
var s = t.Get<string>();
var i = t.Get<int>();
var c = t.Get<MyClass>();

源码：

public static class TypedTuple
{
    public static TypedTuple<T1> Create<T1>(T1 t1)
    {
        return new TypedTuple<T1>(t1);
    }

    public static TypedTuple<T1, T2> Create<T1, T2>(T1 t1, T2 t2)
    {
        return new TypedTuple<T1, T2>(t1, t2);
    }

    public static TypedTuple<T1, T2, T3> Create<T1, T2, T3>(T1 t1, T2 t2, T3 t3)
    {
        return new TypedTuple<T1, T2, T3>(t1, t2, t3);
    }

    public static TypedTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 t1, T2 t2, T3 t3, T4 t4)
    {
        return new TypedTuple<T1, T2, T3, T4>(t1, t2, t3, t4);
    }

    public static TypedTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
    {
        return new TypedTuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
    }

    public static TypedTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
    {
        return new TypedTuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
    }

    public static TypedTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
    {
        return new TypedTuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
    }

    public static TypedTuple<T1, T2, T3, T4, T5, T6, T7, T8> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
    {
        return new TypedTuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
    }

}

public class TypedTuple<T>
{
    protected Dictionary<Type, object> items = new Dictionary<Type, object>();

    public TypedTuple(T item1)
    {
        Item1 = item1;
    }

    public TSource Get<TSource>()
    {
        object value;
        if (this.items.TryGetValue(typeof(TSource), out value))
        {
            return (TSource)value;
        }
        else
            return default(TSource);
    }

    private T item1;
    public T Item1 { get { return this.item1; } set { this.item1 = value; this.items[typeof(T)] = value; } }
}

public class TypedTuple<T1, T2> : TypedTuple<T1>
{
    public TypedTuple(T1 item1, T2 item2)
        : base(item1)
    {
        Item2 = item2;
    }

    private T2 item2;
    public T2 Item2 { get { return this.item2; } set { this.item2 = value; this.items[typeof(T2)] = value; } }
}

public class TypedTuple<T1, T2, T3> : TypedTuple<T1, T2>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3)
        : base(item1, item2)
    {
        Item3 = item3;
    }

    private T3 item3;
    public T3 Item3 { get { return this.item3; } set { this.item3 = value; this.items[typeof(T3)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4> : TypedTuple<T1, T2, T3>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4)
        : base(item1, item2, item3)
    {
        Item4 = item4;
    }

    private T4 item4;
    public T4 Item4 { get { return this.item4; } set { this.item4 = value; this.items[typeof(T4)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5> : TypedTuple<T1, T2, T3, T4>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
        : base(item1, item2, item3, item4)
    {
        Item5 = item5;
    }

    private T5 item5;
    public T5 Item5 { get { return this.item5; } set { this.item5 = value; this.items[typeof(T5)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5, T6> : TypedTuple<T1, T2, T3, T4, T5>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
        : base(item1, item2, item3, item4, item5)
    {
        Item6 = item6;
    }

    private T6 item6;
    public T6 Item6 { get { return this.item6; } set { this.item6 = value; this.items[typeof(T6)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5, T6, T7> : TypedTuple<T1, T2, T3, T4, T5, T6>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
        : base(item1, item2, item3, item4, item5, item6)
    {
        Item7 = item7;
    }

    private T7 item7;
    public T7 Item7 { get { return this.item7; } set { this.item7 = value; this.items[typeof(T7)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5, T6, T7, T8> : TypedTuple<T1, T2, T3, T4, T5, T6, T7>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
        : base(item1, item2, item3, item4, item5, item6, item7)
    {
        Item8 = item8;
    }

    private T8 item8;
    public T8 Item8 { get { return this.item8; } set { this.item8 = value; this.items[typeof(T8)] = value; } }
}

Answer 12

(double, int) t1 = (4.5, 3);
Console.WriteLine($"Tuple with elements {t1.Item1} and {t1.Item2}.");
// Output:
// Tuple with elements 4.5 and 3.

(double Sum, int Count) t2 = (4.5, 3);
Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");
// Output:
// Sum of 3 elements is 4.5.

来自文档： https://learn .microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-tuples

Answer 13

这非常烦人，我希望 C# 的未来版本能够满足这一需求。我发现最简单的解决方法是使用不同的数据结构类型或重命名“项目”，以保证您和其他人阅读您的代码的理智。

Tuple<ApiResource, JSendResponseStatus> result = await SendApiRequest();
ApiResource apiResource = result.Item1;
JSendResponseStatus jSendStatus = result.Item2;

Answer 14

为什么不使用多重返回而不是使用元组

var handler = GenerateFromMethod1(hits);
Process(handler.string1, handler.string1);

private static (string string1, string string2) GenerateFromMethod1()
{

}

Answer 15

我想我会创建一个类，但另一种选择是输出参数。

public void GetOrderRelatedIds(out int OrderGroupId, out int OrderTypeId, out int OrderSubTypeId, out int OrderRequirementId)

由于您的元组仅包含整数，因此您可以使用 Dictionary 表示它，

var orderIds = new Dictionary<string, int> {
    {"OrderGroupId", 1},
    {"OrderTypeId", 2},
    {"OrderSubTypeId", 3},
    {"OrderRequirementId", 4}.
};

但我也不建议这样做。

Answer 16

为什么每个人都让生活如此艰难。元组用于临时数据处理。一直使用元组会使代码在某些时候变得非常难以理解。为所有创建类最终可能会使您的项目变得臃肿。

然而，这是关于平衡的......

你的问题似乎是你想要上课的问题。为了完整起见，下面的类还包含构造函数。

---

的正确模式

• 这是自定义数据类型
  • 没有更多功能。 getter 和 setter 也可以通过代码进行扩展，获取/设置名称模式为“_orderGroupId”的私有成员，同时还执行功能代码。
• 包括构造函数。如果所有属性都是必需的，您还可以选择仅包含一个构造函数。
• 如果您想使用所有构造函数，像这样的冒泡是避免重复代码的正确模式。

---

public class OrderRelatedIds
{
    public int OrderGroupId { get; set; }
    public int OrderTypeId { get; set; }
    public int OrderSubTypeId { get; set; }
    public int OrderRequirementId { get; set; }

    public OrderRelatedIds()
    {
    }
    public OrderRelatedIds(int orderGroupId)
        : this()
    {
        OrderGroupId = orderGroupId;
    }
    public OrderRelatedIds(int orderGroupId, int orderTypeId)
        : this(orderGroupId)
    {
        OrderTypeId = orderTypeId;
    }
    public OrderRelatedIds(int orderGroupId, int orderTypeId, int orderSubTypeId)
        : this(orderGroupId, orderTypeId)
    {
        OrderSubTypeId = orderSubTypeId;
    }
    public OrderRelatedIds(int orderGroupId, int orderTypeId, int orderSubTypeId, int orderRequirementId)
        : this(orderGroupId, orderTypeId, orderSubTypeId)
    {
        OrderRequirementId = orderRequirementId;
    }
}

或者，如果您想要非常简单：您还可以使用类型初始值设定项：

OrderRelatedIds orders = new OrderRelatedIds
{
    OrderGroupId = 1,
    OrderTypeId = 2,
    OrderSubTypeId = 3,
    OrderRequirementId = 4
};

public class OrderRelatedIds
{
    public int OrderGroupId;
    public int OrderTypeId;
    public int OrderSubTypeId;
    public int OrderRequirementId;
}

Answer 17

我会在摘要中写下项目名称。
因此，将鼠标悬停在函数 helloworld() 上，文本将显示 hello = Item1 和 world = Item2

 helloworld("Hi1,Hi2");

/// <summary>
/// Return hello = Item1 and world Item2
/// </summary>
/// <param name="input">string to split</param>
/// <returns></returns>
private static Tuple<bool, bool> helloworld(string input)
{
    bool hello = false;
    bool world = false;
    foreach (var hw in input.Split(','))
    {
        switch (hw)
        {
            case "Hi1":
                hello= true;
                break;
            case "Hi2":
                world= true;
                break;
        }

    }
    return new Tuple<bool, bool>(hello, world);
}

Answer 18

嘿，如果您在删除命名元组参数时遇到动态或对象转换问题，只需创建一个函数，通过引用传递动态/对象转换指针并在返回时重新转换它......让这个坏男孩工作......

Answer 19

如果您需要一个小类来存储数据（而不是像 ValueTuple 这样的结构），那么从 C# 9 开始，您可以使用 record 而不是 Tuple 类

例如：

internal class Program
{
    record OrderInfo(int OrderGroupId, int OrderTypeId, int OrderSubTypeId, int OrderRequirementId);
    
    private static void Main(string[] args)
    {
        OrderInfo order_info = new OrderInfo(0, 1, 2, 3);
        //order_info.OrderGroupId = 1;//you can't change the value of init-only property
        Console.WriteLine(order_info.OrderSubTypeId);//2
    }
}

Answer 20

您可以编写一个包含元组的类。

您需要重写 Equals 和 GetHashCode 函数

以及 == 和 != 运算符。

class Program
{
    public class MyTuple
    {
        private Tuple<int, int> t;

        public MyTuple(int a, int b)
        {
            t = new Tuple<int, int>(a, b);
        }

        public int A
        {
            get
            {
                return t.Item1;
            }
        }

        public int B
        {
            get
            {
                return t.Item2;
            }
        }

        public override bool Equals(object obj)
        {
            return t.Equals(((MyTuple)obj).t);
        }

        public override int GetHashCode()
        {
            return t.GetHashCode();
        }

        public static bool operator ==(MyTuple m1, MyTuple m2)
        {
            return m1.Equals(m2);
        }

        public static bool operator !=(MyTuple m1, MyTuple m2)
        {
            return !m1.Equals(m2);
        }
    }

    static void Main(string[] args)
    {
        var v1 = new MyTuple(1, 2);
        var v2 = new MyTuple(1, 2);

        Console.WriteLine(v1 == v2);

        Dictionary<MyTuple, int> d = new Dictionary<MyTuple, int>();
        d.Add(v1, 1);

        Console.WriteLine(d.ContainsKey(v2));
    }
}

将返回：

True

True

Answer 21

C# 7 元组示例

var tuple = TupleExample(key, value);

     private (string key1, long value1) ValidateAPIKeyOwnerId(string key, string value)
            {
                return (key, value);
            }
      if (!string.IsNullOrEmpty(tuple.key1) && tuple.value1 > 0)
          {
                    //your code

                }