Qu'est-ce que C# analogique de C++ std::pair?

Question

Je suis intéressé (e) qu'est-ce que C# analogique de C++ std::pair? J'ai trouvé le Système.Web.L'INTERFACE utilisateur.Paire de classe, mais je voulais quelque chose à base de modèles.

Merci!!!!

Answer 1

Les Tuples va être une partie de .NET4.0 et le soutien des génériques:

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

---

Vous pouvez utiliser System.Collections.Generic.KeyValuePair<K, V> ou une solution comme suit:

public class Pair<T, U> {
    public Pair() {
    }

    public Pair(T first, U second) {
        this.First = first;
        this.Second = second;
    }

    public T First { get; set; }
    public U Second { get; set; }
};

Et de l'utiliser comme ceci:

Pair<String, int> pair = new Pair<String, int>("test", 2);
Console.WriteLine(pair.First);
Console.WriteLine(pair.Second);

Ce sorties:

test
2

Ou encore cette enchaînés deux à deux:

Pair<Pair<String, int>, bool> pair = new Pair<Pair<String, int>, bool>();
pair.First = new Pair<String, int>();
pair.First.First = "test";
pair.First.Second = 12;
pair.Second = true;

Console.WriteLine(pair.First.First);
Console.WriteLine(pair.First.Second);
Console.WriteLine(pair.Second);

Des sorties:

test
12
true

Answer 2

System.Web.UI contenaient l' Pair de la classe parce qu'il a été largement utilisé dans ASP.NET 1.1 en tant que interne de l'état d'affichage de la structure.

Mise à jour: n-Uplets ont été une partie de .NET depuis la version 4.0.

Voici un article décrivant l'inclusion dans.NET4.0 et de soutien pour les génériques:

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

Answer 3

Malheureusement, il n'y a aucun. Vous pouvez utiliser l' System.Collections.Generic.KeyValuePair<K, V> dans de nombreuses situations.

Alternativement, vous pouvez utiliser les types anonymes pour gérer les tuples, au moins localement:

var x = new { First = "x", Second = 42 };

La dernière alternative est de créer une catégorie à part.

Answer 4

C# a n-uplets de la version 4.0.

Answer 5

Certaines réponses semblent tout simplement faux,

1. vous ne pouvez pas utiliser le dictionnaire comment stocker les paires (a,b) et (a,c). Paires concept ne doit pas être confondue avec l'associatif rechercher des clés et des valeurs
2. beaucoup de code ci-dessus semble suspect

Voici ma paire de classe

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;
    }
}

Voici un code de test:

[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));
    }
}