C# génériques génériques (une question sérieuse)

Question

En C# J'essaie d'écrire du code où je créerais un délégué Func qui est en soi générique. Par exemple, le suivant délégué (non générique) retourne une chaîne arbitraire:

Func<string> getString =() => "Hello!"; 

I d'autre part vouloir créer un générique qui agit de manière similaire aux méthodes génériques. Par exemple, si je veux un Func générique pour revenir par défaut (T) pour un T. type I imagine que j'écrire du code comme suit:

Func<T><T> getDefaultObject = <T>() => default(T); 

alors je l'utiliser comme

getDefaultObject<string>() qui renverrait null et si je devais écrire getDefaultObject<int>() retournerait 0.

Cette question est non seulement un excercise académique. J'ai trouvé de nombreux endroits où j'aurais pu utiliser ceci mais je ne peux pas obtenir la syntaxe correcte. Est-ce possible? Y a-t-il des bibliothèques qui fournissent ce genre de fonctionnalité?

Answer 1

Bien qu'on puisse trouver pratique solutions de contournement comme Stephen Cleary de

Func<T> CreateGetDefaultObject<T>() { return() => default(T); } 

où vous pouvez spécifier les génériques directement, c'est un problème très intéressant d'un point théorique qui ne peut être résolu par type actuel de C# système.

---

Un type qui, comme vous l'appelez, est en soi générique, est appelé un type de rang supérieur.

Prenons l'exemple suivant (pseudo-C#):

Tuple<int[], string[]> Test(Func<?> f) { 
    return (f(1), f("Hello")); 
} 

Dans votre système proposé, un appel pourrait ressembler à ça:

Test(x => new[] { x }); // Returns ({ 1 }, { "Hello" }) 

Mais la question est la suivante: Comment pouvons-nous tapons fonction Test et son argument f? Apparemment, f mappe tous les types T à un tableau T[] de ce type. Alors peut-être?

Tuple<int[], string[]> Test<T>(Func<T, T[]> f) { 
    return (f(1), f("Hello")); 
} 

Mais cela ne fonctionne pas. Nous ne pouvons pas paramétrer Test avec un particulierT, puisque f devrait être appliqué à tous types T. À ce stade, le système de type C# ne peut pas aller plus loin.

Ce que nous avions besoin d'une notation comme

Tuple<int[], string[]> Test(forall T : Func<T, T[]> f) { 
    return (f(1), f("Hello")); 
} 

Dans votre cas, vous pouvez taper

forall T : Func<T> getDefaultValue = ... 

La seule langue que je sais qui prend en charge ce genre de médicaments génériques est Haskell:

test :: (forall t . t -> [t]) -> ([Int], [String]) 
test f = (f 1, f "hello") 

Voir cette entrée Haskellwiki sur polymorphism à propos de cette notation forall.

Answer 2

Vous ne pouvez pas faire cela, car les paramètres de type générique doivent être connus lors de l'exécution. Vous devez utiliser la classe activateur:

Object o = Activator.CreateInstance(typeof(StringBuilder));

qui fera exactement ce que vous voulez. Vous pouvez l'écrire comme suit:

public T Default<T>() 
{ 
    return (T)Activator.CreateInstance(typeof(T)); 
} 

Modifier

solution de Blindy est mieux.

Answer 3

Eh bien, vous ne pouvez pas surcharger quoi que ce soit basée uniquement sur la valeur de retour, donc cela inclut des variables.

Vous pouvez cependant vous débarrasser de cette expression lambda et écrire une fonction réelle:

T getDefaultObject<T>() { return default(T); } 

puis vous l'appeler exactement comme vous voulez:

int i=getDefaultObject<int>();  // i=0 
string s=getDefaultObject<string>(); // s=null 

Answer 4

Ce n'est pas possible, puisque un délégué instance en C# ne peut pas avoir de paramètres génériques. Le plus proche que vous pouvez obtenir est de passer l'objet type comme un paramètre normal et d'utiliser la réflexion. :(

Dans de nombreux cas, l'association à dynamique aide à supprimer la douleur de la réflexion, mais dynamique ne vous aide pas lors de la création de nouvelles instances, comme votre exemple.