C# 4.0中的协变和逆变-c# 协变逆变

在上一篇文章中，我们实现了一个简单的爬虫，并指出了这种方式的缺陷。现在，我们就来看一下，如何使用C# 4.0中所引入的“协变和逆变”特性来改进这种消息执行方式，这也是我认为在“普适Actor模型”中最合适的做法。这次，我们动真格的了，我们会一条一条地改进前文提出的缺陷。

协变和逆变
在以前的几篇文章中，我们一直挂在嘴边的说法便是消息于Actor类型的“耦合”太高。例如在简单的爬虫实现中，Crawler接受的消息为Crawl(Monitor, string)，它的第一个参数为Monitor类型。但是在实际应用中，这个参数很可能需要是各种类型，唯一的“约束”只是它必须能够接受一个ICrawlResponseHandler类型的消息，这样我们就能把抓取的结果传递给它。至于操作Crawler对象的是Monitor还是Robot，还是我们单元测试时动态创建的Mock对象（这很重要），Crawler一概不会关心。

但就是这个约束，在以前的实现中，我们必须让这个目标继承Actor< ICrawlResponseHandler>，这样它也就无法接受其他类型的消息了。例如Monitor还要负责一些查询操作我们该怎么办呢？幸运的是，在.NET 4.0(C# 4.0)中，我们只需要让这个目标实现这样一个接口即可：

public interface IPort< out T>  
{  
    void Post(Action< T> message);  
}

瞅到out关键字了没？事实上，还有一个东西您在这里还没有看到，这便是Action委托在.NET 4.0中的签名：

public delegate void Action< in T>(T obj);

就在这样一个简单的示例中，协变和逆变所需要的in和out都出现了。这意味着如果有两个类型Parent和Child，其中Child是Parent的子类（或Parent接口的实现），那么实现了IPort< Child>的对象便可以自动赋值给IPort< Parent>类型的参数或引用1。使用代码来说明问题可能会更清楚一些：

public class Parent  
{  
    public void ParentMethod() { };  
}  
 
public class Child : Parent { }  
 
static void Main(string[] args)  
{  
    IPort< Child> childPort = new ChildPortType();  
    IPort< Parent> parentPort = childPort; // 自动转化  
    parentPort.Post(p => p.ParentMethod()); // 可以接受Action< Parent>类型作为消息  
}

这意味着，我们可以把ICrawlRequestHandler和ICrawlResponseHandler类型写成下面的形式：

internal interface ICrawlRequestHandler  
{  
    void Crawl(IPort< ICrawlResponseHandler> collector, string url);  
}  
 
internal interface ICrawlResponseHandler  
{  
    void Succeeded(IPort< ICrawlRequestHandler> crawler, string url, string content, List< string> links);  
    void Failed(IPort< ICrawlRequestHandler> crawler, string url, Exception ex);  
}

如今，Monitor和Crawler便可以写成如下模样：

internal class Crawler : Actor< Action< Crawler>>, IPort< Crawler>, ICrawlRequestHandler  
{  
    protected override void Receive(Action< Crawler> message) { message(this); }  
 
    #region ICrawlRequestHandler Members  
 
    void ICrawlRequestHandler.Crawl(IPort< ICrawlResponseHandler> collector, string url)  
    {  
        try 
        {  
            string content = new WebClient().DownloadString(url);  
 
            var matches = Regex.Matches(content, @"href=""(http://[^""]+)""").Cast< Match>();  
            var links = matches.Select(m => m.Groups[1].Value).Distinct().ToList();  
            collector.Post(m => m.Succeeded(this, url, content, links));  
        }  
        catch (Exception ex)  
        {  
            collector.Post(m => m.Failed(this, url, ex));  
        }  
    }  
 
    #endregion  
}  
 
public class Monitor : Actor< Action< Monitor>>, IPort< Monitor>, ICrawlResponseHandler  
{  
    protected override void Receive(Action< Monitor> message) { message(this); }  
 
    #region ICrawlResponseHandler Members  
 
    void ICrawlResponseHandler.Succeeded(IPort< ICrawlRequestHandler> crawler,  
        string url, string content, List< string> links) { ... }  
 
    void ICrawlResponseHandler.Failed(IPort< ICrawlRequestHandler> crawler,  
        string url, Exception ex) { ... }  
 
    #endregion  
 
    private void DispatchCrawlingTasks(IPort< ICrawlRequestHandler> reusableCrawler)  
    {  
        if (this.m_readyToCrawl.Count < = 0)  
        {  
            this.WorkingCrawlerCount--;  
        }  
 
        var url = this.m_readyToCrawl.Dequeue();  
        reusableCrawler.Post(c => c.Crawl(this, url));  
 
        while (this.m_readyToCrawl.Count > 0 &&  
            this.WorkingCrawlerCount <  this.MaxCrawlerCount)  
        {  
            var newUrl = this.m_readyToCrawl.Dequeue();  
            IPort< ICrawlRequestHandler> crawler = new Crawler();  
            crawler.Post(c => c.Crawl(this, newUrl));  
 
            this.WorkingCrawlerCount++;  
        }  
    }  
}

Monitor的具体实现和上篇文章区别不大，您可以参考文章末尾给出的完整代码，并配合前文的分析来理解，这里我们只关注被标红的两行代码。

在第一行中我们创建了一个Crawler类型的对象，并把它赋值给IPort< ICrawlerRequestHandler>类型的变量中。请注意，Crawler对象并没有实现这个接口，它只是实现了IPort< Crawler>及ICrawlerRequestHandler。不过由于IPort< T>支持协变，于是IPort< Crawler>被安全地转换成了IPort< ICrawlerRequestHandler>对象。

第二行中再次发生了协变：ICrawlRequestHandler.Crawel的第一个参数需要IPort< ICrawlResponseHandler>类型的对象，但是this是Monitor类型的，它并没有实现这个接口。不过，和上面描述的一样，由于IPort< T>支持协变，因此这样的类型转化是安全的，允许的。于是在Crawler类便可以操作一个“抽象”，而不是具体的Monitor类型来办事了。

神奇不？但就是这么简单。

“内部”消息控制
在上一篇文章中，我们还提出了Crawler实现的另一个缺点：没有使用异步IO。WebClient本身的DownloadStringAsync方法可以进行异步下载，但是如果在异步完成的后续操作（如分析链接）会在IO线程池中运行，这样我们就很难对任务所分配的运算能力进行控制。我们当时提出，可以把后续操作作为消息发送给Crawler本身，也就是进行“内部”消息控制——可惜的是，我们当时无法做到。不过现在，由于Crawler实现的是IPort< Crawler>接口，因此，我们可以把Crawler内部的任何方法作为消息传递给自身，如下：

internal class Crawler : Actor< Action< Crawler>>, IPort< Crawler>, ICrawlRequestHandler  
{  
    protected override void Receive(Action< Crawler> message) { message(this); }  
 
    #region ICrawlRequestHandler Members  
 
    public void Crawl(IPort< ICrawlResponseHandler> collector, string url)  
    {  
        WebClient client = new WebClient();  
        client.DownloadStringCompleted += (sender, e) =>  
        {  
            if (e.Error == null)  
            {  
                this.Post(c => c.Crawled(collector, url, e.Result));  
            }  
            else 
            {  
                collector.Post(c => c.Failed(this, url, e.Error));  
            }  
        };  
 
        client.DownloadStringAsync(new Uri(url));  
    }  
 
    private void Crawled(IPort< ICrawlResponseHandler> collector, string url, string content)  
    {  
        var matches = Regex.Matches(content, @"href=""(http://[^""]+)""").Cast< Match>();  
        var links = matches.Select(m => m.Groups[1].Value).Distinct().ToList();  
 
        collector.Post(c => c.Succeeded(this, url, content, links));  
    }  
 
    #endregion  
}

我们准备了一个private的Crawled方法，如果抓取成功了，我们会把这个方法的调用封装在一条消息中重新发给自身。请注意，这是个私有方法，因此这里完全是在做“内部”消息控制。

开启抓取任务
在上一篇文章中，我们为Monitor添加了一个Start方法，它的作用是启动URL。我们知道，对单个Actor来说消息的处理是线程安全的，但是这个前提是使用“消息”传递的方式进行通信，如果直接调用Start公有方法，便会破坏这种线程安全特性。不过现在的Monitor已经不受接口的限制，可以自由接受任何它可以执行的消息，因此我们只要对外暴露一个Crawl方法即可：

public class Monitor : Actor< Action< Monitor>>, IPort< Monitor>,  
    ICrawlResponseHandler,  
    IStatisticRequestHandelr  
{  
    ...  
 
    public void Crawl(string url)  
    {  
        if (this.m_allUrls.Contains(url)) return;  
        this.m_allUrls.Add(url);  
 
        if (this.WorkingCrawlerCount <  this.MaxCrawlerCount)  
        {  
            this.WorkingCrawlerCount++;  
            IPort< ICrawlRequestHandler> crawler = new Crawler();  
            crawler.Post(c => c.Crawl(this, url));  
        }  
        else 
        {  
            this.m_readyToCrawl.Enqueue(url);  
        }  
    }  
}

于是我们便可以向Monitor发送消息，让其抓取特定的URL：

string[] urls =  
{  
    "http://www.cnblogs.com/dudu/",  
    "http://www.cnblogs.com/TerryLee/",  
    "http://www.cnblogs.com/JeffreyZhao/" 
};  
 
Random random = new Random(DateTime.Now.Millisecond);  
Monitor monitor = new Monitor(10);  
foreach (var url in urls)  
{  
    var urlToCrawl = url;  
    monitor.Post(m => m.Crawl(urlToCrawl));  
    Thread.Sleep(random.Next(1000, 3000));  
}

上面的代码会每隔1到3秒发出一个抓取请求。由于我们使用了消息传递的方式进行通信，因此对于Monitor来说，这一切都是线程安全的。我们可以随时随地为Monitor添加抓取任务。

接受多种消息（协议）
我们再观察一下Monitor的签名：

class Monitor : Actor< Action< Monitor>>, IPort< Monitor>, ICrawlResponseHandler
可以发现，如今的Monitor已经和它实现的协议没有一对一的关系了。也就是说，它可以添加任意功能，可以接受任意类型的消息，我们只要让它实现另一个接口即可。于是乎，我们再要一个“查询”功能2：

public interface IStatisticRequestHandelr  
{  
    void GetCrawledCount(IPort< IStatisticResponseHandler> requester);  
    void GetContent(IPort< IStatisticResponseHandler> requester, string url);  
}  
 
public interface IStatisticResponseHandler  
{  
    void ReplyCrawledCount(int count);  
    void ReplyContent(string url, string content);  
}

为了让Monior支持查询，我们还需要为它添加这样的代码：

public class Monitor : Actor< Action< Monitor>>, IPort< Monitor>,  
    ICrawlResponseHandler,  
    IStatisticRequestHandelr  
{  
    ...  
 
    #region IStatisticRequestHandelr Members  
 
    void IStatisticRequestHandelr.GetCrawledCount(IPort< IStatisticResponseHandler> requester)  
    {  
        requester.Post(r => r.ReplyCrawledCount(this.m_urlContent.Count));  
    }  
 
    void IStatisticRequestHandelr.GetContent(IPort< IStatisticResponseHandler> requester, string url)  
    {  
        string content;  
        if (!this.m_urlContent.TryGetValue(url, out content))  
        {  
            content = null;  
        }  
 
        requester.Post(r => r.ReplyContent(url, content));  
    }  
 
    #endregion  
}

最后，我们来尝试着使用这个“查询”功能。首先，我们编写一个测试用的TestStatisticPort类：

public class TestStatisticPort : IPort< IStatisticResponseHandler>, IStatisticResponseHandler  
{  
    private IPort< IStatisticRequestHandelr> m_statisticPort;  
 
    public TestStatisticPort(IPort< IStatisticRequestHandelr> statisticPort)  
    {  
        this.m_statisticPort = statisticPort;  
    }  
 
    public void Start()  
    {  
        while (true)  
        {  
            Console.ReadLine();  
            this.m_statisticPort.Post(s => s.GetCrawledCount(this));  
        }  
    }  
 
    #region IPort< IStatisticResponseHandler> Members  
 
    void IPort< IStatisticResponseHandler>.Post(Action< IStatisticResponseHandler> message)  
    {  
        message(this);  
    }  
 
    #endregion  
 
    #region IStatisticResponseHandler Members  
 
    void IStatisticResponseHandler.ReplyCrawledCount(int count)  
    {  
        Console.WriteLine("Crawled: {0}", count);  
    }  
 
    void IStatisticResponseHandler.ReplyContent(string url, string content) { ... }  
 
    #endregion  
}

当调用Start方法时，控制台将会等待用户敲击回车键。当按下回车键时，TestStatisticPort将会向Monitor发送一个IStatisticRequestHandler.GetCrawledCount消息。Monitor回复之后，屏幕上便会显示当前已经抓取成功的URL数目。例如，我们可以编写如下的测试代码：

static void Main(string[] args)  
{  
    var monitor = new Monitor(5);  
    monitor.Post(m => m.Crawl("http://www.cnblogs.com/"));  
 
    TestStatisticPort testPort = new TestStatisticPort(monitor);  
    testPort.Start();  
}

随意敲击几下回车，结果如下：

总结
如今的做法，兼顾了强类型检查，并使用C# 4.0中的协变和逆变特性，把上一篇文章中提出的问题解决了，不知您是否理解了这些内容？只可惜，我们在C# 3.0中还没有协变和逆变。因此，我们还必须思考一个适合C# 3.0的做法。

顺便一提，由于F#不支持协变和逆变，因此本文的做法无法在F#中使用。

注1：关于协变和逆变特性，我认为脑袋兄的这篇文章讲的非常清楚——您看得头晕了？是的，刚开始了解协变和逆变，以及它们之间的嵌套规则时我也头晕，但是您在掌握之后就会发现，这的确是一个非常有用的特性。

注2：不知您是否发现，与之前internal的Crawl相关接口不同，Statistic相关接口是public的。我们在使用接口作为消息时，也可以通过这种办法来控制哪些消息是可以对外暴露的。这也算是一种额外的收获吧。

【编辑推荐】