深入分析C#异步编程详解

using system;
 namespace consoleapplication1
 {
     class class1
     {
         //声明委托
         public delegate void asynceventhandler();

         //异步方法
         void event1()
        {
            console.writeline("event1 start");
            system.threading.thread.sleep(4000);
            console.writeline("event1 end");
        }
        // 同步方法
        void event2()
        {
            console.writeline("event2 start");
            int i=1;
            while(i<1000)
            {
                i=i+1;
                console.writeline("event2 "+i.tostring());
            }
            console.writeline("event2 end");
        }
        [stathread]
        static void main(string[] args)
        {
            long start=0;
            long end=0;
            class1 c = new class1();
            console.writeline("ready");
            start=datetime.now.ticks;
            //实例委托
            asynceventhandler asy = new asynceventhandler(c.event1);
            //异步调用开始，没有回调函数和asyncstate,都为null
            iasyncresult ia = asy.begininvoke(null, null);
            //同步开始，
            c.event2();
            //异步结束，若没有结束，一直阻塞到调用完成，在此返回该函数的return，若有返回值。

            asy.endinvoke(ia);
            //都同步的情况。
            //c.event1();
            //c.event2();

            end =datetime.now.ticks;
            console.writeline("时间刻度差="+ convert.tostring(end-start) );
            console.readline();
        }
    }
}

using system;
using system.net;
using system.threading;
using system.text;
using system.io;
// requeststate 类用于通过
// 异步调用传递数据
public class requeststate
{
    const int buffer_size = 1024;
    public stringbuilder requestdata;
    public byte[] bufferread;
    public httpwebrequest request;
    public stream responsestream;
    // 创建适当编码类型的解码器
    public decoder streamdecode = encoding.utf8.getdecoder();
    public requeststate()
    {
        bufferread = new byte[buffer_size];
        requestdata = new stringbuilder("");
        request = null;
        responsestream = null;
    }
}
// clientgetasync 发出异步请求
class clientgetasync
{
    public static manualresetevent alldone = new manualresetevent(false);
    const int buffer_size = 1024;
    public static void main(string[] args)
    {
        if (args.length < 1)
        {
            showusage();
            return;
        }
        // 从命令行获取 uri
        uri httpsite = new uri(args[0]);
        // 创建请求对象
        httpwebrequest wreq = (httpwebrequest)webrequest.create(httpsite);
        // 创建状态对象
        requeststate rs = new requeststate();
        // 将请求添加到状态，以便它可以被来回传递
        rs.request = wreq;
        // 发出异步请求
        iasyncresult r = (iasyncresult)wreq.begingetresponse(new asynccallback(respcallback), rs);
        // 将 manualresetevent 设置为 wait，
        // 以便在调用回调前，应用程序不退出
        alldone.waitone();
    }
    public static void showusage()
    {
        console.writeline("尝试获取 (get) 一个 url");
        console.writeline("\r\n用法：:");
        console.writeline("clientgetasync url");
        console.writeline("示例：:");
        console.writeline("clientgetasync http://www.51sjk.com/Upload/Articles/1/0/291/291745_20210728120058282.jpg");
    }
    private static void respcallback(iasyncresult ar)
    {
        // 从异步结果获取 requeststate 对象
        requeststate rs = (requeststate)ar.asyncstate;
        // 从 requeststate 获取 httpwebrequest
        httpwebrequest req = rs.request;
        // 调用 endgetresponse 生成 httpwebresponse 对象
        // 该对象来自上面发出的请求
        httpwebresponse resp = (httpwebresponse)req.endgetresponse(ar);
        // 既然我们拥有了响应，就该从
        // 响应流开始读取数据了
        stream responsestream = resp.getresponsestream();
        // 该读取操作也使用异步完成，所以我们
        // 将要以 requeststate 存储流
        rs.responsestream = responsestream;
        // 请注意，rs.bufferread 被传入到 beginread。
        // 这是数据将被读入的位置。
        iasyncresult iarread = responsestream.beginread(rs.bufferread, 0, buffer_size, new asynccallback(readcallback), rs);
    }
    private static void readcallback(iasyncresult asyncresult)
    {
        // 从 asyncresult 获取 requeststate 对象
        requeststate rs = (requeststate)asyncresult.asyncstate;
        // 取出在 respcallback 中设置的 responsestream
        stream responsestream = rs.responsestream;
        // 此时 rs.bufferread 中应该有一些数据。
        // 读取操作将告诉我们那里是否有数据
        int read = responsestream.endread(asyncresult);
        if (read > 0)
        {
            // 准备 char 数组缓冲区，用于向 unicode 转换
            char[] charbuffer = new char[buffer_size];
            // 将字节流转换为 char 数组，然后转换为字符串
            // len 显示多少字符被转换为 unicode
            int len = rs.streamdecode.getchars(rs.bufferread, 0, read, charbuffer, 0);
            string str = new string(charbuffer, 0, len);
            // 将最近读取的数据追加到 requestdata stringbuilder 对象中，
            // 该对象包含在 requeststate 中
            rs.requestdata.append(str);
            // 现在发出另一个异步调用，读取更多的数据
            // 请注意，将不断调用此过程，直到
            // responsestream.endread 返回 -1
            iasyncresult ar = responsestream.beginread(rs.bufferread, 0, buffer_size, new asynccallback(readcallback), rs);
        }
        else
        {
            if (rs.requestdata.length > 1)
            {
                // 所有数据都已被读取，因此将其显示到控制台
                string strcontent;
                strcontent = rs.requestdata.tostring();
                console.writeline(strcontent);
            }
            // 关闭响应流
            responsestream.close();
            // 设置 manualresetevent，以便主线程可以退出
            alldone.set();
        }
        return;
    }
}