C# 委托，事件， 异步

委托

​ 委托可以说是方法的集合,里面放着方法列表,当调用的时候就会调用全部的方法列表

​ 个人理解 ：

• 当声明和创建时委托时， 它是个 对象
• 当使用委托，调用方法时，它是个 方法

声明委托类型

delegate void MyDel(int x)

对比一下filed字段声明

int  count = 5;

​ 可以知道delegate 对应 int , 它是 种类型,void MyDel( int x ) 对应count

创建对象

private delegate void MyDel(int x);
MyDel requestHandler =new MyDel(addCount);


private void addCount(int x){
	x+=x;
}

为委托类型里面添加方法

requestHandler += addCount1;
requestHandler += addCount2;
//调用
requestHandler(5);

private void addCount1(int x){
  
}
private void addCount2(int x){
  
}

​ 委托类型要是有返回值,那么最后一个方法执行的返回值就是就结果

委托方法内存放的是匿名方法

​ 委托里的匿名方法的作用是初始化委托,就是方法列表中的方法是没有名字的

MyDel requestHandler;
requestHandler = delegate(int x){
    x+=x;
}

匿名方法捕获变量

​ 从这里也可以知道匿名方法的声音应该是与int y =5 ;同级或是比它低层次

MyDel requestHandler;
int y=5;
requestHandler = delegate(int x){
	x=y+5;
}

委托 + lamb表达式

MyDel requestHandler;
MyDel requestHandler1;
//匿名方法
requestHandler = delegate(int x) {x+20;}
requestHandler1 =  x => {x+20;}

事件

​ 联想一下观察者模式,当某一状态触发的时候,就会触发一些对象的方法,这个过程就像是委托一样调用方法列表一样,发布者就是一个委托对象,订阅者就是在里面的方法列表. 和方法，属性一样，事件event 是类或结构的成员，所以我们不能在一段可执行代码中声明事件，事件的初始值为null

​ 个人理解：

• event 的声明为事件的关键字，和方法，属性，字段平级

• 当在调用时事件就是调用方法

  ​对于事件的私有委托, 需要注意的事项:

直接上代码

delegate void CountDel();
class Incrementer {
  //事件本身就是个观察者，一旦被触发，就马上通知订阅者
   public event CountDel  MyEvent;
  
  //这是某个触发点
  public void DoCount (){
    for(int i =1;i<100;i++){
      if(i%12==0 && MyEvent!=null){
           MyEvent();
      }
    }
  }

}

//订阅者
class Dozens{
   public int DozenCount {get;private set}

  public void Dozens(Incrementer incrementer){
       incrementer +=AddDozenCount;
  }
  
  public void AddDozenCount(){
       DozenCount++;
  }
}

class Test {
   Incrementer inc = new Incrementer();
   Dozens dozens = new Dozens(inc);
   inc.DoCount();
}

标准事件（EventHandler）

​ .NET 环境中定义的标准事件，定义如下：

public event delegate EventHandler (object sender , EventArgs args)

​ 从形参名字可以看出第一个参数表示发送者，第二个参数传递一些信息

通过扩展EventArgs 来传递数据

​ 需要配置泛型委托来实现，上代码

//自定义EventArgs
class MyEventArgs : EventArgs{
   public int Anum{
     get;set;
   }
}



class Incrementer {
  //事件本身就是个观察者，一旦被触发，就马上通知订阅者
   public event EventHandler<MyEventArgs>  MyEvent;
  
  //这是某个触发点
  public void DoCount (){
    MyEventArgs eventArgs = new MyEventArgs();
    for(int i =1;i<100;i++){
      if(i%12==0 && MyEvent!=null){
           eventArgs.Anum = i;
           MyEvent(this,eventArgs);
      }
    }
  }

}

//订阅者
class Dozens{
  public int DozenCount {get;private set}

  public void Dozens(Incrementer incrementer){
       incrementer +=AddDozenCount;
  }
  
  public void AddDozenCount(object obj,MyEventArgs e){
       Console.writeLine("当数到{0}时，增加一"，e.Anum);
       DozenCount++;
  }
}

