.NET1.0版本中的异步编程模型(APM)

// 从文件流中读取字节块并将该数据写入给定的字节数组中
public override int Read(byte[] array, int offset, int count )

// 开始异步读操作
// 前面的3个参数和同步方法代表的意思一样，这里就不说了，可以看到这里多出了2个参数
// userCallback代表当异步IO操作完成时，你希望由一个线程池线程执行的方法,该方法必须匹配AsyncCallback委托
// stateObject代表你希望转发给回调方法的一个对象的引用，在回调方法中，可以查询IAsyncResult接口的AsyncState属性来访问该对象
public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback userCallback, Object stateObject)

// 摘要:  等待挂起的异步读取完成。
// asyncResult:对要完成的挂起异步请求的引用。
// 返回结果: 从流中读取的字节数.
public virtual int EndRead(IAsyncResult asyncResult);

private static void Main(string[] args)
{
    string downUrl = "http://download.microsoft.com/download/5/B/9/5B924336-AA5D-4903-95A0-56C6336E32C9/TAP.docx";
    DownLoadFileSync(downUrl);  //同步下载文件，在下载操作完成之后我们才可以看到"Start DownLoad File......." 消息显示
    DownloadFileAsync(downUrl); //异步下载文件，在下载操作完成之前我们就可以看到"Start DownLoad File......." 消息显示
    Console.WriteLine("开始下载文件.........");
    Console.ReadLine();
}

//同步下载文件
private static void DownLoadFileSync(string url)
{
    RequestState req = new RequestState(); // 创建一个 RequestState 实例
    try
    {
        HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(url);   // 初始化一个  HttpWebRequest 对象
        req.request = myHttpWebRequest; // 指派 HttpWebRequest实例到requestState的request字段.
        req.response = (HttpWebResponse)myHttpWebRequest.GetResponse();
        req.streamResponse = req.response.GetResponseStream();

        int readSize = req.streamResponse.Read(req.BufferRead, 0, req.BufferRead.Length);
        while (readSize > 0)
        {
            req.filestream.Write(req.BufferRead, 0, readSize);
            readSize = req.streamResponse.Read(req.BufferRead, 0, req.BufferRead.Length);
        }

        Console.WriteLine("\n此文件的长度是: {0}", req.filestream.Length);
        Console.WriteLine("下载完成，下载路径是: {0}", req.savepath);
    }
    catch (Exception e)
    {
        Console.WriteLine("错误信息:{0}", e.Message);
    }
    finally
    {
        req.response.Close();
        req.filestream.Close();
    }
}
 
//异步下载文件
private static void DownloadFileAsync(string url)
{
    try
    {
        HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(url);
        RequestState req = new RequestState();
        req.request = myHttpWebRequest;
        myHttpWebRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), req);
    }
    catch (Exception e)
    {
        Console.WriteLine("错误信息:{0}", e.Message);
    }
}

//每个异步操作完成时，将调用下面的方法
private static void ResponseCallback(IAsyncResult callbackresult)
{
    RequestState req = (RequestState)callbackresult.AsyncState; // 获取 RequestState 对象
    HttpWebRequest myHttpRequest = req.request;
    req.response = (HttpWebResponse)myHttpRequest.EndGetResponse(callbackresult); // 结束一个对英特网资源的的异步请求
    Stream responseStream = req.response.GetResponseStream(); //从服务器获取响应流
    req.streamResponse = responseStream;
    IAsyncResult asynchronousRead = responseStream.BeginRead(req.BufferRead, 0, req.BufferRead.Length, ReadCallBack, req);//异步读取流到字节数组
}

// 写字节数组到 FileStream
private static void ReadCallBack(IAsyncResult asyncResult)
{
    try
    {
        RequestState req = (RequestState)asyncResult.AsyncState; // 获取 RequestState 对象
        Stream responserStream = req.streamResponse;   //从RequestState对象中获取 Response Stream

        int readSize = responserStream.EndRead(asyncResult);
        if (readSize > 0)
        {
            req.filestream.Write(req.BufferRead, 0, readSize);
            responserStream.BeginRead(req.BufferRead, 0, req.BufferRead.Length, ReadCallBack, req);//循环调用ReadCallBack方法。
        }
        else
        {
            Console.WriteLine("\n此文件的长度是: {0}", req.filestream.Length);
            Console.WriteLine("下载完成，下载路径是: {0}", req.savepath);
            req.response.Close();
            req.filestream.Close();
        }
    }
    catch (Exception e)
    {
        Console.WriteLine("错误信息:{0}", e.Message);
    }
}

//存储请求的状态类
public class RequestState
{
    public int BufferSize = 1024;
    public string savepath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\TAP.docx";
    public byte[] BufferRead;
    public HttpWebRequest request;
    public HttpWebResponse response;
    public Stream streamResponse;
    public FileStream filestream;

    public RequestState()
    {
        BufferRead = new byte[BufferSize];
        request = null;
        streamResponse = null;
        if (File.Exists(savepath))
        {
            File.Delete(savepath);
        }
        filestream = new FileStream(savepath, FileMode.OpenOrCreate);
    }
}

// 定义用来实现异步编程的委托
private delegate string AsyncMethodCaller(string fileurl);

private void btnDownLoad_Click(object sender, EventArgs e)
{
    AsyncMethodCaller methodCaller = new AsyncMethodCaller(DownLoadFileSync);//DownLoadFileSync为同步下载文件的方法
    methodCaller.BeginInvoke(this.txbUrl.Text.Trim(), GetResult, null);
}

// 异步操作完成时执行的方法
private void GetResult(IAsyncResult result)
{
    AsyncMethodCaller caller = (AsyncMethodCaller)((AsyncResult)result).AsyncDelegate;// 或者(AsyncMethodCaller)result.AsyncState;
    string returnstring = caller.EndInvoke(result); // 调用EndInvoke去等待异步调用完成并且获得返回值,如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成

    // 然后Invoke方法来使更新GUI操作方法由GUI 线程去执行
    this.Invoke(new MethodInvoker(() =>
    {
        rtbState.Text = returnstring;
        btnDownLoad.Enabled = true;
    }));
}

private static void Main()
{
    string[] array = { "C://1.txt", "C://2.txt", "C://3.txt" };
    List<Task<string>> taskList = new List<Task<string>>(3);
    foreach (var item in array)
    {
        taskList.Add(ReadAsyc(item));
    }
    Task.Factory.ContinueWhenAll(taskList.ToArray(), i =>
    {
        string result = string.Empty;
        //获取各个task返回的结果
        foreach (var item in i)
        {
            result += item.Result;
        }
        //倒序
        String content = new String(result.OrderByDescending(j => j).ToArray());
        Console.WriteLine("倒序结果：" + content);
    });
    Console.WriteLine("我是主线程，我不会被阻塞");
    Console.ReadKey();
}

//异步读取
private static Task<string> ReadAsyc(string path)
{
    FileInfo info = new FileInfo(path);
    byte[] b = new byte[info.Length];
    FileStream fs = new FileStream(path, FileMode.Open);
    Task<int> task = Task<int>.Factory.FromAsync(fs.BeginRead, fs.EndRead, b, 0, b.Length, null, TaskCreationOptions.None);
    //返回当前task的执行结果
    return task.ContinueWith(i =>
    {
        return i.Result > 0 ? Encoding.Default.GetString(b) : string.Empty;
    }, TaskContinuationOptions.ExecuteSynchronously);
}