Quel est l’analogue C # de C ++ std :: pair?

Les tuples sont disponibles depuis .NET4.0 et supportent les génériques:

Tuple t = new Tuple("Hello", 4); 

Dans les versions précédentes, vous pouvez utiliser System.Collections.Generic.KeyValuePair ou une solution comme celle-ci:

 public class Pair { 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 l’utiliser comme ça:

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

Cela produit:

 test 2 

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

 Pair, bool> pair = new Pair, bool>(); pair.First = new Pair(); 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 

System.Web.UI contenait la classe Pair car elle était largement utilisée dans ASP.NET 1.1 en tant que structure interne ViewState.

Mise à jour Août 2017: C # 7.0 / .NET Framework 4.7 fournit une syntaxe pour déclarer un Tuple avec des éléments nommés à l’aide de la structure System.ValueTuple .

 //explicit Item typing (ssortingng 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: Les Tuples font partie de .NET depuis la version 4.0.

Voici un article précédent décrivant l’inclusion dans .NET4.0 et le support pour les génériques:

 Tuple t = new Tuple("Hello", 4); 

Malheureusement, il n’y en a pas. Vous pouvez utiliser System.Collections.Generic.KeyValuePair dans de nombreuses situations.

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

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

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

C # a des tuples à partir de la version 4.0.

Certaines réponses semblent fausses,

1. vous ne pouvez pas utiliser dictionnaire comment stocker les paires (a, b) et (a, c). Le concept de paires ne doit pas être confondu avec la recherche associative de clés et de valeurs
2. lot du code ci-dessus semble suspect

Voici ma classe de paire

 public class Pair { 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 other = obj as Pair; 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() { ssortingng s = "abc"; Pair foo = new Pair(10, s); Pair bar = new Pair(10, s); Pair qux = new Pair(20, s); Pair aaa = new Pair(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 s1 = new Pair("a", "b"); Pair s2 = new Pair(null, "b"); Pair s3 = new Pair("a", null); Pair s4 = new Pair(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)); } } 

S’il s’agit de dictionnaires et autres, vous recherchez System.Collections.Generic.KeyValuePair .

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

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

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

Je posais la même question tout à l’heure après un rapide google, j’ai constaté qu’il y avait une classe de paires dans .NET, sauf dans la classe System.Web.UI ^ ~ ^ ( http://msdn.microsoft.com/en-us/ bibliothèque / system.web.ui.pair.aspx ) bonté sait pourquoi ils l’ont mis là au lieu du cadre des collections

Depuis .NET 4.0, vous avez la classe System.Tuple :

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

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

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

et l’utiliser comme ça:

 public class StatSummary{ public Statistic NetProfit { get; set; } public Statistic NumberOfTrades { get; set; } public StatSummary(double totalNetProfit, int numberOfTrades) { this.TotalNetProfit = new Statistic("Total Net Profit", totalNetProfit); this.NumberOfTrades = new Statistic("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); 

Afin de faire fonctionner ce qui précède (j’avais besoin d’une paire comme clé d’un dictionnaire). J’ai dû append:

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

et une fois que je l’ai fait, j’ai également ajouté

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

pour supprimer un avertissement du compilateur.

La bibliothèque PowerCollections (anciennement disponible sur Wintellect mais maintenant hébergée sur Codeplex @ http://powercollections.codeplex.com ) a une structure de paire générique.

Outre la classe personnalisée ou les tuples .Net 4.0, depuis C # 7.0, il existe une nouvelle fonctionnalité appelée ValueTuple, qui peut être utilisée dans ce cas. Au lieu d’écrire:

 Tuple t = new Tuple("Hello", 4); 

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

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

ou même:

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