根据其他参数指定泛型列表的类型

Question

我有一个问题，我无法用简单的语言来解释，所以我会用一个例子来说明我的想法。

我有牛、马、羊三个班。和类动物。现在我希望 clas Animal 存储动物列表，但只有一个指定的物种（用户在构造函数中选择类型）。现在我不想使用模板，也不想在一个类中创建三个不同的列表。所以我想知道是否有其他方法可以做到这一点。我认为可以这样做：

public class Animal
{

}
public class Cow : Animal
{

}
public class Horse : Animal
{

}
public class Sheep : Animal
{

}
public class Animals
{
    public String Type { get; protected set; }
    public List<Animal> List { get; set;}
    public Animals(String type)
    {
        this.Type = type;
        switch (type)
        {
            case "Cow":
                List = new List<Cow>();
                break;
            case "Horse":
                List = new List<Horse>();
                break;
            case "Sheep":
                List = new List<Sheep>();
                break;
        }
    }
}

当然，该代码只是示例，它不起作用，但我认为它说明了我遇到的问题。我确定我过去看到过类似的东西，但我不知道它是 C# 还是 Java。如果我记得它看起来像这样：

Animal animal = new Cow();

告诉我有没有办法做到这一点。

Answer 1

怎么样

public class Animals<T>
    where T : Animal
{
    public List<T> List {get;set;}
}

var Cows = new Animals<Cow>();

Answer 2

在每种情况下，您都可以将列表创建为List<Animal>，它会愉快地存储任何从 Animal 派生的对象。问题在于强制执行列表中的对象是相同的类型——不清楚你想在哪里强制执行，但我在下面尝试了它，将所需的类型保留在成员变量中。

如果你想要的只是一个特定类型的枚举器，你可以使用 OfType（感谢Kevin D）来生成枚举器。我知道您说过您不想使用泛型，但是您的 Animals 类不必有类型参数，使用模板方法是一种更优雅的解决方案（恕我直言）。

public class Animal
{
}

public class Cow : Animal
{
}

public class Animals
{
    private Type _animalType;
    private List<Animal> _animals = new List<Animal>();

    public Animals(Type animalType)
    {
        _animalType = animalType;
    }

    public IEnumerable<T> GetAnimals<T>() where T : Animal
    {
        return _animals.OfType<T>();
    }

    public void Add(Animal animal)
    {
        if (! _animalType.IsAssignableFrom(animal.GetType()))
            throw new Exception("Expected a " + _animalType.Name + " but was passed a " + animal.GetType().Name);
        _animals.Add(animal);
    }
}


public class Program
{
    public static void Main()
    {
        Animals animals = new Animals(typeof(Cow));

        animals.Add(new Cow());
        IEnumerable<Cow> cows = animals.GetAnimals<Cow>();

        foreach (var cow in cows)
        {
            // do something
        }
    }
}

Answer 3

我相信泛型是解决您的问题的最佳方式，顺便说一下，我希望这段代码对您有所帮助。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication7
{
  public class Animal
  {

  }
  public class Cow : Animal
  {

  }
  public class Horse : Animal
  {

  }
  public class Sheep : Animal
  {

  }    

  public class Animals
  {        
    protected ArrayList List { get; set; }
    protected Type Type { get; set; }

    public Animals(Type type)
    {
        this.Type = type;
        this.List = new ArrayList();
    }

    public void AddAnimal(Animal animal)
    {
        if (animal.GetType() == this.Type)            
            this.List.Add(animal);            
        else
            throw new Exception("Not expected type");
    }
 }

class Program
{
    static void Main(string[] args)
    {
        var s1 = new Sheep();
        var s2 = new Sheep();
        var c1 = new Cow();
        var sheepList = new Animals(typeof(Sheep));
        sheepList.AddAnimal(s1);
        sheepList.AddAnimal(s2);
        sheepList.AddAnimal(c1);//throws an exception
    }
  }
}