¿Qué es un análogo de C# de C++ std::pair?
¿ Qué es el análogo de C# std::pairen C++? Encontré System.Web.UI.Pairclase, pero preferiría algo basado en plantillas.
Las tuplas están disponibles desde .NET4.0 y admiten genéricos:
Tuple<string, int> t = new Tuple<string, int>("Hello", 4);
En versiones anteriores puedes usar System.Collections.Generic.KeyValuePair<K, V>o una solución como la siguiente:
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; }
};
Y úsalo así:
Pair<String, int> pair = new Pair<String, int>("test", 2);
Console.WriteLine(pair.First);
Console.WriteLine(pair.Second);
Esto produce:
test
2
O incluso estos pares encadenados:
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);
Eso produce:
test
12
true
System.Web.UIcontenía la Pairclase porque se usaba mucho en ASP.NET 1.1 como una estructura interna ViewState.
Actualización de agosto de 2017: C# 7.0/.NET Framework 4.7 proporciona una sintaxis para declarar una tupla con elementos con nombre mediante la System.ValueTupleestructura.
//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);
consulte MSDN para obtener más ejemplos de sintaxis.
Actualización de junio de 2012: Tuples ha sido parte de .NET desde la versión 4.0.
Aquí hay un artículo anterior que describe la inclusión en.NET4.0 y la compatibilidad con genéricos:
Tuple<string, int> t = new Tuple<string, int>("Hello", 4);
Desafortunadamente, no hay ninguno. Puedes utilizar el System.Collections.Generic.KeyValuePair<K, V>en muchas situaciones.
Alternativamente, puedes usar tipos anónimos para manejar tuplas, al menos localmente:
var x = new { First = "x", Second = 42 };
La última alternativa es crear una clase propia.
C# tiene tuplas a partir de la versión 4.0.
Algunas respuestas parecen simplemente incorrectas,
- No puedes usar el diccionario para almacenar los pares (a,b) y (a,c). El concepto de pares no debe confundirse con la búsqueda asociativa de claves y valores.
- Gran parte del código anterior parece sospechoso.
Aquí está mi clase de pareja.
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;
}
}
Aquí hay un código de prueba:
[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));
}
}
