How can I define a generic extension method

Question

I am trying to define an extension method that can return an object of a type defined by the call.

Desired Use: Cat acat = guy.GiveMeYourPet<Cat>();

Attempted implementation

I have no trouble defining generic methods like this:

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

Cat acat = GiveMeYourPet<Cat>(guy);

or extension methods like this:

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

Cat acat = guy.GiveMeYourPetCat();

But when I try to do what I really want:

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

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

The compiler expects GiveMeYourPet() to receive 2 type arguments (even though one is implicitly provided by calling the extension method on the object guy.

What can I do to make this work?

Note that I've also tried reversing the order in which the parameters are defined, but nothing changes:

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

The following call also does not work, because you cannot have a method call in the type specifiation:

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

Answer 1

The C# compiler type inference is not as sophisticated as you might hope. You have to explicitly specify both types in such a method:

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

If you want to avoid specifying both explicitly (and I wouldn't blame you), you might try to change your method to something like:

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

(with this interface, you shouldn't even need to know what the real type is; if you do, use as or is) Or even:

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

(and use as or is)

If that's not an option, and the real type of guy (in your example) is not statically known (e.g. you just have him as an object), you'll probably have to use reflection, e.g.:

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

Answer 2

If something like guy.GiveMeYour.Pet<Cat>(); would work you can build 2 levels similar to code:

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