C# 异步编程1 APM模式异步程序开发

最新推荐文章于 2024-08-20 14:38:27 发布
最新推荐文章于 2024-08-20 14:38:27 发布
阅读量613 收藏 2
点赞数

C#已有10多年历史，单从微软2年一版的更新进度来看活力异常旺盛，C#中的异步编程也经历了多个版本的演化，从今天起着手写一个系列博文，记录一下C#中的异步编程的发展历程。广告一下：喜欢我文章的朋友，请点下面的“关注我”。谢谢

我是2004年接触并使用C#的，那时C#版本为1.1，所以我们就从就那个时候谈起。那时后在大学里自己看书写程序，所写的程序大都是同步程序，最多启动个线程........其实在C#1.1的时代已有完整的异步编程解决方案，那就是APM（异步编程模型）。如果还有不了解“同步程序、异步程序”的请自行百度哦。

APM异步编程模型最具代表性的特点是：一个异步功能由以Begin开头、End开头的两个方法组成。Begin开头的方法表示启动异步功能的执行，End开头的方法表示等待异步功能执行结束并返回执行结果。下面是一个模拟的实现方式（后面将编写标准的APM模型异步实现）：

public class Worker
    {
        public int A { get; set; }
        public int B { get; set; }
        private int R { get; set; }
        ManualResetEvent et;
        public void BeginWork(Action action)
        {
            et = new ManualResetEvent(false);
            new Thread(() =>
            {
                R = A + B;
                Thread.Sleep(1000);
                et.Set();
                if(null != action)
                {
                    action();
                }
            }).Start();
        }

        public int EndWork()
        {
            if(null == et)
            {
                throw new Exception("调用EndWork前，需要先调用BeginWork");
            }
            else
            {
                et.WaitOne();
                return R;
            }

        } 
    }
        static void Main(string[] args)
        {
           Worker w = new Worker();
            w.BeginWork(()=> {
                Console.WriteLine("Thread Id:{0},Count:{1}", Thread.CurrentThread.ManagedThreadId,
                    w.EndWork());
            });
            Console.WriteLine("Thread Id:{0}", Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

在上面的模拟APM模型中我们使用了 Thread、ManualResetEvent，如果你对多线程和ManualResetEvent不熟悉，请阅读我之前的Blog《C#多线程的用法系列-线程间的协作ManualResetEvent》。C#中使用异步编程不可避免的会涉及到多线程的知识，虽然微软在Framework中做了很多封装，但朋友们应该掌握其本质。

上面模拟的APM异步模型之所以简单，是因为C#发展过程中引入了很多优秀的语法规则。上例我们较多的使用了Lambda表达式，如果你不熟悉 匿名委托与lambda表达式可看我之前的Bolg《匿名委托与Lambda表达式》。上面做了如此多的广告，下面我们来看一下标准的APM模型如何实现异步编程。

IAsyncResult接口

IAsyncResult接口定义了异步功能的状态，该接口具体属性及含义如下：

   //     表示异步操作的状态。
    [ComVisible(true)]
    public interface IAsyncResult
    {
        //
        // 摘要:
        //     获取一个值，该值指示异步操作是否已完成。
        //
        // 返回结果:
        //     如果操作已完成，则为 true；否则为 false。
        bool IsCompleted { get; }
        //
        // 摘要:
        //     获取用于等待异步操作完成的 System.Threading.WaitHandle。
        //
        // 返回结果:
        //     用于等待异步操作完成的 System.Threading.WaitHandle。
        WaitHandle AsyncWaitHandle { get; }
        //
        // 摘要:
        //     获取一个用户定义的对象，该对象限定或包含有关异步操作的信息。
        //
        // 返回结果:
        //     一个用户定义的对象，限定或包含有关异步操作的信息。
        object AsyncState { get; }
        //
        // 摘要:
        //     获取一个值，该值指示异步操作是否同步完成。
        //
        // 返回结果:
        //     如果异步操作同步完成，则为 true；否则为 false。
        bool CompletedSynchronously { get; }
    }
注意：模型示例1中的 ManualResetEvent 继承自 WaitHandle
APM传说实现方式
在了解了IAsyncResult接口后，我们来通过实现 IAsyncResult 接口的方式完成对模拟示例的改写工作，代码如下：
    public class NewWorker
    {
        public class WorkerAsyncResult : IAsyncResult
        {
            AsyncCallback callback;
            public WorkerAsyncResult(int a,int b, AsyncCallback callback, object asyncState) {
                A = a;
                B = b;
                state = asyncState;
                this.callback = callback;
                new Thread(Count).Start(this);
            }
            public int A { get; set; }
            public int B { get; set; }

            public int R { get; private set; }

            private object state;
            public object AsyncState
            {
                get
                {
                    return state;
                }
            }
            private ManualResetEvent waitHandle;
            public WaitHandle AsyncWaitHandle
            {
                get
                {
                    if (null == waitHandle)
                    {
                        waitHandle = new ManualResetEvent(false);
                    }
                    return waitHandle;
                }
            }
            private bool completedSynchronously;
            public bool CompletedSynchronously
            {
                get
                {
                    return completedSynchronously;
                }
            }
            private bool isCompleted;
            public bool IsCompleted
            {
                get
                {
                    return isCompleted;
                }
            }
            private static void Count(object state)
            {
                var result = state as WorkerAsyncResult;
                result.R = result.A + result.B;
                Thread.Sleep(1000);
                result.completedSynchronously = false;
                result.isCompleted = true;
                ((ManualResetEvent)result.AsyncWaitHandle).Set();
                if (result.callback != null)
                {
                    result.callback(result);
                }
            }
        }
        public int Num1 { get; set; }
        public int Num2 { get; set; }

        public IAsyncResult BeginWork(AsyncCallback userCallback, object asyncState)
        {
            IAsyncResult result = new WorkerAsyncResult(Num1,Num2,userCallback, asyncState);
            return result;
        }

        public int EndWork(IAsyncResult result)
        {
            WorkerAsyncResult r = result as WorkerAsyncResult;
            r.AsyncWaitHandle.WaitOne();
            return r.R;
        }
    }

示例代码分析：

上面代码中NewWorker的内部类 WorkerAsyncResult 是关键点，它实现了 IAsyncResult 接口并由它来负责开启新线程完成计算工作。

在WorkerAsyncResult中增加了 A、B两个私有属性来存储用于计算的数值，一个对外可读不可写的属性R，用于存储WorkerAsyncResult内部运算的结果。AsyncWaitHandle属性由 ManualResetEvent 来充当，并在首次访问时创建ManualResetEvent（但不释放）。其他接口属性正常实现，没有什么可说。

WorkerAsyncResult 中新增 static Count 方法，参数 state 为调用Count方法的当前WorkerAsyncResult对象。Count 方法在 WorkerAsyncResult 对象的新启线程中运行，因此Thread.Sleep(1000)将阻塞新线程1秒中。然后设置当前WorkerAsyncResult对象是否同步完成为false，异步完成状态为true，释放ManualResetEvent通知以便等待线程获取通知进入执行状态，判断是否有异步执行结束回调委托，存在则回调之。

NewWorker 非常简单，Num1、Num2两个属性为要计算的数值。BeginWork 创建WorkerAsyncResult对象、并将要计算的两个数值Num1、Num2、userCallback回调委托、object 类型的 asyncState 传入要创建的WorkerAsyncResult对象。经过此步操作，WorkerAsyncResult对象获取了运算所需的所有数据、运算完成后的回调，并马上启动新线程进行运算（执行WorkerAsyncResult.Count方法）。

因为WorkerAsyncResult.Count执行在新线程中，在该线程外部无法准确获知新线程的状态。为了满足外部线程与新线程同步的需求，在NewWorker中增加EndWork方法，参数类型为IAsyncResult。要调用EndWork方法应传入BeginWork 获取的WorkerAsyncResult对象，EndWork方法获取WorkerAsyncResult对象后，调用WorkerAsyncResult.AsyncWaitHandle.WaitOne()方法，等待获取ManualResetEvent通知，在获取到通知时运算线程已运算结束（线程并未结束），下一步获取运算结果R并返回。

接下来是NewWorker调用程序，如下：

        static void Main(string[] args)
        {
            NewWorker w2 = new NewWorker();
            w2.Num1 = 10;
            w2.Num2 = 12;
            IAsyncResult r = null;
            r = w2.BeginWork((obj) => {
            Console.WriteLine("Thread Id:{0},Count:{1}",Thread.CurrentThread.ManagedThreadId,
            w2.EndWork(r));
            }, null);
            Console.WriteLine("Thread Id:{0}", Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

下图我简单画的程序调用过程，有助于各位朋友理解：

标准的APM模型异步编程，对应开发人员来说过于复杂。因此通过实现 IAsyncResult 接口进行异步编程，就是传说中的中看不中用（罪过罪过.....）。

Delegate异步编程（APM 标准实现）

C#中委托天生支持异步调用（APM模型），任何委托对象后"."就会发现BeginInvoke、EndInvoke、Invoke三个方法。BeginInvoke为异步方式调用委托、EndInvoke等待委托的异步调用结束、Invoke同步方式调用委托。因此上面的标准APM实例，可借助  delegate 进行如下简化。

上面NewWorker使用委托方式改写如下：

    public class NewWorker2
    {
        Func<int, int, int> action;
        public NewWorker2()
        {
            action = new Func<int, int, int>(Work);
        }
        public IAsyncResult BeginWork(AsyncCallback callback, object state)
        {
            dynamic obj = state;
            return action.BeginInvoke(obj.A, obj.B, callback, this);
        }

        public int EndWork(IAsyncResult asyncResult)
        {
            try
            {
                return action.EndInvoke(asyncResult);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        private int Work(int a, int b)
        {
            Thread.Sleep(1000);
            return a + b;
        }
    }

调用程序：

        static void Main(string[] args)
        {
            NewWorker2 w2 = new NewWorker2();
            IAsyncResult r = null;
            r = w2.BeginWork((obj) =>
            {
                Console.WriteLine("Thread Id:{0},Count:{1}", Thread.CurrentThread.ManagedThreadId,
                    w2.EndWork(r));
            }, new { A = 10, B = 11 });
            Console.WriteLine("Thread Id:{0}", Thread.CurrentThread.ManagedThreadId);

            Console.ReadLine();
        }

上面的使用委托进行APM异步编程，比实现 IAsyncResult 接口的方式精简太多、更易理解使用。因此这里建议朋友们 delegate 异步调用模型应该掌握起来，而通过实现 IAsyncResult 接口的传说方式看你的喜好吧。

同时上面的delegate中我们还用了一些委托、匿名对象、动态类型等知识，如果你感兴趣的话都可从我的Blog中找到相关知识供你参考。

最后再广告一次：喜欢我文章的朋友请关注一下我的blog，谢谢。

 

nginxs
关注
C#：异步编程
子昊
06-15 2071
异步操作表示执行某项操作之后不等待操作结束，但可以在操作结束后收到通知。示例： 示例是一个调用阻塞操作的例子。tcp连接的方法就是一个阻塞操作，只有连接成功或是失败的时候才会回复。发送数据也是同样的。线程阻塞的时候操作系统会调度这些执行操作的线程进入等待状态，等到操作完成后再重新把线程放入待运行队列中并调度执行。这种方式会出现一个问题，如果我们要同时管理多个tcp连接，那么我们就需要创建很多的线程，每个线程分配的栈空间加起来就会消耗很多的内存。在linux平台下，一个线程栈会默认分配8~10M的空间，也
C#异步编程案例学习——异步加载大资源文件1 之 使用 BeginInvoke 与 EndInvoke
SQWH_SSGS的博客
11-10 1004
在使用 WPF 开发桌面软件过程中，遇到一个需要预加载大量文件的需求，具体需求如下： 在软件启动后，需要加载大量的 CAD 资源文件，文件供软件中后续使用。 文件加载过程中非常耗时，若同步加载则界面会出现假死的状态。 在文件加载过程中，需要保证界面仍然可以进行其他操作。 解决方案： 在软件启动后，软件页面正常完成加载后，后台继续进行异步加载资源文件，此时可操作正在加载的资源文件的按钮设置为不可操作。文件加载完成之后开发操作资源文件的按钮可操作。 具体实现如下： 1、WPF 页面 Window 中存在一个
C# --- 异步编程（Async/Await）
最新发布
qq_53839898的博客
08-20 949
异步编程（Async/Await）
C# 异步编程
绿龙术士的专栏
03-21 1390
使用异步编程，方法调用时在后台运行，并且不会阻塞调用线程。 异步编程模型Async Patterns Model(APM) 异步模式定义了BeginXXX和EndXXX方法。BeginXXX方法接受其同步方法的所有输入参数，EndXXX方法使用同步方法的所有输出参数，并按照同步方法的返回类型来返回结果。 //异步模式定义了BeginXXX和EndXXX方法 ...
C#异步编程-------异步编程模型（APM）
sinolover的专栏
02-22 1034
术语解释： APM异步编程模型，Asynchronous Programming Model EAP基于事件的异步编程模式，Event-based Asynchronous Pattern TAP基于任务的异步编程模式，Task-based Asynchronous Pattern 一...
C# APM 异步编程例子
Gylianger的专栏
01-28 1040
APM异步回调模型   /// /// 异步执行方法 /// /// public void AsyncSend(string name) { Func func = SayHi; func.BeginInvoke(name, new AsyncCallback(C
异步编程_C#_异步编程_
10-04
在C#编程中，异步编程是一种至关...通过学习这些知识点，开发者能更好地理解和运用C#异步编程，编写出高性能、响应快速的应用程序。同时，阅读《异步编程.pdf》这份文档，将有助于深入理解这些概念并掌握实际应用技巧。
Task C# 异步编程模式，实例分享
06-13
Task类位于System.Threading.Tasks命名空间中，它是C#异步编程的核心。Task对象表示一个执行中的工作单元，可以是一个方法调用或一组计算。Task提供了异步操作的状态管理，包括开始、运行、完成等状态，并且可以通过...
C#_5.0新特性：Async和Await使异步编程更简单.pdf
06-02
在C#5.0之前，.NET提供了基于事件和回调的异步编程模型（APM）和基于任务的异步编程模型（TAP）。APM模型涉及到使用异步模式和IAsyncResult接口，而TAP则是通过使用Task和Task类来实现的。这些模型虽然比完全同步的...
c#异步编程
2303_77666647的博客
11-09 236
调用begininvoke是从线程池中调出一个线程来执行委托的方法，有三个参数包括引用的目标方法的参数类型（想要得到返回的参数使用IAsyncResult方法得到），一个是回调，一个是state；进程-------主线程UI。利用Timer，其中Timer的第一个参数是回调方法，第二个参数是传入的参数，第三个参数是第一次任务开始执行的时间，第四个参数是每次执行时间间隔。异步编程:当一个程序没有运行完成的时候先去执行另外一个进程，当那个进程执行完毕以后，再回到未执行完的程序的原位置继续完成未完成的操作。
C#之异步编程
weixin_30421525的博客
04-24 77
　　使用异步编程，方法调用是在后台运行（通常在线程和任务的帮助下），并且不会阻塞调用线程。 　　异步编程有三种模式：异步模式，基于事件的异步模式和基于任务的异步模式（TAP）。一.异步模式 　　从.NET 1.0开始 .NET Framework就提供了异步特性，.NET Framework的许多类（但不是全部类）都实现了一个或多个异步模式，自定义类可以通过委托类型实现异步模式。 　　.NET ...
C#异步编程
万事胜意
04-18 674
异步编程并行和异步编程预备知识任务Lambda表达式Action和Func委托元组（Tuple类）异步编程基本技术异步编程的实现方式异步操作关键字创建任务取消或终止任务的执行获取任务执行的状态报告任务执行的进度C#网络编程学不会呜呜呜 并行和异步编程预备知识 任务 任务(Task) 表示一个异步操作。任务运行的时候需要使用线程，通用语言运行时（CLR）会创建必要的线程来支持任务执行的需求。 1．T...
c# 异步编程
一个记录自己技术成长的博客
11-23 182
20191123 今天学了一些关于异步编程的知识点，现总结记录以下关键点： 1、报告进度 在异步操作过程，展示操作的进度 使用IProgress<T>和Progress<T>。在async方法里传入IProgress<T>，其中T是需要报告的进度类型。 注意：由于IProgress<T>.Report方法是可以移步的，意味着报告进度之前，异...
.NET异步编程：四种模式详解及代码示例
本文将概述四种常见的异步编程模式，并通过C#代码示例进行解释。这四种方法可以大致分为两类：基于“等待”的方法和基于“回调”的方法。 1. BeginInvoke/EndInvoke方法（等待类） 这是.NET中最传统的异步编程模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值