.net KeyValuePair列表

为什么.NET不为

列表提供类

我认为在很多情况下，你需要保持一个成对的数组。比如说,

1; 2      "a"; "array"
5; 8      "b"; "browser"
1; 9      "f"; "Firefox"
8; 10     "f"; "frequency"

Àla：

Pairs<int, int> myPairs;

myPairs.Add(10, 8);
myPairs.Add(5, 8);
myPairs.Add(10, 5);
myPairs.Add(1, 4);

myPairs[0].Value1 = 5;
myPairs[5].Value2 = 8;

Pairs-myPairs；
添加（10,8）；
添加（5,8）；
添加（10,5）；
添加（1,4）；
myPairs[0]。值1=5；
myPairs[5]。值2=8；
您可能正在寻找：

表示键和值的集合

字典
是一个专门的集合，针对键/值对进行了优化。虽然您可以自由创建一个
列表
，但由于您无法优化密钥值的访问权限，因此您正在短时间更改自己。
您可能正在寻找：

表示键和值的集合

字典
是一个专门的集合，针对键/值对进行了优化。虽然您可以自由创建一个
列表
，但由于您无法对密钥进行优化访问，因此您的更改量很小。
是什么阻止您直接使用
列表
？而且，如果您知道
T
和
V
，您可以在源文件的顶部将其别名：

using KeyValueList = System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<MyNS.MyKeyType, MyNS.MyValueType>>;

// in your code...
KeyValueList list = new KeyValueList();
list.Add(new KeyValuePair<MyKeyType, MyValueType>(..., ...));

使用KeyValueList=System.Collections.Generic.List；
//在你的代码中。。。
KeyValueList list=新的KeyValueList（）；
添加（新的KeyValuePair（…，…）；
是什么阻止您直接使用
列表？而且，如果您知道
T
和
V
，您可以在源文件的顶部将其别名：

using KeyValueList = System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<MyNS.MyKeyType, MyNS.MyValueType>>;

// in your code...
KeyValueList list = new KeyValueList();
list.Add(new KeyValuePair<MyKeyType, MyValueType>(..., ...));

使用KeyValueList=System.Collections.Generic.List；
//在你的代码中。。。
KeyValueList list=新的KeyValueList（）；
添加（新的KeyValuePair（…，…）；
为什么停在那里？为什么不列出三胞胎呢？还是四胞胎

事实上，这对你自己来说是非常微不足道的。编写一个从
List
派生的类，添加一个接受2个参数的
add
方法

public class KeyValueList<TKey, TValue> : List<KeyValuePair<TKey, TValue>>
{
    public void Add(TKey key, TValue value)
    {
        Add(new KeyValuePair<TKey, TValue>(key, value));
    }
}

…然后需要一个可变类型，例如：

public sealed class Pair<T1, T2>
{
    public T1 X { get; set; }
    public T2 Y { get; set; }
}

public class PairList<T1, T2> : List<Pair<T1, T2>>
{ /* ...same as KeyValueList<T1, T2>, basically... */ }

公共密封类对
{
公共T1 X{get；set；}
公共t2y{get；set；}
}
公共类成对列表：列表
{/*…与KeyValueList相同，基本上…*/}

还要注意，这将启用nice初始化语法：

var list = new PairList<int, string>
{
    { 1, "dan" },
    { 2, "serhio" }
};

var list=new PairList
{
{1，“dan”}，
{2，“serhio”}
};

但是，这里的重点是，这非常简单，因此不值得在框架中使用它自己的类型。这样看：你能说出BCL中本质上只是另一种类型但添加了一个方便方法的任何类型吗


结束语：您提出了以下问题：


既然可以使用
T[]
数组，为什么还要引入
List
类型
既然可以使用
列表
，为什么还要引入
字典
类型

老实说，这些都是奇怪的问题。既然你可以用过程代码和全局变量做任何事情，为什么还要引入OOP呢？为什么你可以在汇编程序中编写所有的高级编程语言，比如C++，C++，甚至C？
List
类提供了一个有用的封装，它包含了访问数组中的元素、维护项目数量、根据需要调整数组大小等所有功能。使用
List
和使用
T[]

字典
还封装了维护与唯一键关联的值集合的功能。它还提供了对这些键的killer O（1）查找时间。
字典
和
列表
之间存在巨大差异

列表
和您建议的
KeyValueList
（正如我上面所说）之间的差异实际上是零。几乎没有什么新东西是封装的。它只是一个
列表
。老实说，对我来说，好处不比添加一个只包装
列表的
Int32List
类型大多少

没有理由将这样的类型添加到BCL中。
为什么要到此为止？为什么不列出三胞胎呢？还是四胞胎

事实上，这对你自己来说是非常微不足道的。编写一个从
List
派生的类，添加一个接受2个参数的
add
方法

public class KeyValueList<TKey, TValue> : List<KeyValuePair<TKey, TValue>>
{
    public void Add(TKey key, TValue value)
    {
        Add(new KeyValuePair<TKey, TValue>(key, value));
    }
}

…然后需要一个可变类型，例如：

public sealed class Pair<T1, T2>
{
    public T1 X { get; set; }
    public T2 Y { get; set; }
}

public class PairList<T1, T2> : List<Pair<T1, T2>>
{ /* ...same as KeyValueList<T1, T2>, basically... */ }

公共密封类对
{
公共T1 X{get；set；}
公共t2y{get；set；}
}
公共类成对列表：列表
{/*…与KeyValueList相同，基本上…*/}

还要注意，这将启用nice初始化语法：

var list = new PairList<int, string>
{
    { 1, "dan" },
    { 2, "serhio" }
};

var list=new PairList
{
{1，“dan”}，
{2，“serhio”}
};

但是，这里的重点是，这非常简单，因此不值得在框架中使用它自己的类型。这样看：你能说出BCL中本质上只是另一种类型但添加了一个方便方法的任何类型吗


结束语：您提出了以下问题：


既然可以使用
T[]
数组，为什么还要引入
List
类型
既然可以使用
列表
，为什么还要引入
字典
类型

老实说，这些都是奇怪的问题。既然你可以用过程代码和全局变量做任何事情，为什么还要引入OOP呢？为什么你可以在汇编程序中编写所有的高级编程语言，比如C++，C++，甚至C？
List
类提供了一个有用的封装，它包含了访问数组中的元素、维护项目数量、根据需要调整数组大小等所有功能。使用
List
和仅使用
T[]
可以做的事情有很大的区别<