协变(Covariance)与逆变(Contravariance)

协变与逆变是类型系统中一个常见的问题，基类与子类之间类型变换时的定义要求。

协变:模板参数实例化中的子类赋值给基类,保留类型的顺序，从具体类型到抽象类型。

IEnumerable<Base> base =IEnumerable<Derived>

         逆变:与协变相反，基类赋值给子类，从抽象类型到具体类型。

          IEnumerable<Derived> derived =IEnumerable<Base>

         不变:赋值时左右值类型必须相等

协变参数类型用于接口方法的返回值，逆变参数用于接口方法的形参。

协变与逆变只针对引用数据类型，值类型只有不变性。

C#语言中，在类继承体系中也可体现协变与逆变的特点，下面的例子中基类Objects对象赋值得到子类类型就是一个协变的实例，上下文中会记录objs的实际类型。当赋值时，编译器会判断对象的类型，如类型不合，则抛出异常。

            string[] str = new string[3];
            object[] objs = str;
            objs[1] = 12;// 类型不兼容异常
            objs[2] = "hello,world";
            Console.WriteLine(objs);

在类的继承体系中，这一特征就更加明显.

 public class Animal {
        public override string ToString()
        {
            return string.Format("class:{0}",this.GetType().Name);
        }
    };

    public class Cat : Animal {
        public override string ToString()
        {
            return string.Format("class:{0}", this.GetType().Name);
        }
    };

    public class AnimalShelter {
        public Animal getAnimalForAdoption() {
            Console.WriteLine("AnimalShelter::getAnimalForAdoption.");
            return new Animal();
        }

        public void putAnimal(Animal animal) {
            Console.WriteLine("AnimalShelter::putAnimal:{0}.",animal);
        } 
    };

    public class CatShelter :  AnimalShelter
    {
        public override Cat getAnimalForAdoption() {
            Console.WriteLine("AnimalShelter::getAnimalForAdoption.");
            return new Cat();
        }
}

上面实例的继承关系如下:

Cat → Animal: Cat 继承自Animal.

CatShelter → AnimalShelter:CatShelter 继承自AnimalShelter.

在方法getAnimalForAdoption中CatShelter重载基类方法，返回类型为Cat非基类的Animal，但这样的方法C#并不支持，基类约定返回为Animal对象，但子类返回为Animal的子类对象，这也就是协变(Covariant).C++中却支持返回协变类型的对象(多态)，相同实例如下:

class Animal {
public:
	friend std::ostream& operator<<(std::ostream &os,const Animal &animal);

	virtual std::ostream& ToString(std::ostream &os) const
	{
		os << "class Animal" << std::endl;

		return os;
	}
};

class Cat:public Animal{
	public:
	friend std::ostream& operator<<(std::ostream &os,const Cat &cat);
	std::ostream& ToString(std::ostream &os) const
	{
		os << "class Cat"<< std::endl;

		return os;
	}
};

class AnimalShelter {
public:
	virtual Animal* getAnimalForAdoption() {
            std::cout << "AnimalShelter::getAnimalForAdoption." << std::endl;
            return new Animal;
    }

	 virtual void putAnimal(const Animal& animal) {
            std::cout << "AnimalShelter::putAnimal:" << animal << std::endl;
     }

	 virtual ~AnimalShelter() {}
};

class CatShelter : public AnimalShelter
{
public:
	CatShelter(){}
	Cat* getAnimalForAdoption() { //covariant: return type
            std::cout << "CatShelter::getAnimalForAdoption." << std::endl;
            return new Cat;
    }

	void putAnimal(const Cat& cat) // Cat contracovariant: argument type
	{
		std::cout << "CatShelter::putAnimal:" << cat << std::endl;
	}
};

std::ostream& operator<<(std::ostream &os,const Animal &t)
{
	return t.ToString(os);
}

int _tmain(int argc, _TCHAR* argv[])
{
	
	AnimalShelter *psh = new CatShelter();
    Animal *pAnimal = psh->getAnimalForAdoption();
    psh->putAnimal(*pAnimal);
	getchar();
	delete pAnimal;
	delete psh;
	return 0;
}

另一方面，通过C++实例可以看到，putAnimal方法实现了逆变:子类函数参数为Cat非基类中的Animal (Animal→ Cat)，这一类型转换存在风险，Animalis Cat，Dog对象也可以作为putAnimal函数参数，这里调用仍然为基类方法。

C#模板中的Action对象定义如下：

public delegate void Action<in T>(T obj);//in 
public delegate void PAction<T>(T obj);
测试代码如下:
    public class Base {

        public override string ToString()
        {
            return string.Format("Class Base");
        }
    };
    public class Derived :Base{
        public override string ToString()
        {
            return string.Format("Class Derived");
        }
    
    };

Action<Base> b = (target) => { Console.WriteLine(target); };
Action<Derived> d = b;//子类 赋值 基类，基类赋值给子类，从抽象类型到具体类型
d(new Derived());
PAction<Base> pb = (target) => { Console.WriteLine(target); };
pb(new Derived());

public static void ForEach<T>(IEnumerable<T> enumeration, Action<T> action)
{
    foreach (T item in enumeration)
            {
                action(item);
            }
}
//基类作为形参，可能传入子类的对象，协变:基类 赋值 子类，从具体类型到抽象类型。
static void Print(IEnumerable<Base> iList)
{       
    ForEach(iList,(b) => { Console.WriteLine(b); });
}
List<Derived> dlist = new List<Derived>();
dlist.Add(new Derived());
dlist.Add(new Derived());
Print(dlist);