《C# 爬虫 破境之道》：第二境 爬虫应用 — 第二节：以事件驱动状态、数据处理

续上一节内容，对Web爬虫进行进一步封装，通过委托将爬虫自己的状态变化以及数据变化暴露给上层业务处理或应用程序。

为了方便以后的扩展，我先定义一个蚂蚁抽象类（Ant），并让WorkerAnt（工蚁）继承自它。

[Code 2.2.1]

 using System;

 public abstract class Ant
 {
     public UInt32 AntId { get; set; }

     public Action<Ant, JobEventArgs> OnJobStatusChanged { get; set; }

     protected virtual JobEventArgs NotifyStatusChanged(JobEventArgs args)
     {
         if (null != OnJobStatusChanged)
             OnJobStatusChanged(args.EventAnt, args);
         else
             Console.WriteLine($"Worker { args.EventAnt.AntId } JobStatus: {args.Context.JobStatus}.");

         return args;
     }
 }

蚂蚁类（Ant）

蚂蚁类比较简单，定义了一个属性（AntId），作为每只小蚂蚁的编号；

定义了一个委托（OnJobStatusChanged），当任务状态发生变化时，用来发出状态变化通知；其中第二个参数JobEventArgs我们一会列出它的定义；

在有就是定义了一个虚方法NotifyStatusChanged，用来检查和触发委托事件；

[Code 2.2.2]

 using System.ComponentModel;

 public class JobEventArgs : CancelEventArgs
 {
     public Ant EventAnt { get; set; }
     public JobContext Context { get; set; }
     public String Message { get; set; }
 }

委托参数类（JobEventArgs）

委托参数类也比较简单，

• 定义了一个属性（EventAnt），指示事件的触发者，就是编程世界中很有名气的sender，通常是object类型，不过在我们的爬虫框架里，这个事件通常是有蚂蚁触发，所以我就暂定它的类型为蚂蚁了，先把坑占上，如果以后扩展需要外部触发的话，我们再升级；
• 另一个属性（Context）就是上节中使用的JobContext，内涵与Job相关的属性、描述信息；
• 还有一个属性Message，做简单的说明，比如失败的原因是什么；

[Code 2.2.3]

 using System;
 using System.Diagnostics;
 using System.IO;
 using System.Net;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;

 /// <summary>
 /// 一个爬虫的最小任务单位，一只小工蚁。
 /// </summary>
 public class WorkerAnt : Ant
 {
     public void Work(JobContext context)
     {
         if (null == context)
         {
             context.JobStatus = TaskStatus.Faulted;
             NotifyStatusChanged(new JobEventArgs
             {
                 Context = context,
                 EventAnt = this,
                 Message = @"can not start a job with no context",
             });
             return;
         }

         switch ((context.Method ?? string.Empty))
         {
             case WebRequestMethods.Http.Connect:
             case WebRequestMethods.Http.Get:
             case WebRequestMethods.Http.Head:
             case WebRequestMethods.Http.MkCol:
             case WebRequestMethods.Http.Post:
             case WebRequestMethods.Http.Put:
                 break;
             default:
                 context.JobStatus = TaskStatus.Faulted;
                 NotifyStatusChanged(new JobEventArgs
                 {
                     Context = context,
                     EventAnt = this,
                     Message = $"can not start a job with request method <{(context.Method ?? "no method")}> is unsupported",
                 });
                 return;
         }

         if (null == context.Uri || !Uri.IsWellFormedUriString(context.Uri, UriKind.RelativeOrAbsolute))
         {
             context.JobStatus = TaskStatus.Faulted;
             NotifyStatusChanged(new JobEventArgs
             {
                 Context = context,
                 EventAnt = this,
                 Message = $"can not start a job with uri '{context.Uri}' is not well formed",
             });
             return;
         }

         context.JobStatus = TaskStatus.Created;
         if (NotifyStatusChanged(new JobEventArgs { Context = context, EventAnt = this, }).Cancel)
         {
             context.JobStatus = TaskStatus.Canceled;
             NotifyStatusChanged(new JobEventArgs { Context = context, EventAnt = this, });
             return;
         }

         /* ........... 此处省略上万字 ......... */
     }

     private void GetResponse(JobContext context)
     {
         context.Request.BeginGetResponse(new AsyncCallback(acGetResponse =>
         {
             var contextGetResponse = acGetResponse.AsyncState as JobContext;
             using (contextGetResponse.Response = contextGetResponse.Request.EndGetResponse(acGetResponse))
             using (contextGetResponse.ResponseStream = contextGetResponse.Response.GetResponseStream())
             using (contextGetResponse.Memory = new MemoryStream())
             {
                 var readCount = ;
                 if (null == contextGetResponse.Buffer) contextGetResponse.Buffer = new byte[];
                 IAsyncResult ar = null;
                 do
                 {
                     if ( < readCount)
                     {
                         contextGetResponse.Memory.Write(contextGetResponse.Buffer, , readCount);
                         contextGetResponse.JobStatus = TaskStatus.Running;
                         if (NotifyStatusChanged(new JobEventArgs { Context = contextGetResponse, EventAnt = this, }).Cancel)
                         {
                             contextGetResponse.JobStatus = TaskStatus.Canceled;
                             NotifyStatusChanged(new JobEventArgs { Context = contextGetResponse, EventAnt = this, });
                             break;
                         }
                     }
                     ar = contextGetResponse.ResponseStream.BeginRead(
                         contextGetResponse.Buffer, , contextGetResponse.Buffer.Length, null, contextGetResponse);
                 } while ( < (readCount = contextGetResponse.ResponseStream.EndRead(ar))
                 && TaskStatus.Running == contextGetResponse.JobStatus); // 与EndRead的顺序不能颠倒

                 contextGetResponse.Request.Abort();
                 contextGetResponse.Response.Close();
                 contextGetResponse.Watch.Stop();

                 if (TaskStatus.Running == contextGetResponse.JobStatus)
                 {
                     contextGetResponse.Buffer = contextGetResponse.Memory.ToArray();

                     contextGetResponse.JobStatus = TaskStatus.RanToCompletion;
                     NotifyStatusChanged(new JobEventArgs { Context = context, EventAnt = this, });
                 }
                 contextGetResponse.Buffer = null;
             }
         }), context);
     }
 }