class Test {
   static void main (){
      Incrementer inc = new Incrementer();
      Dozens dozens = new Dozens(inc);
      inc.DoCount();
      Console.writeLine("共记录了{0}次"，dozens.DozenCount);
   }
}

异步

​ 异步是什么 ? 例如你去买奶茶，店员说请稍等，你在店员做奶茶的同时，你可以刷刷朋友圈，做其他事，等奶茶做好了，你再付钱，完成了买奶茶这件事。对于我来说，店员调配奶茶就是一个异步方法。异步不一定就是在其他线程执行，也可能在同个线程执行

​ 首先看一下异步方法

class Today{
    async Task<Tea> MakeTeaAsync （）{
    	Console.Writeline("开始做奶茶呀！");
  		Salewoman girl = new Salewomen();
    	Tea tea = await girl.makeTea();
    	return tea;
     }
}

class Test {
  public static void main(string args){
    	Today  to = new Today();
    	Task<Tea> teaTask = to.MakeTeaAsync();
    	Console.writeLine(teaTask.Tostring());
  }
    
}

​ 异步方法有三种返回值void,Task<T>,Task ,获取异步方法的结果调用Task.Result.调用方法的接收都是用Task 对象接收.

​ 如果我们的异步不需要异步的数据,那么可以一直执行下去,但是当并行的线程需要异步的数据仍然会阻塞等待

class Test{
    public static void main (){
         Task<int> task = CountAsync();
                 ...
         //下面需要用到异步的数据,那么加入异步没完成,此处会阻塞
         Console.wrintLine("结果为: "+task.Result);
      
      	//异步方法另外两种返回值
        Task task = CounterAsync1();
        Task task = CounterAsync2();//或直接调用异步方法 CounterAsync();
    }
}

private async Task<int> CountAsync(){
   int result = await SocketHelper.get();
   return result;
}

private async Task CountAsync1(){
  	int result = await SocketHelper.getAgain();
  	Console.writeLine("hello world !");
}

private async void CountAsync2(){
    int result = await SocketHelper.getAgain1();
}

​ 那么有没有,解决方法呢?我就是不想阻塞. 有, 回调.稍后介绍

异步方法在新线程执行

​ 异步默认情况下是当前线程执行的,当需要新开线程执行时,直接使用lamb 表达式

private async Task<int> CountAsync(){
  
   int result = await Task.Run(new Fun<int>(Get));
   //lamb表达式,
   int result1 = await Task.Run(()=>{
       return SocketHelper.get(num);
   });
  
   return result;
}

private int GetCount(int num){
    return SocketHelper.get(num);
}

​ Task.Run( ) 返回的结果有Task 和 Task<TResult>两种,形参用到的类有Action , Fun<TResult>和Fun<Task>,其中Fun<Task>不讲,详细方法如下 , (学习两种简单的)

public static Task Run (Action action) {}

public static Task<TResult> Run (Func<TResult> func) {}

​ Action 和 Func<TResult> 是两个委托, 它们的方法列表签名是不需要参数,返回值一个为void ,另外一个为传入的泛型,上面的例子

//委托Action 
 public delegate void Action();

//委托Func<TResult>
public delegate TResult Func<out TResult>();

//创建匿名委托对象(方法列表)内添加Get方法
int result = await Task.Run(new Fun<int>(Get));

​ 假如我需要个执行的任务是需要传递参数的,那么可以这样写

int reusult = await Task.Run(()=>Get(5,6));

​ 上面的例子()=>Get(5,6)是创建了Func<TResult>对象,并且为这个委托(方法列表)内添加了一个匿名的不需参数的方法,在这个匿名方法内执行Get(5,6)

异步方法中取消任务

​ 同样的是Task.Run( )方法，这里用到两个类，CancelationToken 和 CancelationTokenSource ,后者从名字可以看出是产生CancelationToken的,而使用CancelationToken去取消任务实际是令CancelationToken的属性IsCancelationRequested 为true

public static Task Run (Action action , CancelationToken token) {}

