name - tuples c# 7




¿Una versión futura de.NET admitirá tuplas en C#? (8)

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

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


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

C # soporta tuplas simples a través de genéricos con bastante facilidad (según una respuesta anterior), y con "tipar tipeo" (una de las muchas mejoras posibles del lenguaje C #) para mejorar la inferencia de tipo podrían ser muy, muy poderosas.

Por lo que vale, F # admite tuplas de forma nativa, y después de haber jugado con él, no estoy seguro de que las tuplas (anónimas) añadan mucho ... lo que gana en brevedad se pierde muy rápidamente en la claridad del código.

Para el código dentro de un único método, hay tipos anónimos; para el código que va fuera de un método, creo que me atengo a los tipos con nombre simple. Por supuesto, si un futuro C # hace que sea más fácil hacerlos inmutables (aunque sea fácil trabajar con él), seré feliz.


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


Implementar clases Tuple o reutilizar clases F # dentro de C # es solo la mitad de la historia, estas te dan la capacidad de crear tuplas con relativa facilidad, pero no el azúcar sintáctico que las hace tan agradables de usar en lenguajes como F #.

Por ejemplo, en F # puede usar la coincidencia de patrones para extraer ambas partes de una tupla dentro de una declaración let, por ejemplo

let (a, b) = someTupleFunc

Lamentablemente, hacer lo mismo con las clases F # de C # sería mucho menos elegante:

Tuple<int,int> x = someTupleFunc();
int a = x.get_Item1();
int b = x.get_Item2();

Las tuplas representan un método poderoso para devolver múltiples valores de una llamada de función sin la necesidad de ensuciar su código con clases desechables, o recurriendo a parámetros de ref o out desagradables. Sin embargo, en mi opinión, sin azúcar sintáctico para hacer que su creación y acceso sean más elegantes, tienen un uso limitado.


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.


Para que estos sean útiles en una tabla hash o diccionario, es probable que desee proporcionar sobrecargas para GetHashCode e Igual.


Si recuerdo correctamente las clases de Informática, las tuplas son solo datos.

Si desea datos agrupados, cree clases que contengan propiedades. Si necesita algo como KeyValuePair , ahí está.







language-features