我如何允许C＃添加另一种类型的结构以在其中添加或添加相同类型的列表？

Question

i have a List<animal> where i want to add all animal their even i can add them or add them whole list.

how i can do something that they allow to add the List<rat> or rat their is not only one i need to add any type of animal in it.

means i can allow both

List<animal> animal  = new List<animal>();

animal.Add(new rat());
animal.Add(new List<Elephant>());

i need a thing more that all animal is all animal found in animal list. i not need to count all object i need to count Every animal who add seprately or add whole list.

Can someone explain the code in C#.

Answer 1

List<animal> animal  = new List<animal>();
animal.Add(new Animal());
animal.AddRange(new List<animal>());

Of course if the types you are willing to add don't have a common base parent you cannot use a generic list. You might use an ArrayList which allows for storing any types.

---

UPDATE:

If Rat and Elephant both derive from Animal you can always do

List<animal> animal  = new List<animal>();
animal.Add(new Rat());

And in .NET 4.0 thanks to generic covariance you can also do:

animal.AddRange(new List<Elephant>()); 

but not in previous versions of the framework.

Answer 2

For your example with two different kinds of animals, I think a base class of animal makes sense, and derive a separate class for Elephant and Animal. A less novel approach, though doable is creating a generic list of objects. Not sure what your project is, so depending on the situation, you'll need to choose the implementation to use. Add each object to the generic list and check the type before using it with GetType() method.

Here's an example of using derived class though. You could change the base class to be an interface or abstract class as discussed above. I'll provide an example shortly for using generic objects.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        // Using derived way.
        List<Animal> animals = new List<Animal>();
        animals.Add(new Rat("the rat's name"));
        animals.Add(new Elephant("the elephant's name"));

        foreach (Animal a in animals)
        {
            Console.WriteLine(
                string.Format("Name of animal: {0}"), a.Name));
        }
    }
}

public class Animal
{
    public Animal(string name)
    {
        this.Name = name;
    }

    public string Name
    {
        get;
        private set;
    }
}

public class Elephant : Animal
{
    public Elephant(string name)
        :base(name)
    {

    }

    public string AnimalProps
    {
        get;
        set;
    }
}

public class Rat :Animal
{
    public Rat(string name)
        :base(name)
    {

    }

    public string RatProps
    {
        get;
        set;
    }
}

Answer 3

Here's an example with using a list of objects. I'd advise against this implementation, as generally a base/abstract/interface class and derived classes is cleaner, though I have seen cases where something like this is required.

public Form2()
    {
        InitializeComponent();

        List<object> objects = new List<object>();
        objects.Add(new Rat("the rat's name"));
        objects.Add(new Elephant("the elephant's name"));

        foreach (object o in objects)
        {
            if(o.GetType() == typeof(Rat))
            {
                Rat r = o as Rat;

                Console.WriteLine(
                    string.Format("Name of rat: {0}", r.Name));
            }
            else if(o.GetType() == typeof(Elephant))
            {
                Elephant e = o as Elephant;

                Console.WriteLine(
                    string.Format("Name of elephant: {0}", e.Name));
            }
        }
    }

    public class Elephant
    {
        public Elephant(string name)
        {
            this.Name = name;
        }

        public string Name
        {
            get;
            private set;
        }

        public string AnimalProps
        {
            get;
            set;
        }
    }

    public class Rat
    {
        public Rat (string name)
        {
            this.Name = name;
        }

        public string Name
        {
            get;
            private set;
        }

        public string RatProps
        {
            get;
            set;
        }
    }