C# 列表中有多个参数。如何在没有类的情况下创建？

这可能是一个非常明显的问题，但是我如何创建一个具有多个参数的

列表

，而不创建一个类呢

例如：

var list = new List<string, int>();

list.Add("hello", 1);

然后通过执行以下操作创建我的列表：

var list = new List<MyClass>();
list.Add(new MyClass { myString = "hello", myInt32 = 1 });

var list=newlist（）；
添加（新的MyClass{myString=“hello”，myInt32=1}）；

如果您使用的是.NET 4.0，则可以使用

列表；

---

对于较旧版本的.NET，您必须创建一个自定义类（除非您足够幸运，能够在基类库中找到一个适合您需要的类）。

如果您不介意项目是可修改的，您可以使用添加到.NET 4中的类

var list = new List<Tuple<string,int>>();
list.Add(new Tuple<string,int>("hello", 1));

list[0].Item1 //Hello
list[0].Item2 //1

var list=newlist（）；
添加（新元组（“hello”，1））；
列表[0]。项1//您好
列表[0]。项2//1

---

但是，如果每次添加两个项目，并且其中一个是唯一id，则可以使用一个列表，该列表只接受一个类型参数。 您将从列表中获得的最接近的结果是：

 var list = new List<Tuple<string, int>>();
 list.Add(Tuple.Create("hello", 1));

var list=newlist（）；
添加（Tuple.Create（“hello”，1））；

如果合适，您可以使用字典，它也是一个通用集合：

Dictionary<string, int> d = new Dictionary<string, int>();
d.Add("string", 1);

Dictionary d=newdictionary（）；
d、 添加（“字符串”，1）；

正如Scott Chamberlain（和其他几位）所说，如果您不介意使用不可变（即只读）对象，元组的工作效果最好

例如，如果像David建议的那样，希望通过字符串值引用int，那么应该使用字典

Dictionary<string, int> d = new Dictionary<string, int>();
d.Add("string", 1);
Console.WriteLine(d["string"]);//prints 1

Dictionary d=newdictionary（）；
d、 添加（“字符串”，1）；
Console.WriteLine（d[“string”]）//印刷品1

但是，如果您希望将元素可变地存储在列表中，并且不希望使用字典式的引用系统，那么您最好的选择（即目前唯一的真正解决方案）是使用KeyValuePair，它本质上是std:：pair for C#：

var-kvp=新的KeyValuePair（2，“a”）；
//kvp.Key=2和a.Value=“a”；
kvp.Key=3//关键和关键
kvp.Value=“b”//价值是可变的

当然，这是可以堆叠的，所以如果你需要一个更大的元组（比如如果你需要4个元素），你只需要堆叠它。就算这很快变得丑陋：

     var quad=new KeyValuePair<KeyValuePair<int,string>, KeyValuePair<int,string>>
                (new KeyValuePair<int,string>(3,"a"),
                new KeyValuePair<int,string>(4,"b"));
//quad.Key.Key=3

var quad=新的KeyValuePair
（新的KeyValuePair（3，“a”），
新的KeyValuePair（4，“b”）；
//quad.Key.Key=3

很明显，如果要这样做，可能还应该定义一个辅助函数

我的建议是，如果元组包含2个以上的元素，请定义自己的类。您可以使用typedef-esque-using语句，如：

using quad = KeyValuePair<KeyValuePair<int,string>, KeyValuePair<int,string>>;

使用quad=KeyValuePair；

---

但这并没有使实例化变得更容易。如果在使用2个以上元素的元组时使用用户定义的类，您可能会花更少的时间编写模板参数，花更多的时间在非样板代码上，以添加到其他建议中的内容。我喜欢以下构造，以避免将成员添加到keyvaluepair集合中的麻烦

public class KeyValuePairList<Tkey,TValue> : List<KeyValuePair<Tkey,TValue>>{
    public void Add(Tkey key, TValue value){
        base.Add(new KeyValuePair<Tkey, TValue>(key, value));
    }
}

public类KeyValuePairList:列表{
公共无效添加（Tkey键，TValue值）{
添加（新的KeyValuePair（key，value））；
}
}

这意味着可以使用更好的语法初始化构造函数：

