web-dev-qa-db-fra.com

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

Je suis intéressé: Quel est l'analogue de C # de std::pair en C++? J'ai trouvé la classe System.Web.UI.Pair, mais je préférerais quelque chose basé sur un modèle.

Je vous remercie!

c#.netdata-structuresstd-pairbase-class-library
269
Alexander Prokofyev

Tuples sont disponibles depuis .NET4. et supporte les génériques:

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

Dans les versions précédentes, vous pouvez utiliser System.Collections.Generic.KeyValuePair<K, V> ou une solution semblable à celle-ci:

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 utilisez-le comme ceci:

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

Cela génère:

test
2

Ou même ces paires chaînées:

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

Cela produit:

test
12
true
305
Jorge Ferreira

_System.Web.UI_ contenait la classe Pair car elle était fortement utilisée dans ASP.NET 1.1 en tant que structure ViewState interne.

Mise à jour août 2017: C # 7.0/.NET Framework 4.7 fournit une syntaxe permettant de déclarer un tuple avec des éléments nommés à l'aide de System.ValueTuple struct.

_//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);
_

voir MSDN pour plus d'exemples de syntaxe.

Mise à jour juin 2012: Tuples fait partie de .NET depuis la version 4.0.

Voici n article précédent décrivant l'inclusion dans .NET4. et le support des génériques:

_Tuple<string, int> t = new Tuple<string, int>("Hello", 4);
_
87
Jay Walker

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

Vous pouvez également utiliser des types anonymes pour gérer les nuplets, au moins localement:

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

La dernière alternative consiste à créer une propre classe.

38
Konrad Rudolph

C # a tuples à partir de la version 4.0.

20
Kenan E. K.

Certaines réponses semblent tout simplement fausses,

  1. vous ne pouvez pas utiliser de dictionnaire pour stocker les paires (a, b) et (a, c). Le concept des paires ne doit pas être confondu avec la recherche associative de la clé et des valeurs
  2. beaucoup de ce code semble suspect

Voici mon cours de couple

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));
    }
}
11
Antony

S'il s'agit de dictionnaires, etc., vous recherchez System.Collections.Generic.KeyValuePair <TKey, TValue>.

7
OregonGhost

J'ai créé une implémentation en C # de Tuples, qui résout le problème génériquement entre deux et cinq valeurs - voici l'article du blog , qui contient un lien vers la source.

3
Erik Forbes

Selon ce que vous voulez accomplir, vous pouvez essayer KeyValuePair .

Le fait que vous ne pouvez pas modifier la clé d'une entrée peut bien sûr être corrigé en remplaçant simplement l'entrée entière par une nouvelle instance de KeyValuePair.

3
Grimtron

Je posais la même question tout à l’heure, après un rapide Google, j’ai trouvé qu’il existe une classe de paires dans .NET, à l’exception de la classe System.Web.UI ^ ~ ^ ( http://msdn.Microsoft.com/en-us/library/system.web.ui.pair.aspx ) Dieu sait pourquoi ils l'ont mis là au lieu du cadre des collections

2
Lyra

J'étends généralement la classe Tuple dans mon propre wrapper générique comme suit:

public class Statistic<T> : Tuple<string, T>
{
    public Statistic(string name, T value) : base(name, value) { }
    public string Name { get { return this.Item1; } }
    public T Value { get { return this.Item2; } }
}

et l'utiliser comme ça:

public class StatSummary{
      public Statistic<double> NetProfit { get; set; }
      public Statistic<int> NumberOfTrades { get; set; }

      public StatSummary(double totalNetProfit, int numberOfTrades)
      {
          this.TotalNetProfit = new Statistic<double>("Total Net Profit", totalNetProfit);
          this.NumberOfTrades = new Statistic<int>("Number of Trades", numberOfTrades);
      }
}

StatSummary summary = new StatSummary(750.50, 30);
Console.WriteLine("Name: " + summary.NetProfit.Name + "    Value: " + summary.NetProfit.Value);
Console.WriteLine("Name: " + summary.NumberOfTrades.Value + "    Value: " + summary.NumberOfTrades.Value);
2
parliament

Depuis .NET 4.0, vous avez la classe System.Tuple<T1, T2>:

// pair is implicitly typed local variable (method scope)
var pair = System.Tuple.Create("Current century", 21);
2
Serge Mikhailov

La bibliothèque PowerCollections (auparavant disponible auprès de Wintellect mais désormais hébergée sur Codeplex @ http://powercollections.codeplex.com ) a une structure Pair générique.

1
James Webster

Outre la classe personnalisée ou .Net 4.0 Tuples, depuis C # 7.0, il existe une nouvelle fonctionnalité appelée ValueTuple, qui est une structure utilisable dans ce cas. Au lieu d'écrire:

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

et accéder aux valeurs via t.Item1 et t.Item2, vous pouvez simplement le faire comme ça:

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

ou même:

(var message, var count) = ("Hello", 4);
1
Pawel Gradecki

Afin de faire fonctionner ce qui précède (j'avais besoin d'une paire comme clé d'un dictionnaire). Je devais ajouter:

    public override Boolean Equals(Object o)
    {
        Pair<T, U> that = o as Pair<T, U>;
        if (that == null)
            return false;
        else
            return this.First.Equals(that.First) && this.Second.Equals(that.Second);
    }

et une fois que j'ai fait cela, j'ai aussi ajouté

    public override Int32 GetHashCode()
    {
        return First.GetHashCode() ^ Second.GetHashCode();
    }

pour supprimer un avertissement du compilateur.

1
Andrew Stein