享受代码,享受人生

SOA is an integration solution. SOA is message oriented first.
The Key character of SOA is loosely coupled. SOA is enriched
by creating composite apps.
posts - 213, comments - 2314, trackbacks - 162, articles - 45
  博客园 :: 首页 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理

公告

Covariance and Contravariance

Posted on 2010-06-20 14:36 idior 阅读(...) 评论(...) 编辑 收藏

协变和逆变,这两个词的翻译实在很难表达出他们的真实含义。其实他们是继承和多态的衍生物,而且在.Net 1.0 和2.0中都提供了某种程度的支持,只是在.Net 4.0中支持的更加完善了。

简单说来,协变和逆变就是希望支持更多情况的隐式类型转换,使得我们的编程更加方便,而通常来说只有具备继承关系的两个对象才可以发生隐式类型转换,如Base b=new Derived(). 协变和逆变则使得更多的类型之间可以发生隐式类型转换,如通过协变以下代码可以正常工作:

           Func<Derived> dFunc=GetDFunc();
           Func<Base> bFunc = dFunc;

           IEnumerable<Derived> dEnum=GetDEnum();
           IEnumerable<Base> bEnum = dEnum;

 

那么我们为什么需要这种功能呢?让我们从一个多态的例子开始:

 

     abstract class Animal
     {
         internal abstract void Eat();
     }


     abstract class Mammal : Animal
     {
     }

     class Tiger : Mammal
     {
         internal override void Eat()
         {
             Console.WriteLine("Tiger eat");
         }
     }
class Program
{
    static void Main(string[] args)
    {
        Tiger tiger = new Tiger();
        FeedAnimal(tiger);
    }

    static void FeedAnimal(Animal animal)
    {
        animal.Eat();
    }
}

虽然FeedAnimal方法接受的参数类型为Animal ,但是当我们传入一个Tiger 的实例,方法能够编译通过,并得到正确的执行。这是一个典型的多态运用。之所以能够这么做是因为Tiger 继承于Animal ,在FeedAnimal方法中对Animal对象的各种操作,Tiger 对象同样支持,而不会发生调用了animal的某个方法A,而tiger中不存在A方法的情况。 那么如果我们把这一原则推而广之,就出现了协变这一概念。

       static void FeedAnimal(Func<Animal> animalCreator)
       {
           var animal=animalCreator();
           animal.Eat();
       }

       static Tiger CreateTiger()
       {
           return new Tiger();
       }

现在我们让FeedAnimal方法接受一个能够返回Animla的delegate,而同时又创建了一个能够返回Tiger的方法。按照之前的推理,FeedAnimal方法无非就是对delegate中返回的Animal对象进行各种操作,那么如果给它一个返回Tiger对象的delegate,也应该能够正常的工作。所以下面这段代码是可以在.NET 2.0中工作的。

class Program
{
    static void Main(string[] args)
    {
        FeedAnimal(CreateTiger);
    }
}

这就是所谓的协变,我们希望两个对象之间,除了继承关系外也能做隐式类型的转换,因为我们认为这种转换是合理的,是类型安全的。

大家可能很奇怪,如果.Net 2.0就已经支持了以上的代码,那么4.0又搞了些什么?

先来看看下面的代码:

 
class Program
{
    static void Main(string[] args)
    {
        Tiger tiger = new Tiger();
        FeedAnimal(tiger);
    }

    static void FeedAnimal(Animal animal)
    {
        Console.WriteLine("Feed Animal");    
    }
 
    static void FeedAnimal(Mammal mammal)
    {
        Console.WriteLine("Feed Mamal");  
    } 
}
 

以上这段代码的输出结果是 Feed Mammal,当碰到两个匹配的重载方法时,.Net编译器选择了形参类型在继承树上更接近自己的方法。可是如果我们把Animal改成Func<Animal> 以下代码就编译出错了,编辑器不知道选择哪个方法作为匹配。

 

class Program
{
    static void Main(string[] args)
    {
        FeedAnimal(CreateTiger);
    }
    static Tiger CreateTiger() { return new Tiger(); } 
  
    static void FeedAnimal(Func<Animal> animalCreator)
    {
        var animal=animalCreator();
        animal.Eat();
    }

    static void FeedAnimal(Func<Mammal> animalCreator)
    {
        var animal = animalCreator();
        animal.Eat();
    }

究其根本,在C# 2.0中你无法实现以下delegate间的隐式类型转换

Func<Tiger> tFunc = CreateTiger;
Func<Animal> aFunc = tFunc;

 

而C# 4.0, 使得上述代码能够成功运行,之前的两个方法他也能够做出正确的选择。这是通过out关键字实现的。 注意Func<TResult> 这个delegate在C# 2.0和4.0中的定义是不同的:

     //C# 2.0
     public delegate TResult Func<TResult>();

     //C# 4.0
     public delegate TResult Func<out TResult>();

out关键字表示该类型用于返回值,而返回值可以发生协变,因为一个方法如果能够接受一个返回Animal的delegate,那么他必然也可以接受一个返回Tiger的delegate,因为他对animla的操作同样可以作用于tiger上。

既然delegate能够支持协变,那么interface也应该给予支持,因为它无非就是多个delegate罢了。

以下代码在C# 2.0中式不能通过编译的, 这样看来interface还不如delegate支持的好。

static void Main(string[] args)
{
    List<Tiger> tigers = new List<Tiger>();
    FeedAnimals(tigers);          
}

static void FeedAnimals(IEnumerable<Animal> animals)
{
    foreach (var animal in animals)
        animal.Eat();
}

下面的代码也就更加不行了:

List<Tiger> tigers = new List<Tiger>();
IEnumerable<Animal> animlas = tigers;

 

到了C# 4.0中,由于out关键字的缘故,以上两段代码都能正常工作了。而IEnumerable<T>的定义也被改为

 

     public interface IEnumerable<out T> : IEnumerable
     {                     
         IEnumerator<T> GetEnumerator();
     }

 

之前举得例子都是描述协变的,其实逆变无非就是扩大了输入参数的类型转换的可能,不过方向是反的。

  static void FeedAnimal(Animal animal)
  {
      animal.Eat();
  }

  static void Execute(Action<Mammal> tAct)
  {
      tAct(new Tiger());
  }

 

在Execute方法中, 我们接受一个类型为Action<Mammal> 的delegate,我们在使用这个delegate时,可以传入各种类型的Mammal,比如Tiger, Lion。如果我们传入的delegate能够作用于Animal对象,那么他自然可以作用于Tiger, Lion。 所以我们可以传入一个输入类型更抽象的delegate。因此,在逆变的支持下我们可以写出以下代码。

 

      static void Main(string[] args)
      {
          Action<Animal> aAct = FeedAnimal;
          Action<Mammal> mAct = aAct;
          
          Execute(aAct);
      }

 

参考资料:

eric's series on covariance and contravariance