c# tuple ejemplo - ¿Una versión futura de .NET admitirá tuplas en C #?




6 Answers

Acabo de leer este artículo de MSDN Magazine: Building Tuple

Aquí hay extractos:

La próxima versión 4.0 de Microsoft .NET Framework presenta un nuevo tipo llamado System.Tuple. System.Tuple es una colección de tamaño fijo de datos de tipo heterogéneo.

Como una matriz, una tupla tiene un tamaño fijo que no se puede cambiar una vez que se ha creado. A diferencia de una matriz, cada elemento en una tupla puede ser de un tipo diferente, y una tupla puede garantizar un tipado fuerte para cada elemento.

Ya hay un ejemplo de una tupla flotando alrededor de Microsoft .NET Framework, en el espacio de nombres System.Collections.Generic: KeyValuePair. Aunque se puede pensar que KeyValuePair es lo mismo que Tuple, ya que ambos tipos tienen dos cosas, KeyValuePair se siente diferente de Tuple porque evoca una relación entre los dos valores que almacena (y con buena razón, ya que admite la clase Dictionary )

Además, las tuplas pueden ser arbitrariamente dimensionadas, mientras que KeyValuePair contiene solo dos cosas: una clave y un valor.

Mientras que algunos lenguajes como F # tienen una sintaxis especial para tuplas, puede usar el nuevo tipo de tupla común desde cualquier idioma. Revisando el primer ejemplo, podemos ver que aunque es útil, las tuplas pueden ser demasiado detalladas en los lenguajes sin sintaxis para una tupla:

class Program {
    static void Main(string[] args) {
        Tuple<string, int> t = new Tuple<string, int>("Hello", 4);
        PrintStringAndInt(t.Item1, t.Item2);
    }
    static void PrintStringAndInt(string s, int i) {
        Console.WriteLine("{0} {1}", s, i);
    }
}

Usando la palabra clave var de C # 3.0, podemos eliminar la firma de tipo en la variable tupla, lo que permite un código algo más legible.

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

También hemos agregado algunos métodos de fábrica a una clase Tuple estática que facilita la creación de tuplas en un lenguaje que admite la inferencia de tipos, como C #.

var t = Tuple.Create("Hello", 4);
list tuples

.Net 3.5 no admite tuplas. Lástima, ¿pero no estoy seguro si la versión futura de .net soportará tuplas o no?




Existe una implementación adecuada (no rápida) de C # Tuple en bibliotecas compartidas Lokad (de código abierto, por supuesto) que incluye las siguientes características requeridas:

  • 2-5 implementaciones de tuplas inmutables
  • DebuggerProDisplayAttribute
  • Comprobaciones de hash e igualdad correctas
  • Ayudantes para generar tuplas a partir de los parámetros proporcionados (los genéricos se deducen por compilador) y extensiones para operaciones basadas en recopilación.
  • probado en producción.



En mi opinión, la característica de tipos anónimos no es una tupla, sino una construcción muy similar. El resultado de algunas consultas LINQ son colecciones de tipos anónimos, que se comportan como tuplas.

Aquí hay una declaración, que crea una tupla tipeada :-) sobre la marcha:

var p1 = new {a = "A", b = 3};

ver: http://www.developer.com/net/csharp/article.php/3589916




Mi biblioteca de fuente abierta .NET Sasa ha tenido tuplas durante años (junto con muchas otras funcionalidades, como el análisis MIME completo). Lo he estado utilizando en el código de producción durante unos años.




Aquí está mi conjunto de tuplas, están autogeneradas por una secuencia de comandos de Python, por lo que tal vez haya ido un poco por la borda:

Enlace al repositorio de Subversion

Necesitarás un nombre de usuario / contraseña, ambos son invitados

Se basan en la herencia, pero Tuple<Int32,String> no se comparará con Tuple<Int32,String,Boolean> incluso si tienen los mismos valores para los dos primeros miembros.

También implementan GetHashCode y ToString, entre otros, y muchos métodos pequeños de ayuda.

Ejemplo de uso:

Tuple<Int32, String> t1 = new Tuple<Int32, String>(10, "a");
Tuple<Int32, String, Boolean> t2 = new Tuple<Int32, String, Boolean>(10, "a", true);
if (t1.Equals(t2))
    Console.Out.WriteLine(t1 + " == " + t2);
else
    Console.Out.WriteLine(t1 + " != " + t2);

Se producirá:

10, a != 10, a, True



Me sorprendería que C # sea un lenguaje fuertemente tipado, mientras que las tuplas son adecuadas para lenguajes con más tipos dinámicos. C # ha ido a la deriva más dinámico a medida que pasa el tiempo, pero eso es azúcar sintáctica, no un cambio real en los tipos de datos subyacentes.

Si quiere dos valores en una instancia, un KeyValuePair <> es un sustituto decente, aunque torpe. También puede crear una estructura o una clase que haga lo mismo y que sea ampliable.




Related