web-dev-qa-db-fra.com

Tuple.Create () vs nouveau Tuple

Considérez les expressions suivantes:

new Tuple<int,int>(1,2);

Tuple.Create(1,2);

Y a-t-il une différence entre ces deux méthodes de création de Tuple? D'après ma lecture, il semble que ce soit plus un raccourci pratique que n'importe quoi comme la création d'objets en C++ (tas vs pile).

c#tuples
39
chris

Eh bien, cette question est ancienne ... mais je pense néanmoins que je peux contribuer de manière constructive. De la réponse acceptée:

Je suppose qu'un avantage est que, puisque vous n'avez pas à spécifier le type avec Tuple.Create, vous pouvez stocker des types anonymes pour lesquels vous ne seriez pas autrement en mesure de dire quel est le type

La conséquence est vraie: vous pouvez stocker des types anonymes pour lesquels ...

Mais la première partie:

puisque vous n'avez pas besoin de spécifier le type avec Tuple.Create

n'est pas toujours vrai. Considérez le scénario suivant:

interface IAnimal
{
}

class Dog : IAnimal
{
}

Les éléments suivants ne seront pas compilés:

Tuple<IAnimal> myWeirdTuple;

myWeirdTuple = Tuple.Create(new Dog());

Vous devrez spécifier le paramètre de type dans la méthode Create comme ceci:

myWeirdTuple = Tuple.Create<IAnimal>(new Dog());

qui est aussi verbeux que d'appeler new Tuple<IAnimal>(new Dog()) IMO

8
taquion

Personnellement, je trouve Tuple.Create() moins verbeux et plus facile à lire.

Il n'y a aucune différence, sous le capot. Les méthodes Tuple.Create() surchargées ne sont qu'un tas de méthodes statiques qui appellent la première version que vous avez publiée:

public static class Tuple
{
    public static Tuple<T1> Create<T1>(T1 item1) {
        return new Tuple<T1>(item1);
    }

    public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2) {
        return new Tuple<T1, T2>(item1, item2);
    }

    public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3) {
        return new Tuple<T1, T2, T3>(item1, item2, item3);
    }

    ...

Je suppose qu'un avantage est que, puisque vous n'avez pas besoin de spécifier le type avec Tuple.Create, vous pouvez stocker des types anonymes pour lesquels vous ne seriez autrement pas en mesure de dire quel est le type.

public class Person
{
    public string Name { get; set; }
    public int Height { get; set; }
    public DateTime BirthDate { get; set; }
}

var people = new List<Person>
{
    new Person { Name = "Bob", Height = 72, BirthDate = new DateTime(1984,1,1) },
    new Person { Name = "Mary", Height = 64, BirthDate = new DateTime(1980,2,2) }
};

var oneAnonList = people.Select(x => new { x.Name, x.BirthDate });
var twoAnonList = people.Select(x => new { x.Height, x.Name });

var myTuple = Tuple.Create(oneAnonList, twoAnonList);

Cela crée un tuple avec deux types anonymes, le premier est un new { string Name, DateTime BirthDate } et le second est un new { int Height, string Name }.

Vous ne pouvez toujours pas faire grand-chose avec cela, car pour le passer à une autre méthode, vous devez toujours pouvoir définir le "type" du paramètre. Donc, cela se résume vraiment à la commodité.

23
Grant

L'avantage de Tuple.Create Est que vous pouvez généralement omettre les arguments de type, par exemple. Tuple.Create(1,2) est plus bref que new Tuple<int,int>(1,2).

Si vous essayez d'omettre les arguments de type du constructeur new Tuple(1,2), vous verrez l'erreur CS0712 "Impossible de créer une instance de la classe statique 'Tuple" "

20
Jacob Lambert

Il n'y a pas de différence. Si vous jetez un œil au code source, il fait la même chose.

http://referencesource.Microsoft.com/#mscorlib/system/Tuple.cs,9124c4bea9ab0199

Par exemple:

Tuple.create(1,2);

va appeler

   public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2) {
        return new Tuple<T1, T2>(item1, item2);
    }
4
d.moncada