C# Dérivation Méthodes génériques

Question

Quand je dois passer un type générique je peux utiliser la syntaxe

(Exemple: Ofcourse il n'est pas une méthode générique)

public void Sample(T someValue) 
{ 
    ...... 
} 

Quel est l'avantage de déclarer Sample<T>?

Je veux dire

public void Sample<T> (T someValue) 
{ 
    ...... 
} 

Answer 1

Pour que cela fonctionne:

public void Sample(T someValue) 
{ 
    ...... 
} 

Le type T doit être déclaré dans le système déjà. Et la méthode n'acceptera que le type T ou ses dérivés.

En déclarant ceci:

public void Sample<T> (T someValue) 
{ 
    ...... 
} 

vous dire la méthode acceptera tout type qui vient.

Answer 2

Vous pouvez utiliser le 2ème exemple si votre classe n'est pas générique. Cela signifie que vous pouvez rendre cette méthode générique. Si votre classe est générique, vous devez utiliser votre premier exemple.

Answer 3

Les génériques types et génériques méthodes sont des choses très différentes. Il semble que vous avez un type générique:

class SomeType<T> { 
    public void Sample(T someValue) {...} 
} 

et discutez avec une méthode générique à l'intérieur:

class SomeType<T> { 
    public void Sample<T>(T someValue) {...} 
} 

Ce sont très différents. Dans le premier, à l'intérieur Sample, puis T signifie "le T qui s'est passé à SomeType<T>". Dans la seconde, à l'intérieur Sample, il s'agit d'un séparé et indépendantT - "le T qui a été passé à Sample<T>". En fait, l'appeler T (dans ce cas) est une erreur. Vous pourriez avoir, par exemple:

var obj = new SomeType<int>(); // here T for SomeType<T> is int 
obj.Sample<decimal>(123.45M); // here T for Sample<T> is decimal 

Notez qu'il n'y a aucun moyen facile (au sein Sample<T>) de dire « T dans SomeType<T> » - donc pourquoi vous devez renommer le paramètre de type générique de la méthode.

Il existe des scénarios valides pour ce type de scénario (méthodes génériques sur les types génériques), par exemple (et notez le nouveau nom):

class SomeType<T> { 
    public void Sample<TActual>(TActual someValue) where TActual : T, new() {...} 
} 

Cela nous permet de faire des choses très intéressantes en termes de héritage, etc - ou vous pouvez vouloir une méthode générique qui a peu ou pas par rapport à T. C'est bien aussi.

Answer 4

Considérez ce qui suit:

class SomeClass<T> 
{ 
    public void Sample(T value) 
    { 
     // code goes here 
    } 
} 

ou ceci:

class SomeClass 
{ 
    public void Sample<T>(T value) 
    { 
     // code goes here 
    } 
} 

Dans le premier cas, pour tous les appels à Sample dans une instance spécifique T sera le même type. Dans le second cas, chaque appel dans une instance spécifique peut avoir son propre type de T, puisque l'argument de type générique est fourni avec l'appel de la méthode.

La seconde approche peut avoir de nombreuses utilisations, mais que je l'ai utilisé moi-même est parfois dans les méthodes d'usine:

public static class SomeFactory 
{ 
    public static T CreateSomeObject<T>() 
    { 
     T result = Activator.CreateInstance<T>(); 
     // perform any extra initialization 
     return result; 
    } 
}