Passare una funzione generica come parametro

Question

So che quello che sto facendo può essere fatto in un modo diverso, ma sono curioso di sapere come funzionano le cose. Quello che segue è un codice semplificato che non viene compilato, ma che dovrebbe mostrare il mio obiettivo.

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 è una conversione generico da stringa ad un oggetto (si pensi deserializzazione). GeneralizedFunction utilizza due specializzazioni di trasformazione: una per il tipo A e una per il tipo B. So che posso farlo in molti altri modi (ad esempio introducendo un parametro per il tipo di oggetto), ma sto cercando spiegazioni se è possibile o impossibile farlo con generici/lambda. Se Transform è specializzato prima di essere passato come parametro a GeneralizedFunction, allora è impossibile. Quindi la domanda è perché questa possibilità è limitata.

Answer 1

provare la seguente firma:

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

(Si noti che GeneralizedFunction deve essere generico, il compilatore indovinare automaticamente il parametro type quando si chiama il metodo).

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

Quello che stai chiedendo di fare non è possibile usando i generici da solo. Il compilatore deve generare due versioni digitate della tua funzione Transform: una per restituire il tipo A e una per il tipo B. Il compilatore non ha modo di saperlo generare in fase di compilazione; solo eseguendo il codice saprebbe che A e B sono obbligatori.

Un modo per risolverlo sarebbe quello di passare nelle due versioni:

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

il compilatore sa esattamente quello di cui ha bisogno per generare in questo caso.

Answer 4

Sembra che la risposta sia "no".

Quando si chiama Transform direttamente, è necessario specificare un parametro di tipo:

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

Quindi ipoteticamente, se si poteva passare una funzione generica incompleto-costruito come si vuole, avresti bisogno di specificare il parametri di tipo così:

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 
} 

Quindi mi sembra che si potrebbe ipoteticamente fare questo, se C# ha avuto una sintassi del genere.

Ma qual è il caso d'uso? A parte trasformare le stringhe al valore predefinito di un tipo arbitrario, non vedo molto l'uso per questo. Come potresti definire una funzione che fornisca un risultato significativo in uno dei due diversi tipi utilizzando la stessa serie di affermazioni?

EDIT

L'analisi del motivo per cui non è possibile:

Quando si utilizza un'espressione lambda nel codice, viene compilato in sia un delegato o di un albero di espressione; in questo caso, è un delegato. Non puoi avere un'istanza di tipo generico "aperto"; in altre parole, per creare un oggetto da un tipo generico, è necessario specificare tutti i parametri del tipo.In altre parole, non c'è modo di avere un'istanza di un delegato senza fornire argomenti per tutti i suoi parametri di tipo.

Una delle funzioni utili del compilatore C# è rappresentata dalle conversioni di gruppi di metodi impliciti, in cui il nome di un metodo (un "gruppo di metodi") può essere convertito implicitamente in un tipo delegato che rappresenta uno degli overload di tale metodo. Allo stesso modo, il compilatore converte implicitamente un'espressione lambda in un tipo delegato. In entrambi i casi, il compilatore emette il codice per creare un'istanza del tipo delegato (in questo caso, per passarlo alla funzione). Ma l'istanza di quel tipo delegato deve ancora avere un argomento di tipo per ciascuno dei suoi parametri di tipo.

per passare la funzione generica come funzione generica, sembra, il compilatore avrebbe bisogno di essere in grado di passare gruppo metodo o l'espressione lambda al metodo senza conversione, così il aAction parametro avrebbe in qualche modo un tipo di "metodo gruppo" o "espressione lambda". Quindi, la conversione implicita a un tipo di delegato potrebbe avvenire nei siti di chiamata A result1 = aAction<A>(aStringA); e B result2 = aAction<B>(aStringB);. Naturalmente, a questo punto, siamo ben lungi dall'universo dei contrafactuals e degli ipotetici.

La soluzione mi è venuta durante il pranzo è stato questo, assumendo una funzione Deserialize<T> che prende una stringa contenente dati serializzati e restituisce un oggetto di tipo 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

Questa risposta non spiega il motivo perché, solo come per aggirare la limitazione.

Invece di passare una funzione di vero e proprio, è possibile passare un oggetto che ha una tale funzione:

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

Per il vostro caso specifico utilizzo, può essere semplificata per:

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