C#高级语法之泛型、泛型约束，类型安全、逆变和协变（思想原理）

//动物类
public class Animal
{
    //随便定义出一个属性和方法
    public String SkinColor { get; set; }//皮肤颜色
    //会跑的方法
    public virtual void CanRun()
    {
        Console.WriteLine("Animal Run Can");
    }
}

//动物子类 Dog
public class Dog : Animal
{
    //重写父类方法
    public override void CanRun()
    {
        Console.WriteLine("Dog Can Run");
    }
}

//动物子类 Pig
public class Pig : Animal
{
    //重写父类方法
    public override void CanRun()
    {
        Console.WriteLine("Pig Can Run");
    }
}

//存放所有动物
public class AnimalHouse
{
    //由于自己写线性表需要考虑很多东西，而且我们是要讲泛型的，所以内部就用List来实现
    private List animal = new List();

    //添加方法
    public void AddAnimal(Animal a)
    {
        animal.Add(a);
    }
    //移除方法，并返回是否成功
    public bool RemoveAnimal(Animal a)
    {
        return animal.Remove(a);
    }

}

//用在类中
public class ClassName
{
    //用在方法中
    public void Mothed() {
        
    }

    //泛型类中具体使用CName
    //返回值为CName并且接受一个类型为CName类型的对象
    public CName GetC(CName c) {
        //default关键字的作用就是返回类型的默认值
        return default(CName);
    }
}

public class AnimalHouse
{
    private List animal = new List();

    public void AddAnimal(T a)
    {
        animal.Add(a);
    }
    public bool RemoveAnimal(T a)
    {
        return animal.Remove(a);
    }

}

//声明存放所有Dog类型的集合
AnimalHouse dog = new AnimalHouse();
//声明存放所有Pig类型的集合
AnimalHouse pig = new AnimalHouse();

//微软官方例子
class Base { }
class Testwhere U : struct
    where T : Base, new()
{ }

//Animal约束T必须是Animal的子类或者本身，new()约束放在最后
public class AnimalHousewhere T : Animal, new()
{
    private List animal = new List();

    public void AddAnimal(T a)
    {
        //调用CanRun方法
        //如果不加Animal泛型约束是无法调用.CanRun方法的，因为类型是不确定的
        a.CanRun();
        //添加
        animal.Add(a);
    }
    public bool RemoveAnimal(T a)
    {
        return animal.Remove(a);
    }

}

//动物子类 Tiger
public class Tiger : Animal
{
    //私有化构造函数
    private Tiger()
    {

    }
    public override void CanRun()
    {
        Console.WriteLine("Tiger Can Run");
    }
}

Dog dog = new Dog();
Animal animal = dog;

AnimalHouse dogHouse = new AnimalHouse();
AnimalHouse animalHouse = dogHouse;

//强转编译会通过，强转的话会转换失败，值为null
IAnimalHouse animalHouse = dogHouse as IAnimalHouse;

//动物房子接口（所有动物的房子必须继承该接口，例如红砖动物房子，别墅动物房）
public interface IAnimalHousewhere T : Animal,new()
{

}
//实现IAnimalHouse接口
public class AnimalHouse : IAnimalHousewhere T : Animal,new()
{
    private List animal = new List();

    public void AddAnimal(T a)
    {
        a.CanRun();
        animal.Add(a);
    }
    public bool RemoveAnimal(T a)
    {
        return animal.Remove(a);
    }
}

public interface IAnimalHouseout T> where T : Animal,new()
{

}

IAnimalHouse dogHouse = new AnimalHouse();
IAnimalHouse animalHouse = dogHouse;

public interface IAnimalHousein T> where T : Animal,new()
{

}

IAnimalHouse animalHouse = new AnimalHouse();
IAnimalHouse dogHouse = animalHouse;

public interface IAnimalHousein T> where T : Animal,new()
{
    //添加方法
    void AddAnimal(T a);
    //移除方法
    bool RemoveAnimal(T a);
}

//需要一个IAnimalHouse类型的参数
public void TestIn(IAnimalHouse dog) {
    
}

//需要一个IAnimalHouse类型的参数
public static void TestIn(IAnimalHouse dog) {
    Dog d = new Dog();
    dog.AddAnimal(d);
}

//第一种
AnimalHouse dogHouse = new AnimalHouse();
TestIn(dogHouse);
//第二种 
AnimalHouse animalHouse = new AnimalHouse();
//因为使用了in关键字所以可以传入父类对象
TestIn(animalHouse);