C#编程总结(六)详解异步编程

1、什么是异步?

异步操作通常用于执行完成时间可能较长的任务,如打开大文件、连接远程计算机或查询数据库。异步操作在主应用程序线程以外的线程中执行。应用程序调用方法异步执行某个操作时,应用程序可在异步方法执行其任务时继续执行。

2、同步与异步的区别

同步(Synchronous):在执行某个操作时,应用程序必须等待该操作执行完成后才能继续执行。

异步(Asynchronous):在执行某个操作时,应用程序可在异步操作执行时继续执行。实质:异步操作,启动了新的线程,主线程与方法线程并行执行。

3、异步和多线程的区别   

我们已经知道,异步的实质是开启了新的线程。它与多线程的区别是什么呢?

简单的说就是:异步线程是由线程池负责管理,而多线程,我们可以自己控制,当然在多线程中我们也可以使用线程池。

就拿网络扒虫而言,如果使用异步模式去实现,它使用线程池进行管理。异步操作执行时,会将操作丢给线程池中的某个工作线程来完成。当开始I/O操作的时候,异步会将工作线程还给线程池,这意味着获取网页的工作不会再占用任何CPU资源了。直到异步完成,即获取网页完毕,异步才会通过回调的方式通知线程池。可见,异步模式借助于线程池,极大地节约了CPU的资源。

注:DMA(Direct Memory Access)直接内存存取,顾名思义DMA功能就是让设备可以绕过处理器,直接由内存来读取资料。通过直接内存访问的数据交换几乎可以不损耗CPU的资源。在硬件中,硬盘、网卡、声卡、显卡等都有直接内存访问功能。异步编程模型就是让我们充分利用硬件的直接内存访问功能来释放CPU的压力。

两者的应用场景:

计算密集型工作,采用多线程。

IO密集型工作,采用异步机制。

4、异步应用

.NET Framework 的许多方面都支持异步编程功能,这些方面包括:

      1)文件 IO、流 IO、套接字 IO。

      2)网络。

      3)远程处理信道(HTTP、TCP)和代理。

      4)使用 ASP.NET 创建的 XML Web services。

      5)ASP.NET Web 窗体。

      6)使用 MessageQueue 类的消息队列。

.NET Framework 为异步操作提供两种设计模式:

      1)使用 IAsyncResult 对象的异步操作。

      2)使用事件的异步操作。

IAsyncResult 设计模式允许多种编程模型,但更加复杂不易学习,可提供大多数应用程序都不要求的灵活性。可能的话,类库设计者应使用事件驱动模型实现异步方法。在某些情况下,库设计者还应实现基于 IAsyncResult 的模型。

使用 IAsyncResult 设计模式的异步操作是通过名为 Begin操作名称和End操作名称的两个方法来实现的,这两个方法分别开始和结束异步操作操作名称。例如,FileStream 类提供 BeginRead 和 EndRead 方法来从文件异步读取字节。这两个方法实现了 Read 方法的异步版本。在调用 Begin操作名称后,应用程序可以继续在调用线程上执行指令,同时异步操作在另一个线程上执行。每次调用 Begin操作名称 时,应用程序还应调用 End操作名称来获取操作的结果。Begin操作名称 方法开始异步操作操作名称并返回一个实现 IAsyncResult 接口的对象。 .NET Framework 允许您异步调用任何方法。定义与您需要调用的方法具有相同签名的委托;公共语言运行库将自动为该委托定义具有适当签名的 BeginInvoke 和 EndInvoke 方法。  

IAsyncResult 对象存储有关异步操作的信息。下表提供了有关异步操作的信息。

名称        

说明

AsyncState

获取用户定义的对象,它限定或包含关于异步操作的信息。

AsyncWaitHandle

获取用于等待异步操作完成的 WaitHandle。

CompletedSynchronously

获取一个值,该值指示异步操作是否同步完成。

IsCompleted

获取一个值,该值指示异步操作是否已完

5、应用实例

案例1-读取文件

通常读取文件是一个比较耗时的工作,特别是读取大文件的时候,常见的上传和下载。但是我们又不想让用户一直等待,用户同样可以进行其他操作,可以使得系统有良好的交互性。这里我们写了同步调用和异步调用来进行比较说明。

读取文件类

using System;
using System.IO;
using System.Threading;

namespace AsynSample
{
  class FileReader
  {
    /// <summary>
    /// 缓存池
    /// </summary>
    private byte[] Buffer { get; set; }
    /// <summary>
    /// 缓存区大小
    /// </summary>
    public int BufferSize { get; set; }

    public FileReader(int bufferSize)
    {
      this.BufferSize = bufferSize;
      this.Buffer = new byte[BufferSize];
    }

