Get tipo di ritorno "oggetto" da Func <MyClass, object>

Question

Supponiamo ho definito Func come segue:

Func<MyClass, object> f = o => o.StringProperty; 

o

Func<MyClass, object> f = o => o.Property.SomeMethod(); 

c'è modo per ottenere l'attuale ritorno digitare senza specificarlo?

Answer 1

È possibile ottenere il tipo di ritorno come questo:

Ma questo si tornerà il tipo object. Se si desidera ottenere Method o String o qualcosa che deriva da object, non sarà possibile avere le informazioni a meno che non si chiami il metodo.

In realtà si potrebbe, ma ciò significherebbe che si dovrebbe smontare il metodo core e quindi analizzarlo per vedere cosa può restituire il metodo. Ma anche in questo caso, potrebbero esserci molti tipi diversi di rendimento.

Quindi la risposta è: se vuoi sapere che restituisce un oggetto, allora sì puoi, altrimenti non ne vale la pena, ed è meglio trovare un altro modo di fare ciò che ti serve.

Answer 2

Si può fare qualcosa di simile a questo utilizzando un metodo generico per rendere il compilatore dedurre gli argomenti di tipo:

static Func<T1, R> Infer<T1, R>(Func<T1, R> f) { return f; } 

E poi:

var func = Infer((string s) => s.Length); 

Questa codificherà il tipo di ritorno in tipo di func al momento della compilazione.

Naturalmente per una soluzione più generalmente applicabile si avrebbe bisogno di un po 'di sovraccarichi di Infer per coprire Action e Func con uno, due, tre, ecc argomenti.

Se si desidera ottenere il tipo di ritorno in fase di esecuzione, per qualsiasi tipo di Func è semplice come func.Method.ReturnType come già rilevato da ppetrov.

Answer 3

Poiché si richiamano questi delegati Func<MyClass, object> in fase di runtime da altre fonti, le informazioni sul tipo vengono sostanzialmente perse.

Invece, in cui vengono definite queste funzioni, è possibile avere i chiamanti in sostanza, di codificare le informazioni di tipo in un delegato avvolto sfruttando la LINQ Expression API (EDIT: mi sciocco, di gran lunga più semplice, a questo punto, abbiamo già avere le informazioni momento della compilazione generico):

public class MyClassDelegate 
{ 
    private readonly Func<MyClass, object> Function; 

    public Type ReturnType { get; private set; } 

    private MyClassDelegate(Func<MyClass, object> function, Type returnType) 
    { 
     this.Function = function; 
     this.ReturnType = returnType; 
    } 

    public object Invoke(MyClass context) 
    { 
     return Function(context); 
    } 

    public static MyClassDelegate Create<TReturnType>(Func<MyClass, TReturnType> function) 
    { 
     Func<MyClass, object> nonTypedFunction = o => function(o); 
     return new MyClassDelegate(nonTypedFunction, typeof(TReturnType)); 
    } 
} 

(Un generico classe derivata MyClassDelegate<TReturnType> : MyClassDelegate potrebbe essere fatto anche per aggirare alcuni dei sillyness nel metodo Create, o evitare il valore-tipo di boxe, o di avere il ritorno scrivi le informazioni disponibili al momento della compilazione o anche riflettendo su qualsiasi cosa sia MyClassDelegate<TReturnType>.)

chiamanti che definiscono i delegati invece di lavorare direttamente con un Func<MyClass, object> avrebbe invece lavorare con questa classe e definire i loro delegati come:

MyClassDelegate f1 = MyClassDelegate.Create(o => o.StringProperty); 
MyClassDelegate f2 = MyClassDelegate.Create(o => o.Property.SomeMethod()); 

tuo API richiederebbe un MyClassDelegate, con il quale si può facilmente accedere ai loro tipi :

Console.WriteLine(f1.ReturnType.FullName); //string 
Console.WriteLine(f2.ReturnType.FullName); //whatever `SomeMethod()` is declared to return 

Infine, è possibile richiamare i delegati o addirittura creare Func<MyClass, object> delegati ancora:

f1.Invoke(myClassInstance); 
Func<MyClass, object> f3 = f1.Invoke;