利用委托实现异步调用

Posted 2020-07-01 许明会的计算机技术主页

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了利用委托实现异步调用相关的知识，希望对你有一定的参考价值。

同步调用示例(委托是一个类型安全的,面向对象的指针)

using System;
using System.Threading;

namespace Demo
{
    public delegate int Operate(int x, int y);

    public class DelegateAsync
    {
        static int Add(int a, int b)
        {
            Console.WriteLine ("Add() invoked on thread:{0}\\n", 
                Thread.CurrentThread.GetHashCode ());
            Thread.Sleep (5000);
            return a + b;
        }

        static void Main()
        {
            Console.WriteLine ("Main() invoked on thread:{0}",
                Thread.CurrentThread.GetHashCode ());
            //Add() call in Synchronouse mode
            Operate op = new Operate (Add);
            int answer = op (10, 20);
            //after Add() executed, the folow goes on.
            Console.Write("After Add() executed, result = {0}",answer);
            Console.ReadKey ();
        }
    }
}

剖析代码的继承关系: 代理Operate经历了3次派生(绿色部分),实现了一个构造和3个虚拟函数(黄色部分).

异步调用方法:线程异步了,但是主线程等待次线程返回才能获得结果,阻塞在EndInvoke上.

using System;
using System.Threading;

namespace Demo
{
    public delegate int Operate(int x, int y);

    public class DelegateAsync
    {
        static int Add(int a, int b)
        {
            Console.WriteLine ("Add() invoked on thread:{0}\\n", 
                Thread.CurrentThread.GetHashCode ());
            Thread.Sleep (5000);
            return a + b;
        }

        static void Main()
        {
            Console.WriteLine ("Main() invoked on thread:{0}",
                Thread.CurrentThread.GetHashCode ());
            //Add() call in Synchronouse mode
            Operate op = new Operate (Add);
            IAsyncResult result = op.BeginInvoke(10,20,null,null);
            Console.WriteLine ("Doing more in Main() exected immediately.");
            //the thread susppend on EndInvoke while \'result\' is ready!
            int answer = op.EndInvoke (result);
            Console.Write("After Add() executed, result = {0}",answer);
            Console.ReadKey ();
        }
    }
}

同步调用:如果线程没有返回,不要一直问何时返回,每间隔500ms做该做的事情!!!

using System;
using System.Threading;

namespace Demo
{
    public delegate int Operate(int x, int y);

    public class DelegateAsync
    {
        static int Add(int a, int b)
        {
            Console.WriteLine ("Add() invoked on thread:{0}\\n", 
                Thread.CurrentThread.GetHashCode ());
            Thread.Sleep (5000);
            return a + b;
        }

        static void Main()
        {
            Console.WriteLine ("Main() invoked on thread:{0}\\n",
                Thread.CurrentThread.GetHashCode ());
            //Add() call in Synchronouse mode
            Operate op = new Operate (Add);
            IAsyncResult result = op.BeginInvoke(10,20,null,null);
            //while result is not OK, do it every 500 ms.
            while (!result.AsyncWaitHandle.WaitOne(500,true)) {//result.IsCompleted
                Console.WriteLine ("Doing more work in Main().");
            }
            int answer = op.EndInvoke (result);
            Console.Write("After Add() executed, result = {0}",answer);
            Console.ReadKey ();
        }
    }
}

线程回调: 好吧,干脆你返回的时候通知我,我该干啥不耽搁!

using System;
using System.Threading;

/// <summary>
/* Main() invoked on thread:1
Main() execute no need to wait any more.
Add() invoked on thread:3
AddComplete() invoked on thread:3
Your Addition is complete.
*/
/// </summary>
namespace Demo
{
    public delegate int Operate(int x, int y);

    public class DelegateAsync
    {
        static int Add(int a, int b)
        {
            Console.WriteLine ("Add() invoked on thread:{0}", 
                Thread.CurrentThread.GetHashCode ());
            Thread.Sleep (5000);
            return a + b;
        }

        static void AddComplete(IAsyncResult ia)
        {
            Console.WriteLine ("AddComplete() invoked on thread:{0}",
                Thread.CurrentThread.GetHashCode ());
            //Get Result value
            System.Runtime.Remoting.Messaging.AsyncResult ar=
                (System.Runtime.Remoting.Messaging.AsyncResult)ia;
            Operate op = (Operate)ar.AsyncDelegate;
            Console.WriteLine ("The value is {0}.", op.EndInvoke (ia));
        }

        static void Main()
        {
            Console.WriteLine ("Main() invoked on thread:{0}",
                Thread.CurrentThread.GetHashCode ());
            //Add() call in Synchronouse mode
            Operate op = new Operate (Add);
            IAsyncResult result = op.BeginInvoke (10, 20, new AsyncCallback (AddComplete), null);
            Console.WriteLine ("Main() execute no need to wait any more.");
            Console.ReadKey ();
        }
    }
}

主线程向次线程传递对象,通知!

using System;
using System.Threading;

/// <summary>
/*

Main() invoked on thread:1
Main() execute no need to wait any more.
Add() invoked on thread:3
AddComplete() invoked on thread:3
The value is 30.
The Main() thread is :1

*/
/// </summary>
namespace Demo
{
    public delegate int Operate(int x, int y);

    public class DelegateAsync
    {
        static int Add(int a, int b)
        {
            Console.WriteLine ("Add() invoked on thread:{0}", 
                Thread.CurrentThread.GetHashCode ());
            Thread.Sleep (5000);
            return a + b;
        }

        static void AddComplete(IAsyncResult ia)
        {
            Console.WriteLine ("AddComplete() invoked on thread:{0}",
                Thread.CurrentThread.GetHashCode ());
            //Get Result value
            System.Runtime.Remoting.Messaging.AsyncResult ar=
                (System.Runtime.Remoting.Messaging.AsyncResult)ia;
            Operate op = (Operate)ar.AsyncDelegate;
            Console.WriteLine ("The value is {0}.", op.EndInvoke (ia));
            Thread thread = (Thread)ia.AsyncState;
            Console.WriteLine ("The Main() thread is :{0}", thread.GetHashCode());
        }

        static void Main()
        {
            Console.WriteLine ("Main() invoked on thread:{0}",
                Thread.CurrentThread.GetHashCode ());
            //Add() call in Synchronouse mode
            Operate op = new Operate (Add);
            IAsyncResult result = op.BeginInvoke (10, 20, 
                new AsyncCallback (AddComplete),Thread.CurrentThread);
            Console.WriteLine ("Main() execute no need to wait any more.");
            Console.ReadKey ();
        }
    }
}

推荐下博客客户端工具: Download

以上是关于利用委托实现异步调用的主要内容，如果未能解决你的问题，请参考以下文章

委托事件总结之旅

对“xxx”类型的已垃圾回收委托进行了回调。这可能会导致应用程序崩溃损坏和数据丢失。向非托管代码传递委托时，托管应用程序必须让这些委托保持活动状态，直到确信不会再次调用它们。错误解决一例。(代码片段

C#委托异步调用

浅谈AsyncState与AsyncDelegate使用的异同

如何将异步Func或Action转换为委托并调用它

C# Winform 多线程异步委托进度条