    /// <summary>
    /// 同步读取文件
    /// </summary>
    /// <param name="path">文件路径</param>
    public void SynsReadFile(string path)
    {
      Console.WriteLine("同步读取文件 begin");
      using (FileStream fs = new FileStream(path, FileMode.Open))
      {        
        fs.Read(Buffer, 0, BufferSize);
        string output = System.Text.Encoding.UTF8.GetString(Buffer);
        Console.WriteLine("读取的文件信息:{0}",output);
      }
      
      Console.WriteLine("同步读取文件 end");
    }
    /// <summary>
    /// 异步读取文件
    /// </summary>
    /// <param name="path"></param>
    public void AsynReadFile(string path)
    {
      Console.WriteLine("异步读取文件 begin");
      //执行Endread时报错,fs已经释放,注意在异步中不能使用释放需要的资源
      //using (FileStream fs = new FileStream(path, FileMode.Open))
      //{
      //  Buffer = new byte[BufferSize];
      //  fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);
      //} 
      if (File.Exists(path))
      {
        FileStream fs = new FileStream(path, FileMode.Open);
        fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);
      }
      else
      {
        Console.WriteLine("该文件不存在");
      }

    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="ar"></param>
    void AsyncReadCallback(IAsyncResult ar)
    {
      FileStream stream = ar.AsyncState as FileStream;
      if (stream != null)
      {
        Thread.Sleep(1000);
        //读取结束
        stream.EndRead(ar);
        stream.Close();

        string output = System.Text.Encoding.UTF8.GetString(this.Buffer);
        Console.WriteLine("读取的文件信息:{0}", output);
      }
    }
  }
}

测试用例

using System;
using System.Threading;

namespace AsynSample
{
  class Program
  {
    static void Main(string[] args)
    {
      FileReader reader = new FileReader(1024);

      //改为自己的文件路径
      string path = "C:\\Windows\\DAI.log";

      Console.WriteLine("开始读取文件了...");
      //reader.SynsReadFile(path);

      reader.AsynReadFile(path);

      Console.WriteLine("我这里还有一大滩事呢.");
      DoSomething();
      Console.WriteLine("终于完事了,输入任意键,歇着!");
      Console.ReadKey();      
    }
    /// <summary>
    /// 
    /// </summary>
    static void DoSomething()
    {
      Thread.Sleep(1000);
      for (int i = 0; i < 10000; i++)
      {
        if (i % 888 == 0)
        {
          Console.WriteLine("888的倍数:{0}",i);
        }
      }
    }
  }
}

输出结果:

同步输出:


异步输出:


结果分析:

如果是同步读取,在读取时,当前线程读取文件,只能等到读取完毕,才能执行以下的操作

而异步读取,是创建了新的线程,读取文件,而主线程,继续执行。我们可以开启任务管理器来进行监视。

案例二--基于委托的异步操作

系统自带一些类具有异步调用方式,如何使得自定义对象也具有异步功能呢?

我们可以借助委托来轻松实现异步。

说到BeginInvoke,EndInvoke就不得不停下来看一下委托的本质。为了便于理解委托,我定义一个简单的委托:

public delegate string MyFunc(int num, DateTime dt);

我们再来看一下这个委托在编译后的程序集中是个什么样的:

委托被编译成一个新的类型,拥有BeginInvoke,EndInvoke,Invoke这三个方法。前二个方法的组合使用便可实现异步调用。第三个方法将以同步的方式调用。 其中BeginInvoke方法的最后二个参数用于回调,其它参数则与委托的包装方法的输入参数是匹配的。 EndInvoke的返回值与委托的包装方法的返回值匹配。

异步实现文件下载:

using System;
using System.Text;

namespace AsynSample
{
  /// <summary>
  /// 下载委托
  /// </summary>
  /// <param name="fileName"></param>
  public delegate string AysnDownloadDelegate(string fileName);
  /// <summary>
  /// 通过委托实现异步调用
  /// </summary>
  class DownloadFile
  {
    /// <summary>
    /// 同步下载
    /// </summary>
    /// <param name="fileName"></param>
    public string Downloading(string fileName)
    {
      string filestr = string.Empty;
      Console.WriteLine("下载事件开始执行");
      System.Threading.Thread.Sleep(3000);
      Random rand = new Random();
      StringBuilder builder =new StringBuilder();
      int num;
      for(int i=0;i<100;i++)
      {
        num = rand.Next(1000);
        builder.Append(i);
      }
      filestr = builder.ToString();
      Console.WriteLine("下载事件执行结束");

      return filestr;
    }
    /// <summary>
    /// 异步下载
    /// </summary>
    public IAsyncResult BeginDownloading(string fileName)
    {
      string fileStr = string.Empty;
      AysnDownloadDelegate downloadDelegate = new AysnDownloadDelegate(Downloading);
      return downloadDelegate.BeginInvoke(fileName, Downloaded, downloadDelegate);
    }
    /// <summary>
    /// 异步下载完成后事件
    /// </summary>
    /// <param name="result"></param>
    private void Downloaded(IAsyncResult result)
    {
      AysnDownloadDelegate aysnDelegate = result.AsyncState as AysnDownloadDelegate;
      if (aysnDelegate != null)
      {
        string fileStr = aysnDelegate.EndInvoke(result);
        if (!string.IsNullOrEmpty(fileStr))
        {
          Console.WriteLine("下载文件:{0}", fileStr);
        }
        else
        {
          Console.WriteLine("下载数据为空!");
        }
      }
      else
      {
        Console.WriteLine("下载数据为空!");
      }
    }
  }
}


通过案例,我们发现,使用委托能够很轻易的实现异步。这样,我们就可以自定义自己的异步操作了。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持菜鸟教程(cainiaojc.com)。

声明:本文内容来源于网络,版权归原作者所有,内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:notice#cainiaojc.com(发邮件时,请将#更换为@)进行举报,并提供相关证据,一经查实,本站将立刻删除涉嫌侵权内容。