工蚁（WorkerAnt）进行改造

工蚁类抹去了内部输出，采用状态变更通知方式向外界传递消息。

第15~57行，演示了如何处理参数异常，发出通知，并停止采集工作。

其中第27~45行，演示了如何验证一个Request Method是否有效，注意，Method需要全部大写，所以，验证方法是区分大小写的；

其中第47~57行，演示了如何验证一个Uri是否是合法的格式；

第60~65行以及82~98，演示了如何处理业务逻辑返回的'Cancel'指令，并停止采集工作；

其中第87~93行，演示了在数据下载过程中，发出状态通知，业务逻辑层或应用层可以借此机会对部分数据进行编码或更新进度条；如果下载的数据是压缩数据，也可以在此时进行解压缩工作；也可以对数据进行文件写入操作；这也将导致在业务层或应用层将收到不止一次JobStatus = TaskStatus.Runing的消息；

第104~110行，演示了如何发出的任务完成通知；

[Code 2.2.4]

 Console.WriteLine("/* ************** 第二境 * 第二节 * 以事件驱动状态、数据处理 ************** */");

 var requestDataBuilder = new StringBuilder();
 requestDataBuilder.AppendLine("using System;");
 requestDataBuilder.AppendLine("namespace HelloWorldApplication");
 requestDataBuilder.AppendLine("{");
 requestDataBuilder.AppendLine("    class HelloWorld");
 requestDataBuilder.AppendLine("    {");
 requestDataBuilder.AppendLine("        static void Main(string[] args)");
 requestDataBuilder.AppendLine("        {");
 requestDataBuilder.AppendLine("            Console.WriteLine(\"《C# 爬虫 破境之道》\");");
 requestDataBuilder.AppendLine("        }");
 requestDataBuilder.AppendLine("    }");
 requestDataBuilder.AppendLine("}");

 var requestData = Encoding.UTF8.GetBytes(
     @"code=" + System.Web.HttpUtility.UrlEncode(requestDataBuilder.ToString())
     + @"&token=4381fe197827ec87cbac9552f14ec62a&language=10&fileext=cs");

 for (int i = ; i < ; i++)
 {
     new WorkerAnt()
     {
         AntId = (uint)Math.Abs(DateTime.Now.ToString("yyyyMMddHHmmssfff").GetHashCode()),
         OnJobStatusChanged = (sender, args) =>
         {
             Console.WriteLine($"{args.EventAnt.AntId} said: {args.Context.JobName} entered status '{args.Context.JobStatus}'.");
             switch (args.Context.JobStatus)
             {
                 case TaskStatus.Created:
                     if (string.IsNullOrEmpty(args.Context.JobName))
                     {
                         Console.WriteLine($"Can not execute a job with no name.");
                         args.Cancel = true;
                     }
                     else
                         Console.WriteLine($"{args.EventAnt.AntId} said: job {args.Context.JobName} created.");
                     break;
                 case TaskStatus.Running:
                     if (null != args.Context.Memory)
                         Console.WriteLine($"{args.EventAnt.AntId} said: {args.Context.JobName} already downloaded {args.Context.Memory.Length} bytes.");
                     break;
                 case TaskStatus.RanToCompletion:
                     if (null != args.Context.Buffer &&  < args.Context.Buffer.Length)
                     {
                         Task.Factory.StartNew(oBuffer =>
                         {
                             var content = new UTF8Encoding(false).GetString((byte[])oBuffer);
                             Console.WriteLine(content.Length >  ? content.Substring(, ) + "..." : content);
                         }, new MemoryStream(args.Context.Buffer).ToArray(), TaskCreationOptions.LongRunning);
                     }
                     if (null != args.Context.Watch)
                         Console.WriteLine("/* ********************** using {0}ms / request  ******************** */"
                             + Environment.NewLine + Environment.NewLine, (args.Context.Watch.Elapsed.TotalMilliseconds / ).ToString("000.00"));
                     break;
                 case TaskStatus.Faulted:
                     Console.WriteLine($"{args.EventAnt.AntId} said: job {args.Context.JobName} faulted because {args.Message}.");
                     break;
                 case TaskStatus.WaitingToRun:
                 case TaskStatus.WaitingForChildrenToComplete:
                 case TaskStatus.Canceled:
                 case TaskStatus.WaitingForActivation:
                 default:
                     /* Do nothing on this even. */
                     break;
             }
         },
     }.Work(new JobContext
     {
         JobName = "“以事件驱动状态、数据处理”",
         Uri = @"https://tool.runoob.com/compile.php",
         ContentType = @"application/x-www-form-urlencoded; charset=UTF-8",
         Method = WebRequestMethods.Http.Post,
         Buffer = requestData,
     });
 }

