C# 创建抽象基类的子类的数组、列表或集合

试图帮助一个朋友。我不是微软的程序员

public abstract class Foo {}
public class Bar : Foo {}
public class Baz : Foo {}

这似乎工作得很好，然后在另一个类中，他可以像这样实例化

Bar

和

Baz

的数组

public class MyClass {
  Bar[] Bars = new Bar[] { new Bar[] { new Bar(), new Bar() } }
  Baz[] Bazs = new Baz[] { new Baz[] { new Baz(), new Baz() } }
}

问题是他是否想要一个返回

Foos

和

bar

的访问者，他是如何做到的

public class MyClass {
  Bar[] Bars = new Bar[] { new Bar[] { new Bar(), new Bar() } }
  Baz[] Bazs = new Baz[] { new Baz[] { new Baz(), new Baz() } }
  public IEnumerable<Foo> GetFoos() {
    // No go.
    return [ Bars, Bazs ];

    // Also No go.
    List<Foo> test = new List<Foo> { Bars, Bazs };
    return test;
  }
}

公共类MyClass{
Bar[]Bars=新条[]{new Bar[]{new Bar（），new Bar（）}
Baz[]Baz=new Baz[]{new Baz[]{new Baz（），new Baz（）}
公共IEnumerable GetFoos（）{
//不行。
返回[bar，baz]；
//也不行。
列表测试=新列表{bar，baz}；
回归试验；
}
}

---

我认为微软通常通过接口来实现这一点，但他的任务要求使用抽象基类。有没有方法返回抽象基类的子类列表或数组？

在这两种情况下，都不能创建“new Foo（）”的实例，因为“Foo”是一个抽象类。您可以创建Bar和Baz对象，并返回Foo数组。看看下面的答案是否有用

    public class MyClass
    {
        Foo[] Foos1 = new Foo[] { new Bar(), new Bar() };
        Foo[] Foos2 = new Foo[] { new Baz(), new Baz() };

        // OR use as below

        /*
        Foo[] Foos1 = new Bar[] { new Bar(), new Bar() };
        Foo[] Foos2 = new Baz[] { new Baz(), new Baz() };
        */

        public IEnumerable<Foo> GetFoos1()
        {
            // Works.
            return Foos1;
        }

        public IEnumerable<Foo> GetFoos2()
        {
            // Works
            List<Foo> test = new List<Foo>();
            test.AddRange(Foos2);
            return test;
        }
    }

公共类MyClass
{
Foo[]Foos1=newfoo[]{newbar（），newbar（）}；
Foo[]Foos2=newfoo[]{new Baz（），new Baz（）}；
//或使用如下
/*
Foo[]Foos1=newbar[]{newbar（），newbar（）}；
Foo[]Foos2=newbaz[]{newbaz（），newbaz（）}；
*/
公共IEnumerable GetFoos1（）
{
//工作。
返回食物1；
}
公共IEnumerable GetFoos2（）
{
//工作
列表测试=新列表（）；
测试范围（Foos2）；
回归试验；
}
}

在这两种情况下，都不能创建“new Foo（）”的实例，因为“Foo”是一个抽象类。您可以创建Bar和Baz对象，并返回Foo数组。看看下面的答案是否有用

    public class MyClass
    {
        Foo[] Foos1 = new Foo[] { new Bar(), new Bar() };
        Foo[] Foos2 = new Foo[] { new Baz(), new Baz() };

        // OR use as below

        /*
        Foo[] Foos1 = new Bar[] { new Bar(), new Bar() };
        Foo[] Foos2 = new Baz[] { new Baz(), new Baz() };
        */

        public IEnumerable<Foo> GetFoos1()
        {
            // Works.
            return Foos1;
        }

        public IEnumerable<Foo> GetFoos2()
        {
            // Works
            List<Foo> test = new List<Foo>();
            test.AddRange(Foos2);
            return test;
        }
    }

公共类MyClass
{
Foo[]Foos1=newfoo[]{newbar（），newbar（）}；
Foo[]Foos2=newfoo[]{new Baz（），new Baz（）}；
//或使用如下
/*
Foo[]Foos1=newbar[]{newbar（），newbar（）}；
Foo[]Foos2=newbaz[]{newbaz（），newbaz（）}；
*/
公共IEnumerable GetFoos1（）
{
//工作。
返回食物1；
}
公共IEnumerable GetFoos2（）
{
//工作
列表测试=新列表（）；
测试范围（Foos2）；
回归试验；
}
}

要将另一个IEnumerable'T添加到列表中，必须使用“AddRange”，如：

List test=newlist（）；
测试范围（Foos）；
测试范围（巴）；
回归试验；

还可以使用列表构造函数重载将现有IEnumerable'T添加到列表中：

List test=新列表（Foos）；
测试范围（巴）；
回归试验；

要将另一个IEnumerable'T添加到列表中，必须使用“AddRange”，如：

List test=newlist（）；
测试范围（Foos）；
测试范围（巴）；
回归试验；

还可以使用列表构造函数重载将现有IEnumerable'T添加到列表中：

List test=新列表（Foos）；
测试范围（巴）；
回归试验；

无需复制阵列。以下代码将生成一个始终反映数组当前内容的

IEnumerable

，并且不会占用大量内存：

public class MyClass
{
    private Bar[] Bars = new Bar[] {new Bar(), new Bar()};
    private Baz[] Bazs = new Baz[] {new Baz(), new Baz()};

    public IEnumerable<Foo> GetFoos()
    {
        // Cast Bars as an Enumerable<Foo>, then append Bazs 
        // (no need to explicitly cast Bazs)
        return Bars.AsEnumerable<Foo>().Concat(Bazs);

        // or

        // Create an empty Enumerable<Foo>, then append Bazs and Bars
        return Enumerable.Empty<Foo>().Concat(Bars).Concat(Bazs);
    }
}

---

无需制作阵列的副本。以下代码将生成一个始终反映数组当前内容的

IEnumerable

，并且不会占用大量内存：

public class MyClass
{
    private Bar[] Bars = new Bar[] {new Bar(), new Bar()};
    private Baz[] Bazs = new Baz[] {new Baz(), new Baz()};

    public IEnumerable<Foo> GetFoos()
    {
        // Cast Bars as an Enumerable<Foo>, then append Bazs 
        // (no need to explicitly cast Bazs)
        return Bars.AsEnumerable<Foo>().Concat(Bazs);

        // or

        // Create an empty Enumerable<Foo>, then append Bazs and Bars
        return Enumerable.Empty<Foo>().Concat(Bars).Concat(Bazs);
    }
}

---

在这两种情况下，都不能创建“new Foo（）”的实例，因为“Foo”是一个抽象类。您可以创建Bar和Baz对象，并返回Foo数组。查看下面的答案是否有帮助。代码中可能存在语法错误：要创建数组，请使用

Bar[]Bar=new Bar[]{new Bar（），new Bar（）}

您似乎创建了某种嵌套数组，其中包含

new Bar[]{new Bar[]{…

在这两种情况下，您都不能创建“new Foo（）的实例'因为'Foo'是一个抽象类。你可以创建Bar和Baz的对象并返回Foo数组。看看下面的答案是否有帮助。代码中可能有语法错误：要创建数组，请使用

Bar[]Bar=new Bar[]{new Bar（），new Bar（）}

你似乎用

new Bar[]{new Bar[]创建了某种嵌套数组{…

在代码的这一点上，是否有办法保持Foos1和Foos2的强类型，并使其仍能工作？或者，我是否已将它们键入那里的ABC？不确定，如果我清楚地理解了问题。如果您能解释您试图解决的问题/场景，这将非常有帮助。您可以替换上述问题的前两行，如中所示更新后的答案也是。在这个例子中，如果我想将Foos1声明为Bar[]，我可以在那个时候这样做，然后稍后将其转换为Foo吗？另外，我声明Foo是一个抽象基类，我得到的列表不包含构造函数？是的，如果我们需要返回，因为Foo[]需要转换为Bar[]或Baz[]稍后，如果您想访问特定于fo Bar或Baz的某些功能，则可以直接作为Foo使用（如果您不打算访问任何特定于Bar或Baz的功能）。在代码的这一点上，是否有办法保持Foos1和Foos2的强类型，并使其仍能工作？或者，我是否已将它们键入那里的ABC？不确定，如果我清楚地理解了问题。如果你能解释你试图解决的问题/场景，那将很有帮助。你可以在更新中替换上述问题的前两行在这种情况下，在从函数返回的点之前——当您