Come definire un metodo di estensione generico

Question

Sto tentando di definire un metodo di estensione che può restituire un oggetto di un tipo definito dalla chiamata.

Uso desiderata:Cat acat = guy.GiveMeYourPet<Cat>();

Tentativo implementazione

non ho problemi a definire metodi generici come questo:

public static T GiveMeYourPet<T>(Person a) { ... } 

Cat acat = GiveMeYourPet<Cat>(guy); 

o estensione metodi come questo:

public static Cat GiveMeYourPetCat<P>(this P self) where P : Person, ... { ... } 

Cat acat = guy.GiveMeYourPetCat(); 

Ma quando cerco di fare quello che voglio:

public static T GiveMeYourPet<T, P>(this P self) where P : Person, ... { ... } 

Cat acat = guy.GiveMeYourPet<Cat>(); 

Il compilatore si aspetta GiveMeYourPet() per ricevere 2 argomenti di tipo (anche se uno è implicita chiamando il metodo di estensione sull'oggetto guy.

Cosa posso fare per fare in modo che funzioni?

Nota che ho provato anche invertendo l'ordine in cui sono definiti i parametri, ma non cambia nulla:

public static T GiveMeYourPet<P, T>(this P self) 

la seguente chiamata, inoltre, non funziona, perché non si può avere una chiamata di metodo nel tipo specifiation:

Cat acat = guy.GiveMeYourPet<guy.GetType(), Cat>(); 

Answer 1

Il tipo C# compilatore inferenza non è sofisticato come si potrebbe sperare. È necessario specificare in modo esplicito di entrambi i tipi in tale metodo:

void Main() 
{ 
    int i = 0; 
    bool b = i.GiveMeYourPet<bool, int>(); 
} 

public static class MyExtensions 
{ 
    public static T GiveMeYourPet<T, P>(this P self) 
    { 
     return default(T); 
    } 
} 

Se si vuole evitare di specificare sia esplicitamente (e non mi biasimo), si potrebbe tentare di cambiare il metodo a qualcosa di simile:

public static T GiveMeYourPet<T>(this IPetOwner self) 

(con questa interfaccia, non si dovrebbe nemmeno bisogno di sapere qual è il tipo reale è, se non, usa as o is) o anche:

public static T GiveMeYourPet<T>(this object self) 

(e utilizzare as o is)

Se questo non è un'opzione, e il vero tipo di guy (nel tuo esempio) non è noto in modo statico (per esempio basta averlo come un object), probabilmente dovrete usare riflessione, ad esempio:

MethodInfo method = typeof(MyExtensions).GetMethod("GiveMeYourPet"); 
MethodInfo generic = method.MakeGenericMethod(typeof(Pet), guy.GetType()); 
generic.Invoke(guy, null); 

Answer 2

Se qualcosa del genere guy.GiveMeYour.Pet<Cat>(); avrebbe funzionato si può costruire 2 livelli simili a Codice:

public class GiveMeYourBuilder<P> 
{ 
    public P Me {get;set;} 
    public T Pet<T>() : where T: new() 
    { return new T();} 
} 

public static PetExtensions 
{ 
    public GiveMeYourBuilder<P>(this P me) 
    { 
     return new GiveMeYourBuilder<P> { Me = me;} 
    } 
} 

Answer 3

È non può in parte specificare argomenti generici, o sono tutti dedotti o devi specificarli tutti.In questo caso, il più vicino si può ottenere è probabilmente per restituire un oggetto intermedio che porta il Person tipo generico il metodo di estensione è chiamato, e definire i Get metodi su questo:

public class GiveContext<T> where T : Person 
{ 
    public P MeYourPet<P>() where P : Pet 
    { 
     return default(P); 
    } 
} 

public static GiveContext<T> Give<T>(this T person) where T : Person 
{ 
    return new GiveContext<T>(); 
} 

che si può usare come:

var p = new Person(); 
Cat c = p.Give().MeYourPet<Cat>(); 

Answer 4

Non è possibile farlo, sfortunatamente. Se il compilatore non riesce a visualizzarli tutti tutti fuori, è necessario digitare tutti gli argomenti di tipo. Il compilatore C# non è che smart. dynamic può aiutare però:

public static T GiveMeYourPet<T>(this dynamic self) 
{ 
    //in here check that self meets your constraints using is, as, etc. 
}