如何在C＃中的通用接口上创建协变扩展方法？

Question

If the title didn't make sense, here's an example:

interface IEat { void Eat; }
class Cat : IEat { void Eat { nom(); } }
class Dog : IEat { void Eat { nom(); nom();nom(); } }
class Labrador : Dog { }

I'd like to create an extension method like this:

public static void FeedAll(this IEnumerable<out IEat> hungryAnimals) {
   foreach(var animal in hungryAnimals) animal.Eat();
}

So I can do this:

listOfCats.FeedAll();
listOfLabs.FeedAll();
listOfMixedHungryAnimals.FeedAll();

Is this possible? Where did I go wrong?

The real-world application here is that "Dog" is a major base class in my application, and there are many subclasses, each of which may have ILists of things from time to time that need to have group operations performed on them. Having to cast them just to call an extension method on a List of an interface they all implement would be suboptimal.

Edit:

I goofed up the example a little. My actual code is using IList , I was hoping to have Count and index-based operations available. Based on the answers below, I guess I'll have to go another direction for the methods that require IList semantics.

Answer 1

This will work if you remove the out :

public static void FeedAll(this IEnumerable<IEat> hungryAnimals) {
   foreach(var animal in hungryAnimals) animal.Eat();
}

variance applies to parameters of the the interface itself ( T in IEnumerable<T> in this case) so a List<Dog> is compatible with IEnumerable<IEat> .

Answer 2

IEnumerable is already covariant, so your extension method can accept an IEnumerable<IEat> and an IEnumerable<Dog> instance will be a valid argument, making the extension method apply to variables of those types.

Had the definition of the interface not specified that the generic argument was covariant/contravariant then there would be nothing that you extension method could do to allow that argument to be covariant. If you were using, say, a List which is invariant, there is nothing your extension method can do to allow for the use of covariance.

Answer 3

As Servy notes, Enumerable<T> is already covariant, but it doesn't need to be. For older versions where the interface isn't covariant, you could do this:

public static void FeedAll<T>(this IEnumerable<T> hungryAnimals) where T : IEat
{
    foreach(var animal in hungryAnimals) animal.Eat();
}

Answer 4

你不需要它通过引用传递它所以它将解决它。