在Ninject中寻找通用接口的具体实现

Question

I have a generic interface with specific implementations as follows:

public class Animal { }
public class Horse : Animal { }
public class Dog : Animal { }

public interface Vet<in T> where T : Animal
{
    void Heal(T animal);
}

public class HorseVet : Vet<Horse>
{
    public void Heal(Horse animal)
    {
        Console.WriteLine("Healing a horse");
    }
}

public class DogVet : Vet<Dog>
{
    public void Heal(Dog animal)
    {
        Console.WriteLine("Healing a dog");
    }
}

Now I want to be able to create an instance of the appropriate concrete implementation of Vet<T> given an Animal at runtime, as follows:

StandardKernel kernel = new StandardKernel();
kernel.Bind<Vet<Horse>>().To<HorseVet>();
kernel.Bind<Vet<Dog>>().To<DogVet>();

var animals = new Animal[] { new Horse(), new Dog() };

foreach (Animal animal in animals)
{
    // how do I get the right Vet<T> type here so I can call Heal(animal)?
}

My question is, how can I achieve the above so the correct implementation is retrieved, or do I need to refactor to a different way of organising my classes?

I've looked at the Ninject Factory Extension but that also doesn't seem to offer what I'm looking for.

If I wasn't using an IoC container, I'd do something like:

public Vet<Animal> Create(Animal animal)
{
    if (animal is Horse)
    {
        return new HorseVet();
    }
    else if ...
}

Answer 1

foreach (Animal animal in animals)
{
    Type vetType = typeof(Vet<>).MakeGenericType(animal.GetType());
    object vet = kernel.Get(vetType);
}

But the question now becomes how do you want to use this type? You might be tempted to do something like this:

var vet = (Vet<Animal>)kernel.Get(vetType);
vet.Heal(animal);

But this doesn't work, because instances of Vet<Dog> and Vet<Horse> can't be cast to Vet<Animal> , because this would require Vet<T> to be defined with an out keyword as in Vet<out Animal> . But this of course wouldn't work, because Vet<T> has an input parameter of type Animal .

So to solve this you either need a second non-generic Vet interface, or you need to either use reflection or dynamic typing. Using the non-generic interface might look like this:

public interface Vet {
    void Heal(Animal animal);
}

public interface Vet<T> : Vet where T : Animal {
    void Heal(T animal);
}

// Usage
var vet = (Vet)kernel.Get(vetType);
vet.Heal(animal);

Problem however is that this pollutes the implementations, because they suddenly need to implement a second method.

Another option is to use dynamic typing or reflection:

dynamic vet = kernel.Get(vetType);
vet.Heal((dynamic)animal);

Downside of course is that you would lose compile-time support, but if these two lines of code are the only lines in the application that call the vet like that, I would say it is fine. You can easily add a unit test that checks this code.

Do note btw that the in keyword on Vet<in T> is probably useless, unless you have vet implementations on both Dog and GoldenRetriever and want to be able to apply a GoldenRetriever to a Vet<Dog> .