var myList = new KeyValuePairList<int,string>{{1,"one"},{2,"two"},{3,"three"}};

var myList=newkeyvaluepairlist{{1，“一”}，{2，“二”}，{3，“三”}；

我个人喜欢上面的代码，而不是更详细的示例。不幸的是，C#本身并不真正支持元组类型，所以这个小技巧非常有效

如果您发现自己确实需要多于2个，我建议针对tuple类型创建抽象（虽然

tuple

是一个类，而不是像

KeyValuePair

这样的结构，但这是一个有趣的区别）

---

奇怪的是，初始值设定项列表语法在任何

IEnumerable

上都可用，它允许您使用任何

Add

方法，甚至是那些对象实际上无法枚举的方法。允许将

对象[]

成员添加为

参数对象[]

成员这样的操作非常方便。

这对我来说很好

List<string> myList = new List<string>();
myList.Add(string.Format("{0}|{1}","hello","1") ;


label:myList[0].split('|')[0] 
val:  myList[0].split('|')[1]

List myList=new List（）；
Add（string.Format（“{0}{1}”，“hello”，“1”）；
标签：myList[0]。拆分（“|”）[0]
val:myList[0]。拆分（“|”）[1]

适用于那些想要使用类的人

创建一个包含所有所需参数的类

创建一个以类为参数的列表

class-MyClass
{
公共字符串S1；
公共字符串S2；
}
List MyList=new List（）；

另一个解决方案创建匿名类型的通用列表

 var list = new[]
 { 
    new { Number = 10, Name = "Smith" },
    new { Number = 10, Name = "John" } 
 }.ToList();

 foreach (var item in list)
 {
    Console.WriteLine(item.Name);
 }

---

这也为您提供了

intellisense

支持，我认为在某些情况下，它比

Tuple

和

Dictionary

从数据库中获取模式名和表名要好

        public IList<Tuple<string, string>> ListTables()
        {

            DataTable dt = con.GetSchema("Tables");

            var tables = new List<Tuple<string, string>>();

            foreach (DataRow row in dt.Rows)
            {
            string schemaName = (string)row[1];
            string tableName = (string)row[2];
            //AddToList();
            tables.Add(Tuple.Create(schemaName, tableName));
            Console.WriteLine(schemaName +" " + tableName) ;
            }
            return tables;
        }

public IList ListTables（）
{
DataTable dt=con.GetSchema（“表”）；
var tables=新列表（）；
foreach（数据行中的数据行）
{
字符串模式名=（字符串）行[1]；
字符串tableName=（字符串）行[2]；
//AddToList（）；
Add（Tuple.Create（schemaName，tableName））；
Console.WriteLine（schemaName+“”+tableName）；
}
返回表；
}

你确定你想要的是列表而不是字典吗？你可能应该就你的实际问题提供更多的细节，这样就清楚了你为什么要这样做。你想用列表做什么？我不想要字典。我试着用一个简单的例子…我将使用两个字符串，我通过a以JSON格式返回SP.NET MVC

Controller.Json

+1，虽然Tuple是在.NET 4中引入的，所以在.NET 3.5中，他仍然坚持写一个类。@大卫：他在问“不创建类”怎么做。@吉姆·舒伯特：当然，这很公平。不过，如果他在可预见的未来使用3.5，那么Tuple类将成为一个方便的可重用实用程序。@Darcy:这个blog有一个.NET3.5的元组实现：+1

List<string> myList = new List<string>();
myList.Add(string.Format("{0}|{1}","hello","1") ;


label:myList[0].split('|')[0] 
val:  myList[0].split('|')[1]

 var list = new[]
 { 
    new { Number = 10, Name = "Smith" },
    new { Number = 10, Name = "John" } 
 }.ToList();

 foreach (var item in list)
 {
    Console.WriteLine(item.Name);
 }

        public IList<Tuple<string, string>> ListTables()
        {

            DataTable dt = con.GetSchema("Tables");

            var tables = new List<Tuple<string, string>>();

            foreach (DataRow row in dt.Rows)
            {
            string schemaName = (string)row[1];
            string tableName = (string)row[2];
            //AddToList();
            tables.Add(Tuple.Create(schemaName, tableName));
            Console.WriteLine(schemaName +" " + tableName) ;
            }
            return tables;
        }