Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Use chamadas assíncronasmétodo de sincronização, aqui usamos o Modelo de Programação Assíncrona (APM) para implementar
1. Defina delegação assíncrona e métodos de teste

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

namespace ApmAsyncApp
{
    public delegate string TestMethodAsyncCaller(int callDuration, out int threadId);
    /// <summary>
    internal class AsyncDemo
    {
        
        /// 执行异步调用的方法
        /// </summary>
        /// <param name="callDuration"></param>
        /// <param name="threadId"></param>
        /// <returns></returns>
        public string TestMethod(int callDuration,out int threadId)
        {
            Console.WriteLine("Test method begins:");
            Thread.Sleep(callDuration);
            threadId=Thread.CurrentThread.ManagedThreadId;
            return String.Format("Call time was {0}",callDuration);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2. Use EndInvoke para aguardar chamadas assíncronas

static void Main(string[] args)
        {
            int threadId;
            //创建测试类
            AsyncDemo asyncDemo = new AsyncDemo();
            //创建委托
            TestMethodAsyncCaller caller = new TestMethodAsyncCaller(asyncDemo.TestMethod);
            //初始化异步调用
            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);
            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);
            //调用EndInvoke检索结果
            string returnValue = caller.EndInvoke(out threadId, result);
            Console.WriteLine("The call executed on thread {0},with return value "{1}".", threadId, returnValue);
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. Use WaitHandle para aguardar chamadas assíncronas

static void Main(string[] args)
        {
            int threadId;
            //创建测试类
            AsyncDemo asyncDemo = new AsyncDemo();
            //创建委托
            TestMethodAsyncCaller caller = new TestMethodAsyncCaller(asyncDemo.TestMethod);
            //初始化异步调用
            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);
            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);
            //sone to do
            //等待信号
            result.AsyncWaitHandle.WaitOne();
            //调用EndInvoke检索结果
            string returnValue = caller.EndInvoke(out threadId, result);
            result.AsyncWaitHandle.Close();
            Console.WriteLine("The call executed on thread {0},with return value "{1}".", threadId, returnValue);
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4. Pesquise o status de conclusão de chamadas assíncronas

static void Main(string[] args)
        {
            int threadId;
            //创建测试类
            AsyncDemo asyncDemo = new AsyncDemo();
            //创建委托
            TestMethodAsyncCaller caller = new TestMethodAsyncCaller(asyncDemo.TestMethod);
            //初始化异步调用
            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);
            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);
            // 等待完成.
            while (result.IsCompleted == false)
            {
                Thread.Sleep(250);
                Console.Write(".");
            }
            //调用EndInvoke检索结果
            string returnValue = caller.EndInvoke(out threadId, result);
            Console.WriteLine("The call executed on thread {0},with return value "{1}".", threadId, returnValue);
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5. Execute o método de retorno de chamada quando a chamada assíncrona for concluída

static void Main(string[] args)
        {
            int threadId = 0;
            //创建测试类
            AsyncDemo asyncDemo = new AsyncDemo();
            //创建委托
            TestMethodAsyncCaller caller = new TestMethodAsyncCaller(asyncDemo.TestMethod);
            //初始化异步调用
            IAsyncResult result = caller.BeginInvoke(3000, out threadId, new AsyncCallback(callbackMethod), "The call executed on thread {0},with return value "{1}".");
            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(5000);
            Console.WriteLine("The main thread ends.");
            Console.ReadLine();
        }

        private static void callbackMethod(IAsyncResult ar)
        {
            //检索委托.
            AsyncResult result = (AsyncResult)ar;
            TestMethodAsyncCaller caller = (TestMethodAsyncCaller)result.AsyncDelegate;
            //格式字符串作为状态信息被传递
            string formatString = (string)ar.AsyncState;
            int threadId = 0;
            //调用EndInvoke检查结果.
            string returnValue = caller.EndInvoke(out threadId, ar);
            //用格式字符串格式化输出信息
            Console.WriteLine(formatString, threadId, returnValue);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28