应用层调用示例改造

对应用层的改造，主要体现在第25~67行，增加了对OnJobStatusChanged事件的处理。

其中，第30~38行，演示了如何在应用层或业务逻辑层，取消采集任务；

其中，第39~42行，演示了如何获取当前任务的当前已下载总量，并且可以通过context.Buffer获取当前下载的增量；如果context.Response.ContentLength不为-1的话，还可以计算出已下载量的占比；不过这里要小心的另一个陷阱就是HTTP 1.1 提供的Transfer-Encoding: Chunked；如果后面能碰到具体的场景，再举栗说明，这里先点破，不说破吧：）

其中，第43~55行，演示了如何获取下载的完整数据，注意，此时的context.Buffer是context.Memory中的所有数据，而不是当前下载的增量了。本节中所说的context.Memory是指当前Job累计下载的所有数据，为什么要加一个条件“本节所说的”呢，因为MemoryStream并不是无限大的，它也有极限，如果我们用它来处理一个Html文档或一张普通小照片还好，如果我们用它来处理一个很大的资源（比如一部蓝光电影或一个巨大的压缩包文件），将会发生异常，在那种情况下，我们就要考虑去使用文件内存映射（MemoryMappedFile）或其他技术了，暂且不在本节讨论。

至此，一个简单的事件处理机制就算是改造完成了。毕竟Web资源采集很重要，后面还会继续改造升级~敬请期待~

喜欢本系列丛书的朋友,可以点击链接加入QQ交流群(994761602)【C# 破境之道】
方便各位在有疑问的时候可以及时给我个反馈。同时，也算是给各位志同道合的朋友提供一个交流的平台。
需要源码的童鞋，也可以在群文件中获取最新源代码。