C# 异步和委托学习

IAsyncResult是接口:

　　IAsyncResult 异步设计模式通过名为 BeginOperationName 和 EndOperationName 的两个方法来实现原同步方法的异步调用，如 FileStream 类提供了 BeginRead 和 EndRead 方法来从文件异步读取字节，它们是 Read 方法的异步版本

Begin 方法包含同步方法签名中的任何参数，此外还包含另外两个参数：一个AsyncCallback 委托和一个用户定义的状态对象。委托用来调用回调方法，状态对象是用来向回调方法传递状态信息。该方法返回一个实现 IAsyncResult 接口的对象

End 方法用于结束异步操作并返回结果，因此包含同步方法签名中的 ref 和 out 参数，返回值类型也与同步方法相同。该方法还包括一个 IAsyncResult 参数，用于获取异步操作是否完成的信息，当然在使用时就必须传入对应的 Begin 方法返回的对象实例

开始异步操作后如果要阻止应用程序，可以直接调用 End 方法，这会阻止应用程序直到异步操作完成后再继续执行。也可以使用 IAsyncResult 的 AsyncWaitHandle 属性，调用其中的WaitOne等方法来阻塞线程。这两种方法的区别不大，只是前者必须一直等待而后者可以设置等待超时

如果不阻止应用程序，则可以通过轮循 IAsyncResult 的 IsCompleted 状态来判断操作是否完成，或使用 AsyncCallback 委托来结束异步操作。AsyncCallback 委托包含一个 IAsyncResult 的签名，回调方法内部再调用 End 方法来获取操作执行结果

//C#异步编程模式IAsyncResult之IAsyncResult 接口
public interface IAsyncResult  

{
    object AsyncState { get; }
    WaitHandle AsyncWaitHandle { get; }
    bool CompletedSynchronously { get; }
    bool IsCompleted { get; }
} 

以上是IAsyncResult 接口的属性。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace ConsoleTest
{
    public delegate int AddHandler(int a, int b);
    public class 加法类
    {
        public static int Add(int a, int b)
        {
            Console.WriteLine("开始计算：" + a + "+" + b);
            Thread.Sleep(); //模拟该方法运行三秒
            Console.WriteLine("计算完成！");
            return a + b;
        }
    }

    #region
    public class 同步调用
    {
        static void Main()
        {
            Console.WriteLine("===== 同步调用 SyncInvokeTest =====");
            AddHandler handler = new AddHandler(加法类.Add);
            int result = handler.Invoke(, );

            Console.WriteLine("继续做别的事情。。。");

            Console.WriteLine(result);
            Console.ReadKey();
        }
    }
    #endregion
}

/*运行结果：
         ===== 同步调用 SyncInvokeTest =====
         开始计算：1+2
         计算完成！
         继续做别的事情。。。
         3

*/

