Passer une fonction générique comme paramètre

Question

Je sais que ce que je fais peut être fait d'une manière différente, mais je suis curieux de savoir comment les choses fonctionnent. Ce qui suit est un code simplifié qui ne compile pas, mais il est censé montrer mon objectif.

private void Execute() 
{ 
    GeneralizedFunction("1", "2", i => Transform(i)); 
} 

void GeneralizedFunction(string aStringA, string aStringB, Func<string, T> aAction) 
{ 
    A result1 = aAction(aStringA); 
    B result2 = aAction(aStringB); 
    // Do something with A and B here 
} 

T Transform<T>(string aString) 
{ 
    return default(T); 
} 

Transform est un générique de convertion chaîne à un objet (pensez désérialisation). GeneralizedFunction utilise deux spécialisations de transformation: une pour le type A et une pour le type B. Je sais que je peux le faire de plusieurs autres manières (disons en introduisant un paramètre pour le type de l'objet), mais je cherche des explications sur la possibilité ou l'impossibilité de le faire avec des génériques/lambdas. Si Transform est spécialisé avant de passer en paramètre à GeneralizedFunction, alors c'est impossible. Alors la question est pourquoi cette possibilité est limitée.

Answer 1

Essayez la signature suivante:

void GeneralizedFunction<T>(string aStringA, string aStringB, Func<string, T> aAction) 

(Notez que GeneralizedFunction doit être générique, le compilateur suppose automatiquement le paramètre de type lors de l'appel de la méthode).

Answer 2

void GeneralizedFunction<T>(string aStringA, string aStringB, Func<string, T> aAction) 
{ 
    A result1 = aAction(aStringA); 
    B result2 = aAction(aStringB); 
} 

T Transform<T>(string aString) 
{ 
    return default(T); 
} 

Answer 3

Ce que vous demandez de faire n'est pas possible en utilisant uniquement les génériques. Le compilateur doit générer deux versions typées de votre fonction Transform: une pour renvoyer le type A et une pour le type B. Le compilateur n'a aucun moyen de savoir générer ceci au moment de la compilation; C'est seulement en exécutant le code que l'on sait que A et B sont requis.

Une façon de le résoudre serait de passer dans les deux versions:

private void Execute() 
{ 
    GeneralizedFunction("1", "2", i => Transform<A>(i), i => Transform<B>(i)); 
} 

void GeneralizedFunction(string aStringA, string aStringB, Func<string, A> aAction, Func<string, B> bAction) 
{ 
    A result1 = aAction(aStringA); 
    B result2 = bAction(aStringB); 
} 

Le compilateur sait exactement ce dont il a besoin pour générer dans ce cas.

Answer 4

Il semble que la réponse soit "non".

Lorsque vous appelez Transform directement, vous devez spécifier un paramètre de type:

int i = Transform<int>(""); 

donc hypothétiquement, si vous pouviez passer une incomplètement construit fonction générique comme vous voulez, vous aurez besoin de préciser la paramètres de type ainsi:

void GeneralizedFunction(string aStringA, string aStringB, Func<string, T> aAction) 
{ 
    A result1 = aAction<A>(aStringA); 
    B result2 = aAction<B>(aStringB); 
    // Do something with A and B here 
} 

il me semble que vous pourriez hypothétiquement faire, si C# a une syntaxe comme ça.

Mais quel est le cas d'utilisation? Mis à part transformer les chaînes à la valeur par défaut d'un type arbitraire, je ne vois pas beaucoup d'utilité pour cela. Comment pourriez-vous définir une fonction qui fournirait un résultat significatif dans l'un ou l'autre de deux types différents en utilisant la même série d'instructions?

EDIT

Une analyse des raisons pour lesquelles il est impossible:

Lorsque vous utilisez une expression lambda dans votre code, il est compilé dans soit un délégué ou un arbre d'expression; dans ce cas, c'est un délégué. Vous ne pouvez pas avoir une instance d'un type générique "ouvert"; en d'autres termes, pour créer un objet à partir d'un type générique, tous les paramètres de type doivent être spécifiés.En d'autres termes, il n'y a aucun moyen d'avoir une instance d'un délégué sans fournir d'arguments pour tous ses paramètres de type. L'une des fonctionnalités utiles du compilateur C# est la conversion implicite de groupes de méthodes, où le nom d'une méthode (un "groupe de méthodes") peut être implicitement converti en un type délégué représentant l'une des surcharges de cette méthode. De même, le compilateur convertit implicitement une expression lambda en un type délégué. Dans les deux cas, le compilateur émet du code pour créer une instance du type délégué (dans ce cas, pour le passer à la fonction). Mais l'instance de ce type de délégué doit toujours avoir un argument type pour chacun de ses paramètres de type.

Pour passer la fonction générique en fonction générique, il semble, le compilateur devrait être en mesure de passer le groupe de méthode ou l'expression lambda la méthode sans conversion, de sorte que le aAction paramètre aurait en quelque sorte un type de "groupe de méthodes" ou "expression lambda". Ensuite, la conversion implicite en un type délégué peut se produire sur les sites d'appel A result1 = aAction<A>(aStringA); et B result2 = aAction<B>(aStringB);. Bien sûr, à ce stade, nous sommes bien dans l'univers des contrefactuels et des hypothétiques.

La solution que je suis venu avec au cours du déjeuner était ce, en supposant une fonction Deserialize<T> qui prend une chaîne contenant des données sérialisés et retourne un objet de type T:

void GeneralizedFunction<T>(string aStringA, string aStringB, Func<T, string> stringGetter) 
{ 
    A result1 = Deserialize<A>(stringGetter(aStringA)); 
    B result2 = Deserialize<B>(stringGetter(aStringB)); 
} 

void Example(string serializedA, string serializedB, string pathToA, string pathToB, FileInfo a, FileInfo b) 
{ 
    GeneralizedFunction(serializedA, serializedB, s => s); 
    GeneralizedFunction(pathToA, pathToB, File.ReadAllText); 
    GeneralizedFunction(a, b, fi => File.ReadAllText(fi.FullName)); 
} 

Answer 5

Cette réponse n'explique pas la raison pourquoi, juste comment pour contourner la limitation.

Au lieu de passer une fonction réelle, vous pouvez passer un objet qui a une telle fonction:

interface IGenericFunc 
{ 
    TResult Call<TArg,TResult>(TArg arg); 
} 

// ... in some class: 

void Test(IGenericFunc genericFunc) 
{ 
    // for example's sake only: 
    int x = genericFunc.Call<String, int>("string"); 
    object y = genericFunc.Call<double, object>(2.3); 
} 

Pour votre cas d'utilisation spécifique, il peut être simplifié à:

interface IDeserializerFunc 
{ 
    T Call<T>(string arg); 
} 

// ... in some class: 
void Test(IDeserializerFunc deserializer) 
{ 
    int x = deserializer.Call<int>("3"); 
    double y = deserializer.Call<double>("3.2"); 
}