Une future version de .NET prendra-t-elle en charge les n-uplets en C #?

Question

Net 3.5 ne supporte pas les n-uplets. Dommage, mais je ne sais pas si la future version de .net supportera les n-uplets ou non?

Answer 1

Je viens de lire cet article de MSDN Magazine: la Construction d'un Tuple

Voici des extraits:

La prochaine version 4.0 de Microsoft .NET Framework introduit un nouveau type appelé Système.N-uplet. Système.Un Tuple est une fixe la taille de la collection de hétérogène des données typées.

 

Comme un tableau, un n-uplet a un fixe taille qui ne peut pas être changé une fois qu'il a été créé. Contrairement à un tableau, chaque élément d'un tuple peut être un autre type, et un n-uplet est en mesure de garantir typage fort pour chaque élément.

 

Il y a déjà un exemple d'un tuple flottant autour de Microsoft .NET Framework, dans le Système.Les Collections.Générique de l'espace de noms: KeyValuePair. Alors que KeyValuePair peut être considéré comme le même comme Tuple, car ils sont les deux types de tenir deux choses, KeyValuePair se sent différent de Tuple parce qu'elle évoque une relation entre les deux valeurs qu'il stocke (et avec de bonnes raisons, comme il prend en charge la Dictionnaire de la classe).

En outre, les tuples peuvent être arbitrairement de taille moyenne, tandis que KeyValuePair ne détient que deux choses: une clé et une valeur.

---

Alors que certaines langues, comme le F# ont une syntaxe spéciale pour les n-uplets, vous pouvez utiliser la nouvelle commune tuple de type à partir de n'importe quelle langue. Revoir le premier exemple, nous pouvons voir que, bien qu'utiles, les tuples peuvent être trop bavard dans les langues sans syntaxe pour un n-uplet:

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

En utilisant le mot-clé var à partir de C# 3.0, on peut retirer le type de signature sur le n-uplet de variables, ce qui permet un peu plus lisible le code.

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

Nous avons également ajouté une usine méthodes statiques Tuple de la classe qui le rend plus facile de construire des tuples dans une langue qui prend en charge l'inférence de type, comme le C#.

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

Answer 2

 #region tuples

    public class Tuple<T>
    {
        public Tuple(T first)
        {
            First = first;
        }

        public T First { get; set; }
    }

    public class Tuple<T, T2> : Tuple<T>
    {
        public Tuple(T first, T2 second)
            : base(first)
        {
            Second = second;
        }

        public T2 Second { get; set; }
    }

    public class Tuple<T, T2, T3> : Tuple<T, T2>
    {
        public Tuple(T first, T2 second, T3 third)
            : base(first, second)
        {
            Third = third;
        }

        public T3 Third { get; set; }
    }

    public class Tuple<T, T2, T3, T4> : Tuple<T, T2, T3>
    {
        public Tuple(T first, T2 second, T3 third, T4 fourth)
            : base(first, second, third)
        {
            Fourth = fourth;
        }

        public T4 Fourth { get; set; }
    }

    #endregion
 

Et pour faire des déclarations plus jolies:

 public static class Tuple
{
    //Allows Tuple.New(1, "2") instead of new Tuple<int, string>(1, "2")
    public static Tuple<T1, T2> New<T1, T2>(T1 t1, T2 t2)
    {
        return new Tuple<T1, T2>(t1, t2);
    }
    //etc...
}
 

Answer 3

Il y a un bon (pas rapide) C# Tuple de la mise en œuvre de Lokad Bibliothèques Partagées (Open-source, bien sûr) qui comprend suivant les fonctionnalités requises:

• 2-5 immuable tuple implémentations
• Bon DebuggerDisplayAttribute
• Bon malaxage et de l'égalité des contrôles
• Les aides pour générer des tuples à partir de la condition des paramètres (les génériques sont inférées par le compilateur) et les extensions de la collection.
• testées en production.

Answer 4

La mise en œuvre de Tuple classes ou la réutilisation F nombre de classes au sein de la C# est seulement la moitié de l'histoire - ces vous donner la possibilité de créer des tuples avec une relative facilité, mais pas vraiment du sucre syntaxique qui les rend si agréable à utiliser dans les langues, comme F#.

Par exemple en F#, vous pouvez utiliser le pattern matching pour en extraire des parties d'un tuple dans une déclaration, par exemple

let (a, b) = someTupleFunc

Malheureusement, à en faire de même à l'aide de la F nombre de classes à partir de C# serait beaucoup moins élégant:

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

Les Tuples représentent une méthode puissante pour retourner plusieurs valeurs à partir d'un appel de fonction sans avoir besoin de la litière de votre code avec jetable classes, ou de recourir à de laide ref ou des paramètres de sortie. Cependant, à mon avis, sans un peu de sucre syntaxique pour leur rendre la création et l'accès de plus élégant, ils sont d'une utilité limitée.

Answer 5

À mon avis, la fonctionnalité de types anonymes n’est pas un tuple, mais une construction très similaire. La sortie de certaines requêtes LINQ est une collection de types anonymes, qui se comportent comme des n-uplets.

Voici une déclaration qui crée un tuple dactylographié :-) à la volée:

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

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