C# 实现多个泛型类型的泛型接口-如何共享方法实现？

假设我有以下接口

public interface IFilter<T>
{
    IEnumerable<T> ApplyFilter(IEnumerable<T> list);
}

公共接口IFilter
{
IEnumerable ApplyFilter（IEnumerable列表）；
}

具体实现如下：

public class PetFilter: IFilter<Dog>, IFilter<Cat>
{
    public IEnumerable<Dog> ApplyFilter(IEnumerable<Dog> list)
    {
         return ApplyFilter<Dog>(list);
    }

    public IEnumerable<Cat> ApplyFilter(IEnumerable<Cat> list)
    {
         return ApplyFilter<Cat>(list);
    }

    private IEnumerable<T> ApplyFilter<T>(IEnumerable<T> list)
    {
         // do the work here
    }
}

公共类PetFilter:IFilter，IFilter
{
公共IEnumerable ApplyFilter（IEnumerable列表）
{
返回ApplyFilter（列表）；
}
公共IEnumerable ApplyFilter（IEnumerable列表）
{
返回ApplyFilter（列表）；
}
私有IEnumerable ApplyFilter（IEnumerable列表）
{
//在这里工作
}
}

---

如果Dog和Cat共享同一个实现，有没有办法避免必须为它们实现单独的方法？

是的，如果

Dog

和

Cat

都继承自一个公共基类，或者实现一个公共接口，例如

IAnimal

。例如：

private IEnumerable<T> ApplyFilter(IEnumerable<T> list)
where T:IAnimal
{
     // do the work here
}

private IEnumerable ApplyFilter（IEnumerable列表）
其中T:IAnimal
{
//在这里工作
}

---

换句话说，如果

Cat

和

Dog

共享过滤逻辑，那么它肯定是指一个公共基类。

是的，因为

Dog

和

Cat

都继承自一个公共基类或实现一个公共接口，例如

IAnimal

。例如：

private IEnumerable<T> ApplyFilter(IEnumerable<T> list)
where T:IAnimal
{
     // do the work here
}

private IEnumerable ApplyFilter（IEnumerable列表）
其中T:IAnimal
{
//在这里工作
}

---

换句话说，如果

Cat

和

Dog

共享过滤逻辑，那么它肯定是指一个共同的基础。

是和否。当您在没有任何约束的情况下使用泛型时，编译器将无法知道如何操作不同的类（即使它们以某种方式相关）。例如，想一想编译器如何知道ApplyFilter可以在Cat和Dog类上工作？对它来说，狗和猫是完全不同的东西

然而，考虑到您的两个类都继承自同一个基类，您可以通过它们的公共基类（或接口）对它们进行操作，但是您的PetFilter类也需要是泛型的

public abstract class Pet
{
}

public class Dog : Pet
{
}

public class Cat : Pet
{

}

下面是一个泛型PetFilter类，它继承了IFilter，即使IFilter没有泛型约束，也可以向PetFilter类添加一个

public class PetFilter<T> : IFilter<T> where T : Pet
{
    public IEnumerable<T> ApplyFilter(IEnumerable<T> list)
    {
        throw new NotImplementedException();
    }
}

公共类PetFilter:IFilter其中T:Pet
{
公共IEnumerable ApplyFilter（IEnumerable列表）
{
抛出新的NotImplementedException（）；
}
}

是和否。当您在没有任何约束的情况下使用泛型时，编译器将无法知道如何操作不同的类（即使它们之间存在某种关联）。例如，想一想编译器如何知道ApplyFilter可以在Cat和Dog类上工作？对它来说，狗和猫是完全不同的东西

然而，考虑到您的两个类都继承自同一个基类，您可以通过它们的公共基类（或接口）对它们进行操作，但是您的PetFilter类也需要是泛型的

public abstract class Pet
{
}

public class Dog : Pet
{
}

public class Cat : Pet
{

}

下面是一个泛型PetFilter类，它继承了IFilter，即使IFilter没有泛型约束，也可以向PetFilter类添加一个

public class PetFilter<T> : IFilter<T> where T : Pet
{
    public IEnumerable<T> ApplyFilter(IEnumerable<T> list)
    {
        throw new NotImplementedException();
    }
}

公共类PetFilter:IFilter其中T:Pet
{
公共IEnumerable ApplyFilter（IEnumerable列表）
{
抛出新的NotImplementedException（）；
}
}

Cat和Dog是否都继承自定义所有要筛选的值的公共基？这不是一个好主意。这很好地说明了你是如何在这段代码中立即创建一个bug的。猫和狗是否都继承了一个定义了所有你想要筛选的值的共同基础？这不是一个好主意。很好地说明了您是如何在这段代码中立即创建错误的。谢谢，不幸的是，我无法使PetFilter通用，因此我认为答案可能是否定的。谢谢您的全面回答。谢谢，不幸的是，我无法使PetFilter通用，因此我认为答案可能是否定的。谢谢您的全面回答。