C# 如何在C中的泛型列表中存储不同类型的对象#

我需要添加不同类型的对象（即使它们不同，它们共享相同的基类，它们是兄弟）

考虑这个类层次结构

public abstract class Fruit
{
    public int Quality { get; set; }

    public string Name { get; set; }

}

public sealed class Apple :Fruit
{
    public string Color { get; set; }

    public Apple(string color ="Red")
    {
        Color = color;
    }
}

public sealed class Orange : Fruit
{
    public Orange(string type = "WithSeed")
    {
        Type = type;
    }
    public string Type { get; set; }
}

我怎么能做这样的事

_apples = new List<Apple>
        {
            new Apple
            {
                Name = "Fiji Apple",
                Quality = 9,
                Color ="Green"
            },
            new **Orange**
            {
                Name = "Indi Orange",
                Quality = 7,
            }
        };

\u苹果=新列表
{
新苹果
{
Name=“斐济苹果”，
质量=9，
Color=“绿色”
},
新**橙**
{
Name=“Indi Orange”，
质量=7，
}
};

此泛型列表的使用者将使用基类使用它。例如：使用

IEnumerable

。

---

有人可以建议吗？

有一个

水果的列表

。这样，列表将包含任何

水果

对象以及继承自

水果

类型的任何对象

List<Fruit> _list = new List<Fruit>
{
    new Apple
    {
        Name = "Fiji Apple",
        Quality = 9,
        Color ="Green"
    },
    new Orange
    {
        Name = "Indi Orange",
        Quality = 7
    }
};

List\u List=新列表
{
新苹果
{
Name=“斐济苹果”，
质量=9，
Color=“绿色”
},
新橙子
{
Name=“Indi Orange”，
质量=7
}
};

有一个

水果

。这样，列表将包含任何

水果

对象以及继承自

水果

的类型的任何对象

List<Fruit> _list = new List<Fruit>
{
    new Apple
    {
        Name = "Fiji Apple",
        Quality = 9,
        Color ="Green"
    },
    new Orange
    {
        Name = "Indi Orange",
        Quality = 7
    }
};

List\u List=新列表
{
新苹果
{
Name=“斐济苹果”，
质量=9，
Color=“绿色”
},
新橙子
{
Name=“Indi Orange”，
质量=7
}
};

列表必须始终知道它包含的是哪种类型。因此，为了让它同时包含

Apple

和

Orange

，您必须将列表定义为包含任何超类或接口，这些超类或接口涵盖了您想要放入列表中的所有项目

---

在这种情况下，这将使

列表

或

列表

可能同时包含这两种类型。

列表必须始终知道它包含的是哪种类型。因此，为了使它同时包含

苹果

和

橙色

，必须将列表定义为包含包含任何超类或接口，这些超类或接口涵盖了要放入列表中的所有项他列出了清单

---

在这种情况下，这将使

列表

或

列表

可能同时包含这两者。

为此使用类层次结构是一个常见的错误。 拥有一个接口，并为该接口创建一个列表，然后您甚至可以存储不属于该类层次结构的对象

---

当您需要存储不同类型的对象时，只需以该类型实现接口，这样您就不必对存储列表代码进行任何更改。

为此目的使用类层次结构是一个常见的错误。 拥有一个接口，并为该接口创建一个列表，然后您甚至可以存储不属于该类层次结构的对象

---

当您需要存储不同类型的对象时，只需以该类型实现接口，这样您就不必对存储列表代码进行任何更改。

因为所有对象都继承自Fruit，因此就足以创建

Fruit

的

列表

 List<Fruit>_apples = new List<Fruit>{...}

请记住，如果不扩展Fruit，则无法访问其属性，如
质量
和
颜色
，因为从Fruit继承的所有对象都足以创建
Fruit的
列表

 List<Fruit>_apples = new List<Fruit>{...}

请记住，如果不扩展Fruit，则无法访问其属性，如
质量
和
颜色
，请使用此代码在列表中添加不同的对象

List<Fruit> fruits = new List<Fruit>();
            fruits.Add(new Apple("Red"));
            fruits.Add(new Orange("Withseed"));

List水果=新列表（）；
添加新苹果（红色）；
水果。添加（新橙子（“带籽”）；
使用此代码在列表中添加不同的对象

List<Fruit> fruits = new List<Fruit>();
            fruits.Add(new Apple("Red"));
            fruits.Add(new Orange("Withseed"));

List水果=新列表（）；
添加新苹果（红色）；
水果。添加（新橙子（“带籽”）；
我相信你想做的是使用不同类型的
水果的列表来存储它们或将它们放在一个
列表中传递，而不是需要单独的
列表
，
列表
等等。但是你仍然需要使用特定类型的东西（比如
苹果.Color
和
橙色.type
）

为了演示这一点，我创建了一个
水果篮
类来存储所有不同的
水果
对象和
Project（）
对象及其唯一属性

public class FruitBasket
{
    public List<Fruit> FruitList { get; }

    public FruitBasket(List<Fruit> fruitList)
    {
        FruitList = fruitList;
    }

    public List<string> Project()
    {
        var result = new List<string>();
        foreach (var fruit in FruitList)
        {
            if (fruit is Apple)
            {
                var apple = (Apple) fruit;
                result.Add("This is a " + apple.Color + " " + apple.Name);
            }
            else if (fruit is Orange)
            {
                var orange = (Orange) fruit;
                result.Add("A " + orange.Name + " with type: " + orange.Type);
            }
            else
            {
                result.Add("An unknown " + fruit.Name);
            }
        }
        return result;
    }
}

而
结果将是：

这是一个绿色的苹果

带有类型：带种子的印度橙

我相信你要做的是使用一个不同类型的
水果的列表来存储它们或者把它们放在一个
列表中，而不是需要单独的
列表
，
列表
，等等。但是你仍然需要使用特定类型的东西（比如
苹果.Color
和
橙色.type
）

为了演示这一点，我创建了一个
水果篮
类来存储所有不同的
水果
对象和
Project（）
对象及其唯一属性

public class FruitBasket
{
    public List<Fruit> FruitList { get; }

    public FruitBasket(List<Fruit> fruitList)
    {
        FruitList = fruitList;
    }

    public List<string> Project()
    {
        var result = new List<string>();
        foreach (var fruit in FruitList)
        {
            if (fruit is Apple)
            {
                var apple = (Apple) fruit;
                result.Add("This is a " + apple.Color + " " + apple.Name);
            }
            else if (fruit is Orange)
            {
                var orange = (Orange) fruit;
                result.Add("A " + orange.Name + " with type: " + orange.Type);
            }
            else
            {
                result.Add("An unknown " + fruit.Name);
            }
        }
        return result;
    }
}

而
结果将是：

这是一个绿色的苹果

带有类型：带种子的印度橙

不使用基类也可以。我的意思是，即使传递不同类型的对象（苹果、橙色、菠萝等）来准备这个数组，它们也应该被投影为苹果。我不知道“投影”是什么在这种情况下是指。你想让软件根据你告诉它的关于橙色的信息来组成一个苹果吗？橙色没有颜色属性，那么它到底是怎么做到的呢？你不能把苹果和橙色混合在一起；）你如何将一个
橙色
作为一个
苹果
？
苹果
有一堆橙色
没有的东西，反之亦然。您必须创建一个新的
Apple
对象，该对象与原始
Orange
对象共享尽可能多的共同点，b