大家知道委托就相当于C++里面的函数指针，相信大家都很很了解，看看如下简单代码来回想一下委托

1. public delegate void Ad(); xu xus = new xu();            
2. Ad b = new Ad(xus.Add);              
3. b += xus.ex;              
4. b();              
5. Console.ReadLine();  
6. class xu     
7.  {         
8.  public void Add()       
9.    {              
10. //Thread.Sleep(5000);            
11.  Console.WriteLine("sssssssssssssssssssss");         
12.  }          
13. public void ex()          
14. {             
15.  //Thread.Sleep(5000);            
16.  Console.WriteLine("aaaaaaaaaaaaaaaaaaaaa");         
17.  }    }  

这里我们看见 定义了一个ADD 的委托没有参数没有返回值 然后把委托指向ADD 和ex 两个方法（多播委托） 然后执行b()  执行之后 结果大家应该知道 就是执行了这2个方法打印出 "ssssssssssssss"于"aaaaaaaaaaaaaaaa"。那如果变成下面这个形式呢？

1. public delegate int Ad(int x,int y);          
2. static void Main(string[] args)          
3. {             
4.  xu xus = new xu();              
5. Ad a = new Ad(Add);              
6. a += (int x, int y) => { return x - y; };            
7. Console.WriteLine(a(3,2));              
8. Console.ReadLine();          
9. }          
10. static int Add(int x, int y)          
11. {              
12. //Thread.Sleep(2000);             
13. return x + y;        }          
14. static int ex(int x, int y)         
15.  {              
16. //Thread.Sleep(5000);            
17.  return x - y;         
18.  }    
19.   } 

这段代码 也是执行一个多播委托 但是输出的结果会是什么样的呢 答案是 输出1，为什么前面那个委托会输出2个方法 而这个委托只会输出第二个方法的返回值？如果我们也想输出2个返回值怎么办呢?其实很简单 代码如下

1. public delegate int Ad(int x,int y);          
2. static void Main(string[] args)         
3.  {              
4. xu xus = new xu();              
5. Ad a = new Ad(Add);              
6. a += (int x, int y) => { return x - y; };            
7. Delegate[] d = a.GetInvocationList();              
8. for (int i = 0; i < d.Length; i++)            
9. {                  
10. if (d[i] is Ad)                 
11.  {                    
12.  Ad s = (Ad)d[i];                      
13. Console.WriteLine(s(3, 2));               
14.    }        
15.       }                
16. Console.ReadLine();         
17.  }          
18. static int Add(int x, int y)        
19.   {             
20. // Thread.Sleep(2000);             
21. return x + y;         
22.  }          
23. static int ex(int x, int y)         
24.  {              
25. //Thread.Sleep(5000);            
26.  return x - y;       
27.    }    } 

这里我们使用了一个GetInvocationList 方法来返回多播委托的调用列表 然后转化ad 然后循环调用 最后显示的结果就是5,1。委托的 复习我们就看到这里 现在回到正题 看看委托的异步调用。

1. public delegate int Ad(int x,int y);          
2. static void Main(string[] args)          
3. {              
4. xu xus = new xu();              
5. Ad a = new Ad(Add);              
6. Console.WriteLine(a(3, 3));              
7. Console.WriteLine("start");             
8.  Console.ReadLine();          
9. }static int Add(int x, int y)         
10.  {              
11. Thread.Sleep(2000);              
12. return x + y;      
13.     } 

运行这段代码 会先停顿2秒钟之后再显示6 和start 因为我使用了sleep这个方法 它使该线程休眠2秒钟，所以会在2秒之后显示信息，但是这对用户体验来说是非常糟糕的，那我们怎么改善呢？看看如下代码

1.  public delegate int Ad(int x,int y);          
2. static void Main(string[] args)          
3. {              
4. xu xus = new xu();              
5. Ad a = new Ad(Add);             
6.  Console.WriteLine(a(3, 3));             
7. // Console.WriteLine("start");            
8. IAsyncResult isa= a.BeginInvoke(3, 3, null, null);             
9. while (!isa.IsCompleted)            
10.  {              
11.  Console.WriteLine("未完成");      
12.        }            
13. int s= a.EndInvoke(isa);            
14. Console.WriteLine(s.ToString());             
15. Console.ReadLine();          
16. }           
17. static int Add(int x, int y)         
18.  {             
19.  Thread.Sleep(2000);             
20.  return x + y;         
21.  }         
22.  static int ex(int x, int y)          
23. {              
24. //Thread.Sleep(5000);            
25.  return x - y;        
26.   }  

这里我们使用了begininvoke方法来异步执行 委托方法返回一个IAsyncResult 类型的值 代表委托执行的状态，使用一个while循环 来判断IsCompleted 如果没有完成异步调用则不断显示“未完成” 如果完成endinvoke 则返回结果。但是这里需要不断的询问操作完成状态 那么我们怎样让委托异步调用完成之后主动通知我们呢？ 看看如下代码

1.   public delegate int Ad(int x,int y);        
2. static void Main(string[] args)       
3.  {            
4. xu xus = new xu();            
5. Ad a = new Ad(Add);            
6. Console.WriteLine(a(3, 3));            
7. IAsyncResult isa= a.BeginInvoke(3, 3, new AsyncCallback(call), "edit by xyl");              
8. //执行你想执行的代码 这里我们还是用IsCompleted来代替          
9.  while (!isa.IsCompleted)            
10. {              
11.  Console.WriteLine("未完成");          
12.    }              
13. Console.ReadLine();     
14.      }          
15. static void call(IAsyncResult isa)          
16. {              
17. AsyncResult ar = (AsyncResult)isa;             
18.  Ad a = (Ad)ar.AsyncDelegate;            
19. Console.WriteLine("this is {0},{1}",a.EndInvoke(isa),ar.AsyncState);         
20.  }          
21. static int Add(int x, int y)       
22.    {              
23. Thread.Sleep(2000);        
24.       return x + y;         
25.  }         
26.  static int ex(int x, int y)         
27.  {              
28. //Thread.Sleep(5000);             
29. return x - y;         
30.  }    }  

这里我们使用了一个call方法 注意它是没有返回值的。把IAsyncResult转换成AsyncResult注意少了个I然后转换成AD 类型的委托 最后endinvoke 来返回值 这样在委托异步执行完成之后会自动通知方法。

文章来源：http://www.hulian.top，转载请注明！

版权说明:本站原创文章,由万象互联SEO优化发表.
本文地址:https://www.hulian.top/zixun/post/5356.html