C#：是否存在支持删除操作的协变列表ICovariantList？

1. 为什么.NET没有内置的协变可删除列表接口？ #

C#中协变（out修饰符）的规则是：类型参数只能出现在输出位置（比如方法返回值），不能出现在输入位置（比如方法参数）。而删除操作的核心方法Remove(T item)中，T是输入参数——如果定义一个协变接口ICovariantList<out T>，这个方法的参数会直接违反协变规则。

假设真存在这样的接口，允许List<Dog>转换为ICovariantList<Pet>，那么理论上可以调用Remove(new Cat())，但实际列表是List<Dog>，根本不可能包含Cat实例，这会导致类型安全被破坏。因此C#不允许定义这种存在逻辑矛盾的协变接口。

2. 针对批量删除场景的解决方案 #

针对你需要聚合不同宠物子类列表、批量删除指定名称宠物的需求，有以下几种实用方案：

方案一：自定义逆变接口 #

利用逆变（in修饰符）定义仅包含安全删除操作的接口，逆变允许基类型替换派生类型，适配List<Dog>这类子类列表：

// 逆变接口，仅包含类型安全的删除操作
interface IPetRemover<in T> where T : Pet
{
    bool Remove(T item);
    IEnumerable<T> GetItems(); // 用于查找目标宠物
}

// 为List<T>实现该接口的包装类
public static class PetRemoverExtensions
{
    public static IPetRemover<T> AsPetRemover<T>(this List<T> list) where T : Pet
    {
        return new ListPetRemover<T>(list);
    }

    private class ListPetRemover<T> : IPetRemover<T> where T : Pet
    {
        private readonly List<T> _list;

        public ListPetRemover(List<T> list) => _list = list;

        public bool Remove(T item) => _list.Remove(item);

        public IEnumerable<T> GetItems() => _list;
    }
}

修改聚合方法和删除逻辑：

IEnumerable<IPetRemover<Pet>> GetPetLists()
{
    yield return dogs.AsPetRemover();
    yield return cats.AsPetRemover();
}

void RemovePet(string name)
{
    foreach (var remover in GetPetLists())
    {
        var doomed = remover.GetItems().FirstOrDefault(p => p.Name == name);
        if (doomed != null)
        {
            remover.Remove(doomed);
        }
    }
}

方案二：直接使用委托封装删除逻辑 #

如果不需要复用列表操作，直接用委托封装每个列表的删除逻辑是最轻量化的方案：

IEnumerable<Action<string>> GetPetRemovers()
{
    yield return name => 
    {
        var target = dogs.FirstOrDefault(d => d.Name == name);
        if (target != null) dogs.Remove(target);
    };
    yield return name => 
    {
        var target = cats.FirstOrDefault(c => c.Name == name);
        if (target != null) cats.Remove(target);
    };
}

void RemovePet(string name)
{
    foreach (var removeAction in GetPetRemovers())
    {
        removeAction(name);
    }
}

方案三：结合协变的IEnumerable<T>与删除委托 #

利用IEnumerable<T>的协变性，同时绑定原列表的删除方法：

IEnumerable<(IEnumerable<Pet> Items, Action<Pet> Remove)> GetPetLists()
{
    yield return (dogs, pet => dogs.Remove((Dog)pet));
    yield return (cats, pet => cats.Remove((Cat)pet));
}

void RemovePet(string name)
{
    foreach (var (items, remove) in GetPetLists())
    {
        var target = items.FirstOrDefault(p => p.Name == name);
        if (target != null) remove(target);
    }
}

总结 #

.NET没有内置协变可删除列表接口的核心原因是类型安全约束——删除操作的输入参数与协变规则冲突。你可以通过自定义逆变接口、封装委托逻辑等方式，在保证类型安全的前提下实现批量删除需求。

内容的提问来源于stack exchange，提问作者Mud