public static Task<TResult> Run (Func<TResult> func , CancelationToken token ) {}

例子

class Test {
  public void main(){
     CancelationTokenSource source = new CancelationTokenSource();
     CancelationToken tokent = source.token;
      
     MyClass my = new MyClass();
     Task task = my.CancelAsync(token);
      
     //task.wait();
     //token.cancel;
     task.wait();
     Console.writeLine("结束");
  }
}

class MyClass {
  public async void CancelAsync(CancelationToken token){
    if(IsCancelationRequested)
            return;
    Task task = await Task.Run(new  Fun(TestTask),token);
    
  }
  
  public  void TestTask(){
     Console.writeLine("开始");
     for(int i = 0 ; i < 5 ; i++){
         if(IsCancelationRequested){
             return;
          }
            
         Thread.sleep(1000);
         Console.writeLine("{0} of counts is completed",i+1);
          	
     }
  }
} 

//带注释运行
开始
1 of counts is completed 
2 of counts is completed
3 of counts is completed
4 of counts is completed 
5 of counts is completed
结束
  
//不带注释运行
开始
1 of counts is completed 
2 of counts is completed
3 of counts is completed
结束

异步中处理异常

​ await语句中直接加上try..catch

等待异步完成后再继续运行

//等待单个任务完成后继续执行
Task.Wait()
  
//等待一组任务完成后
Task[] tasks = new Task[]{t1,t2};
Task.WaitAll(tasks);

委托异步编程

​ 当委托中只有一个方法(方法列表里只要一个方法)时可以使这个方法在另外的线程(线程池中的线程)中异步执行,使用的方法是委托的BeginInvoke ,当希望获取到异步的结果时可以检查BeginInvoke返回的IAsyncResult的Iscompleted属性,或是调用委托的EndInvoke来等待异步的完成.有三种异步编程方式。分别是轮询， 一直等待和回调。

namespace Common.Been
{


    internal delegate int MyDelegate(string milk, string tea);
    class Test
    {
        private MyDelegate del = delegate(string milk, string tea)
        {
            Console.WriteLine(milk + " " + tea);
            return milk.Length + tea.Length;
        };


        public void MyCallback(IAsyncResult asyncResult)
        {
           	AsyncResult AsyncCallback = (AsyncResult) asyncResult.AsyncState;
            MyDelegate callDelegate = (MyDelegate) AsyncCallback.AsyncDelegate;
            int result = callDelegate.EndInvoke(asyncResult);
            //这里在进行一些其他操作
           
        }
        public void main()
        {
            string m = "cow milk";
            string t = "black tea";

            //public IAsyncResult BeginInvoke(string milk, string tea, AsyncCallback callback, object state) 
            //不使用回调的情况
            IAsyncResult AsyncResult = del.BeginInvoke(m, t, null, null);
            int result = del.EndInvoke(AsyncResult);

            //public delegate void AsyncCallback(IAsyncResult ar);
            //使用回调
            IAsyncResult AsyncResult1 = del.BeginInvoke(m, t, new AsyncCallback(MyCallback), del);
            

        }
    }

}

​ BeginInvoke返回一个IAsyncResult对象,它实际上是个AsyhcResult对象,他们的关系是怎么样的呢?

​ 其中,AsyncDelegate保持着调用BeginInvoke方法的委托引用,AsyncState保存着是BeginInvoke方法的第四个参数.

计时器

​ 周期执行的异步类,同样它也是从线程池内拿取线程执行方法,同时可以传入回调

class Test {
    ///
  	///第二个参数: 传给回调的对象引用
    ///第三个参数: 多久后开始
    ///第四个参数: 每过多久循环
    public void main(){
      		//public Timer( TimerCallback callback, object state, int dueTime, int period) 
            //public delegate void TimerCallback(object state);
            string giveCallback = "love you ";
            Timer timer = new Timer(new TimerCallback(TimeCallback), giveCallback, 2000, 3000);
      
    }
  
    private void  TimeCallback(object obj)
    {
            string whatYouGive = (string) obj;
    }
}