根据您想要实现的目标，您可能想尝试KeyValuePair。

不能更改条目的键当然可以通过简单地用KeyValuePair的一个新实例替换整个条目来纠正。

根据您想要实现的目标，您可能想尝试KeyValuePair。

不能更改条目的键当然可以通过简单地用KeyValuePair的一个新实例替换整个条目来纠正。

如果是关于字典之类的，你要找System.Collections.Generic。KeyValuePair < TKey, TValue >。

有些答案似乎是错的，

你不能使用字典来存储(a,b)和(a,c)对。对的概念不应与键和值的关联查找相混淆 上面的许多代码似乎都是可疑的

这是我的pair类

public class Pair<X, Y>
{
    private X _x;
    private Y _y;

    public Pair(X first, Y second)
    {
        _x = first;
        _y = second;
    }

    public X first { get { return _x; } }

    public Y second { get { return _y; } }

    public override bool Equals(object obj)
    {
        if (obj == null)
            return false;
        if (obj == this)
            return true;
        Pair<X, Y> other = obj as Pair<X, Y>;
        if (other == null)
            return false;

        return
            (((first == null) && (other.first == null))
                || ((first != null) && first.Equals(other.first)))
              &&
            (((second == null) && (other.second == null))
                || ((second != null) && second.Equals(other.second)));
    }

    public override int GetHashCode()
    {
        int hashcode = 0;
        if (first != null)
            hashcode += first.GetHashCode();
        if (second != null)
            hashcode += second.GetHashCode();

        return hashcode;
    }
}

下面是一些测试代码:

[TestClass]
public class PairTest
{
    [TestMethod]
    public void pairTest()
    {
        string s = "abc";
        Pair<int, string> foo = new Pair<int, string>(10, s);
        Pair<int, string> bar = new Pair<int, string>(10, s);
        Pair<int, string> qux = new Pair<int, string>(20, s);
        Pair<int, int> aaa = new Pair<int, int>(10, 20);

        Assert.IsTrue(10 == foo.first);
        Assert.AreEqual(s, foo.second);
        Assert.AreEqual(foo, bar);
        Assert.IsTrue(foo.GetHashCode() == bar.GetHashCode());
        Assert.IsFalse(foo.Equals(qux));
        Assert.IsFalse(foo.Equals(null));
        Assert.IsFalse(foo.Equals(aaa));

        Pair<string, string> s1 = new Pair<string, string>("a", "b");
        Pair<string, string> s2 = new Pair<string, string>(null, "b");
        Pair<string, string> s3 = new Pair<string, string>("a", null);
        Pair<string, string> s4 = new Pair<string, string>(null, null);
        Assert.IsFalse(s1.Equals(s2));
        Assert.IsFalse(s1.Equals(s3));
        Assert.IsFalse(s1.Equals(s4));
        Assert.IsFalse(s2.Equals(s1));
        Assert.IsFalse(s3.Equals(s1));
        Assert.IsFalse(s2.Equals(s3));
        Assert.IsFalse(s4.Equals(s1));
        Assert.IsFalse(s1.Equals(s4));
    }
}

除了自定义类或。net 4.0元组，自c# 7.0以来，有一个叫做ValueTuple的新特性，它是一个可以在这种情况下使用的结构体。而不是写:

Tuple<string, int> t = new Tuple<string, int>("Hello", 4);

并通过t.Item1和t.Item2访问值，你可以简单地这样做:

(string message, int count) = ("Hello", 4);

甚至:

(var message, var count) = ("Hello", 4);

ui包含Pair类，因为它在ASP中被大量使用。NET 1.1作为内部ViewState结构。

2017年8月更新:c# 7.0 / . net Framework 4.7提供了一种语法，可以使用System声明具有命名项的元组。ValueTuple结构。

//explicit Item typing
(string Message, int SomeNumber) t = ("Hello", 4);
//or using implicit typing 
var t = (Message:"Hello", SomeNumber:4);

Console.WriteLine("{0} {1}", t.Message, t.SomeNumber);

更多语法示例请参见MSDN。

2012年6月更新:元组从4.0版开始就成为。net的一部分。

以下是之前的一篇文章，描述了包含in.NET4.0和对泛型的支持:

Tuple<string, int> t = new Tuple<string, int>("Hello", 4);