是否有一种方法可以使用Tuple类，但在其中提供项目的名称?
例如:
public Tuple<int, int, int int> GetOrderRelatedIds()
它返回OrderGroupId、OrderTypeId、OrderSubTypeId和OrderRequirementId的id。
让我的方法的用户知道哪个是哪个就好了。(当您调用该方法时，结果为result。Item1,结果。第二条,结果。Item3 result.Item4。不清楚哪个是哪个。)
(我知道我可以创建一个类来保存所有这些id，但这些id已经有自己的类，它们生活在其中，为这个方法的返回值创建一个类似乎很愚蠢。)
当前回答
TL:DR ->系统。ValueTuples可以自定义字段System的名称。元组不能。
澄清一下，在c# 7.0及更高版本中有两种不同类型的元组。
系统。元组 而且 系统。ValueTuple
当你通过tuple <…>类:
public Tuple<int, string, int> GetUserInfo();
您正在声明一个Tuple对象数据类型。
当你通过圆括号声明一个元组时:
public (int id, string name, int age) GetUserInfo();
您正在声明ValueTuple值数据类型。
每一个都有不同的功能和行为。在你的问题中，你的方法返回一个系统。元组对象。
不幸的是，通过系统创建的元组对象。元组类没有内置功能来给每个属性一个自定义名称。它们总是默认为ItemN，这取决于它们包含多少属性。
系统。另一方面，ValueTuple值可以包含自定义命名字段。
要了解更多信息，您可以参考Tuple类型(c#参考)和/或上面每个类的链接。但从本质上讲，文档强调的两种不同类型元组的一些关键区别是:
c#元组，由System。ValueTuple类型是不同的 由System表示的元组。Tuple类型。主要的 区别如下: 系统。ValueTuple类型是值类型。系统。元组类型是引用类型。 系统。ValueTuple类型是可变的。系统。元组类型是不可变的。 系统的数据成员。ValueTuple类型是字段。系统的数据成员。元组类型是属性。
如果你的方法需要返回一个System。元组对象，或者你更想要这种类型的对象的行为，那么在写这篇文章时，你无法实现你想要的。但是，如果您的方法可以返回System。ValueTuple值，然后您可以在返回值中给它自定义命名字段。
其他回答
如果你的项目类型都不同，这里是一个类，我做了更直观地获得他们。
这个类的用法:
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; } }
}
在。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()
};
您可以编写一个包含元组的类。
您需要重写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
TL:DR ->系统。ValueTuples可以自定义字段System的名称。元组不能。
澄清一下，在c# 7.0及更高版本中有两种不同类型的元组。
系统。元组 而且 系统。ValueTuple
当你通过tuple <…>类:
public Tuple<int, string, int> GetUserInfo();
您正在声明一个Tuple对象数据类型。
当你通过圆括号声明一个元组时:
public (int id, string name, int age) GetUserInfo();
您正在声明ValueTuple值数据类型。
每一个都有不同的功能和行为。在你的问题中，你的方法返回一个系统。元组对象。
不幸的是，通过系统创建的元组对象。元组类没有内置功能来给每个属性一个自定义名称。它们总是默认为ItemN，这取决于它们包含多少属性。
系统。另一方面，ValueTuple值可以包含自定义命名字段。
要了解更多信息，您可以参考Tuple类型(c#参考)和/或上面每个类的链接。但从本质上讲，文档强调的两种不同类型元组的一些关键区别是:
c#元组，由System。ValueTuple类型是不同的 由System表示的元组。Tuple类型。主要的 区别如下: 系统。ValueTuple类型是值类型。系统。元组类型是引用类型。 系统。ValueTuple类型是可变的。系统。元组类型是不可变的。 系统的数据成员。ValueTuple类型是字段。系统的数据成员。元组类型是属性。
如果你的方法需要返回一个System。元组对象，或者你更想要这种类型的对象的行为，那么在写这篇文章时，你无法实现你想要的。但是，如果您的方法可以返回System。ValueTuple值，然后您可以在返回值中给它自定义命名字段。
为什么每个人都让生活如此艰难。元组用于相当临时的数据处理。一直使用元组会使代码在某些时候非常难以理解。为所有东西创建类最终会使项目膨胀。
然而，这是关于平衡的……
你的问题似乎需要一门课程来解决。为了完整起见，下面这个类还包含构造函数。
这是合适的模式
自定义数据类型 没有进一步的功能。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;
}
