如何在 C# 中将继承的 List<SuperClass> 专门化为 List<SubClass>？

Question

这听起来像是一个常见的问题，所以如果你有一个基类 A 和 List<SuperClass> 类型的公共属性，并且你在 B 类中继承了该列表，但想要使用更专业的类型参数，那么最佳实践是什么？列表：

class SuperClass 
{
    public bool Flag;
}

class SubClass : SuperClass 
{
    public int Number;
}

class A
{
    public List<SuperClass> Elements { get; }
}

class B : A
{
   public List<SubClass> Elements { get; set; }
}

那么如何用一个新列表覆盖 Elements 列表，但仍然确保如果另一个类只知道 A 对象，它会被访问？

class C
{
    List<A> AList;

    void FillList()
    {
        AList.Add(new B());
    }

    void DoSomething()
    {
        foreach (var a in AList)
            forach(var super in a.Elements)
                super.Flag = true;  
    }
}

Answer 1

我试了一下。

class Program {
    static void Main(string[] args) {

        var c = new C();
        c.FillList();
        c.DoSomething();


        Console.ReadKey();

    }
}


class C {
    List<A> AList;

    public void FillList() {
        AList = new List<A>();

        var a = new A();
        a.Elements = new List<SuperClass>() { new SubClass(), new SuperClass() };
        AList.Add(a);

        var b = new B();
        b.Elements = new List<SubClass>() { new SubClass(), new SubClass() };
        AList.Add(b);
    }

    public void DoSomething() {
        foreach (var a in AList)
            foreach (var super in a.Elements) { 
                super.Flag = true;
                Console.WriteLine(super.GetName());
            }
    }
}


class SuperClass {
    public bool Flag;
    public virtual string GetName() { return "super"; } 
}
class SubClass : SuperClass {
    public SubClass() { }
    public SubClass(SuperClass x) { }

    public int Number;
    public override string GetName() { return "sub"; } 
}

class A {

    public virtual IEnumerable<SuperClass> Elements {
        get{
            return elementList.AsEnumerable();
        }
        set {
            elementList = value.ToList();
        }
    }

    private List<SuperClass> elementList;
}

class B : A {

    public override IEnumerable<SuperClass> Elements {
        get {
            return elementList.AsEnumerable();
        }
        set {
            elementList = value.Aggregate(new List<SubClass>(), 
                                (acc, x) => {
                                    if (x is SubClass) 
                                        acc.Add((SubClass)x);
                                    else 
                                        acc.Add(new SubClass(x)); 
                                    return acc; });
        }
    }

    private List<SubClass> elementList;
}

我使用 IEnumerable。 并在调用 setter 属性（B 类）时将 IEnumerable<SuperClass> 转换为 List<SubClass>。

Answer 2

你不能。因为就目前而言，如果通过 A 接口插入 SuperClass，B 会失败，因为 SuperClass 无法插入 B 的 SubClass 列表中。

你应该用谷歌搜索的具体术语是Covariance 和Contravariance。

如果您将类限制为至少在基类中进行读取访问，则可以解决您的情况。然后，您的 B 类中可以有两个只读属性，一个是专用的，一个不是专用的，但返回专用版本。