public delegate int AddHandler(int a, int b);
    public class 加法类
    {
        public static int Add(int a, int b)
        {
            Console.WriteLine("开始计算：" + a + "+" + b);
            Thread.Sleep(3000); //模拟该方法运行三秒
            Console.WriteLine("计算完成！");
            return a + b;
        }
    }

    #region 异步调用
    public class 异步调用
    {
        static void Main()
        {
            Console.WriteLine("===== 异步调用 AsyncInvokeTest =====");
            AddHandler handler = new AddHandler(加法类.Add);

            //IAsyncResult: 异步操作接口(interface)
            //BeginInvoke: 委托(delegate)的一个异步方法的开始
            IAsyncResult result = handler.BeginInvoke(1, 2, null, null);

            //如果在2秒内完成计算
            if (result.AsyncWaitHandle.WaitOne(2000, true))
            {
                Console.WriteLine(handler.EndInvoke(result));
                Console.WriteLine(result);
            }

            Console.WriteLine("继续做别的事情。。。");

            //异步操作返回
            Console.WriteLine(handler.EndInvoke(result));
            Console.ReadKey();
        }

运行结果:

aaarticlea/png;base64,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" alt="" />

异步回掉：

 public delegate int AddHandler(int a, int b);
    public class 加法类
    {
        public static int Add(int a, int b)
        {
            Console.WriteLine("开始计算：" + a + "+" + b);
            Thread.Sleep(); //模拟该方法运行三秒
            Console.WriteLine("计算完成！");
            return a + b;
        }
    }

    #region 异步回掉函数
    public class 异步回调
    {
        static void Main()
        {
            Console.WriteLine("===== 异步回调 AsyncInvokeTest =====");
            AddHandler handler = new AddHandler(加法类.Add);

            //异步操作接口(注意BeginInvoke方法的不同！)
            IAsyncResult result = handler.BeginInvoke(,,new AsyncCallback(回调函数),"AsycState:OK");
            //IAsyncResult result1 = handler.BeginInvoke(3, 4, new AsyncCallback(CallBackFuncation), "异步回掉完成");

            Console.WriteLine("继续做别的事情。。。");
            Console.ReadKey();
        }

        static void 回调函数(IAsyncResult result)
        {
            //result 是“加法类.Add()方法”的返回值
            //AsyncResult 是IAsyncResult接口的一个实现类，引用空间：System.Runtime.Remoting.Messaging
            //AsyncDelegate 属性可以强制转换为用户定义的委托的实际类。
            AddHandler handler = (AddHandler)((AsyncResult)result).AsyncDelegate;
            Console.WriteLine(handler.EndInvoke(result));
            Console.WriteLine(result.AsyncState);
        }

aaarticlea/png;base64,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" alt="" />

使用事件异步计算：

 public class TestFun
 {
        //模拟一个耗时计算
        static int LongTimeMethod()
        {
            int result = ;
            //Thread. Sleep(3000);
            for (int i = ; i <= ; i++)
            {
                result += i;
            }
            return result;
        }

        static void Main()
        {

            //这里用到的是.Net中定义好的委托来执行BeginInvoke
            Func<int> longTimeAction = new Func<int>(LongTimeMethod);
            IAsyncResult asynResult = longTimeAction.BeginInvoke(null, null);

            //WaitOne
            //这个对象有一个WaitOne方法，还能接受一个超时时间，它会等待这个超时时间指定的长度
            Func<int> longTimeAction1 = new Func<int>(LongTimeMethod);
            IAsyncResult asynResult1 = longTimeAction1.BeginInvoke(null, null);
            //可以继续处理别的事情
            if (asynResult1.AsyncWaitHandle.WaitOne(, true))//判断是不是结果为true，只等你10s
            {
                int result1 = longTimeAction1.EndInvoke(asynResult1);
                Console.WriteLine(result1);
            }
　　}

运行结果:

aaarticlea/png;base64,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" alt="" />

    public class TestFun
    {
    //模拟一个耗时计算
    static int LongTimeMethod()
    {
        int result = 0;
        //Thread. Sleep(3000);
        for (int i = 0; i <= 100; i++)
        {
            result += i;
        }
        return result;
    }

    static void Main()
    {
        //这里用到的是.Net中定义好的委托来执行BeginInvoke
        Func<int> longTimeAction = new Func<int>(LongTimeMethod);
        IAsyncResult asynResult = longTimeAction.BeginInvoke(null, null);

        //轮询
        while (!asynResult.IsCompleted)
        {
            //当不是true时，就执行这里的代码
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("计算还未完成,等待中....");
            Console.ForegroundColor = ConsoleColor.Yellow;
            for (int i = 1; i < 100; i++)
            {
                for (int j = i; j < 100; j++)
                {
                    int a = i, b = j;
                    Console.WriteLine("{0}*{1}={2}", a, b, a * b);
                }
            }
            Console.Clear();
        }
        int result1 = longTimeAction.EndInvoke(asynResult);//当是true时，就将结果返回显示
        Console.WriteLine("计算的结果为:" + result1);
        Console.ReadLine();
    }

运行结果:

aaarticlea/png;base64,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" alt="" />

完整代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace ConsoleTest
{
    public delegate int AddHandler(int a, int b);
    public class 加法类
    {
        public static int Add(int a, int b)
        {
            Console.WriteLine("开始计算：" + a + "+" + b);
            Thread.Sleep(); //模拟该方法运行三秒
            Console.WriteLine("计算完成！");
            return a + b;
        }
    }

    public class TestFun
    {
        //模拟一个耗时计算
        static int LongTimeMethod()
        {
            int result = ;
            //Thread. Sleep(3000);
            for (int i = ; i <= ; i++)
            {
                result += i;
            }
            return result;
        }

        static void Main()
        {

            //这里用到的是.Net中定义好的委托来执行BeginInvoke
            Func<int> longTimeAction = new Func<int>(LongTimeMethod);
            IAsyncResult asynResult = longTimeAction.BeginInvoke(null, null);

            ////WaitOne
            ////这个对象有一个WaitOne方法，还能接受一个超时时间，它会等待这个超时时间指定的长度
            //Func<int> longTimeAction1 = new Func<int>(LongTimeMethod);
            //IAsyncResult asynResult1 = longTimeAction1.BeginInvoke(null, null);
            ////可以继续处理别的事情
            //if (asynResult1.AsyncWaitHandle.WaitOne(10000, true))//判断是不是结果为true，只等你10s
            //{
            //    int result1 = longTimeAction1.EndInvoke(asynResult1);
            //    Console.WriteLine(result1);
            //}

            //回调
            Func<int> longTimeAction2 = new Func<int>(LongTimeMethod);
            //这里使用了一个lambda表达式，省了不少力啊
            IAsyncResult asynResult2 = longTimeAction.BeginInvoke((result) =>
            {
                int ret = longTimeAction.EndInvoke(result);
                Console.WriteLine(ret);
            }, null);

            //轮询
            while (!asynResult.IsCompleted)
            {
                //当不是true时，就执行这里的代码
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("计算还未完成,等待中....");
                Console.ForegroundColor = ConsoleColor.Yellow;
                for (int i = ; i < ; i++)
                {
                    for (int j = i; j < ; j++)
                    {
                        int a = i, b = j;
                        Console.WriteLine("{0}*{1}={2}", a, b, a * b);
                    }
                }
                Console.Clear();
            }
            int result1 = longTimeAction.EndInvoke(asynResult);//当是true时，就将结果返回显示
            Console.WriteLine("计算的结果为:" + result1);
            Console.ReadLine();
        }
    }

    #region 直接调用
    //public class 同步调用
    //{
    //    static void Main()
    //    {
    //        Console.WriteLine("===== 同步调用 SyncInvokeTest =====");
    //        AddHandler handler = new AddHandler(加法类.Add);
    //        int result = handler.Invoke(1, 2);

    //        Console.WriteLine("继续做别的事情。。。");

    //        Console.WriteLine(result);
    //        Console.ReadKey();
    //    }
    //    /*运行结果：
    //     ===== 同步调用 SyncInvokeTest =====
    //     开始计算：1+2
    //     计算完成！
    //     继续做别的事情。。。
    //     3       */
    //}
    #endregion
    #region 异步调用
    //public class 异步调用
    //{
    //    static void Main()
    //    {
    //        Console.WriteLine("===== 异步调用 AsyncInvokeTest =====");
    //        AddHandler handler = new AddHandler(加法类.Add);

    //        //IAsyncResult: 异步操作接口(interface)
    //        //BeginInvoke: 委托(delegate)的一个异步方法的开始
    //        IAsyncResult result = handler.BeginInvoke(1, 2, null, null);

    //        //如果在2秒内完成计算
    //        if (result.AsyncWaitHandle.WaitOne(2000, true))
    //        {
    //            Console.WriteLine(handler.EndInvoke(result));
    //            Console.WriteLine(result);
    //        }

    //        Console.WriteLine("继续做别的事情。。。");

    //        //异步操作返回
    //        Console.WriteLine(handler.EndInvoke(result));
    //        Console.ReadKey();
    //    }
    //    /*运行结果：
    //     ===== 异步调用 AsyncInvokeTest =====
    //     继续做别的事情。。。
    //     开始计算：1+2
    //     计算完成！
    //     3       */
    //}
    //#endregion

    //public class 异步回调
    //{
    //    static void Main()
    //    {
    //        Console.WriteLine("===== 异步回调 AsyncInvokeTest =====");
    //        AddHandler handler = new AddHandler(加法类.Add);

    //        //异步操作接口(注意BeginInvoke方法的不同！)
    //        IAsyncResult result = handler.BeginInvoke(1, 2, new AsyncCallback(回调函数), "AsycState:OK");
    //        //IAsyncResult result1 = handler.BeginInvoke(3, 4, new AsyncCallback(CallBackFuncation), "异步回掉完成");

    //        Console.WriteLine("继续做别的事情。。。");
    //        Console.ReadKey();
    //    }

    //    static void 回调函数(IAsyncResult result)
    //    {
    //        //result 是“加法类.Add()方法”的返回值
    //        //AsyncResult 是IAsyncResult接口的一个实现类，引用空间：System.Runtime.Remoting.Messaging
    //        //AsyncDelegate 属性可以强制转换为用户定义的委托的实际类。
    //        AddHandler handler = (AddHandler)((AsyncResult)result).AsyncDelegate;
    //        Console.WriteLine(handler.EndInvoke(result));
    //        Console.WriteLine(result.AsyncState);
    //    }
    //    /*运行结果：
    //    ===== 异步回调 AsyncInvokeTest =====
    //    开始计算：1+2
    //    继续做别的事情。。。
    //    计算完成！
    //    3
    //    AsycState:OK
    //             */

    //    static void CallBackFuncation(IAsyncResult result)
    //    {
    //        Console.WriteLine("这里是回掉函数");
    //        AddHandler handler = (AddHandler)((AsyncResult)result).AsyncDelegate;
    //        Console.WriteLine(handler.EndInvoke(result));
    //        Console.WriteLine(result.AsyncState);

    //    }
    //}
    #endregion
}