C#中的事件与委托

最新推荐文章于 2023-02-20 21:59:41 发布

chunchunlaila

最新推荐文章于 2023-02-20 21:59:41 发布

阅读量265

点赞数

本文链接：https://blog.csdn.net/chunchunlaila/article/details/105796900

版权

4..net framework事件与委托

例子

5.续

1.事件应该由事件发布者触发，而不应该由客户端（客户程序）来触发

2.为什么委托定义的返回值通常都为void？

1.引言

学习和使用C#有一段时间了，但是对于事件和委托一直一直没有跨过去，到底是怎么一回事呢，今天好好探索一下。

2.委托delegate

delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它"只能持有与它的签名相匹配的方法的引用"。delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。

实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：
1．声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。
2．创建delegate对象，并"将你想要传递的函数作为参数传入"。
3．在要实现异步调用的地方，通过上一步创建的对象来调用方法。

using System;

public class MyDelegateTest
{
// 步骤1，声明delegate对象
public delegate void MyDelegate(string name);

// 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
public static void MyDelegateFunc(string name)
{
Console.WriteLine("Hello, ", name);
}
public static void Main()
{
// 步骤2，创建delegate对象(实例？？)
MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
// 步骤3，调用delegate
md("sam1111");
}
}

使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。

注意这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。

例子：

 public delegate void DoSomeThing(string name);
    class Program
    {
        static void Main(string[] args)
        {
            Say say = new Say();
            DoSomeThing dosomething = new DoSomeThing(say.SayHello);
            dosomething+=say.SayGoodbye;
            dosomething("dxc");
            Console.ReadKey();

        }
    }
    public class Say
    {
        public void SayHello(string name)
        {
            Console.WriteLine("hello, "+name);
        }
        public void SayGoodbye(string name)
        {
            Console.WriteLine("goodbye, "+name);
        }
    }

3.委托、事件与Observer设计模式

Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。

Observer设计模式中主要包括如下两类对象：

Subject：监视对象，它往往包含着其他对象所感兴趣的内容。
Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。

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

namespace Delegate
{



    public delegate void DoSomeThing(string name);
    class Program
    {
        static void Main(string[] args)
        {
            Alarm alarm = new Alarm();
            Display display = new Display();
            Heater heater = new Heater();
            heater.boildhandler += alarm.MakeAlter;
            heater.boildhandler += display.ShowMsg;
            heater.Boiled();
            Console.ReadKey();
        }
    }
    public class Heater
    {
        public int temp;
        public delegate void BoildHandler(int param);
        public event BoildHandler boildhandler;
       //烧水
        public void Boiled()
        {
            for(int i=1;i<100;i++)
            {
                temp = i;
                if(temp>=96)
                {
                    if(boildhandler!=null)
                    {
                        boildhandler(temp);
                    }
                }
            }
        }
    }
    /// <summary>
    /// 报警器
    /// </summary>
    public class Alarm
    {
        public void MakeAlter(int temp)
        {
            Console.WriteLine("嘀嗒嘀嗒，温度到达{0}了", temp);
        }
    }
    public class Display
    {
        public void ShowMsg(int temp)
        {
            Console.WriteLine("显示温度为{0}", temp);
        }
    }
}

4..net framework事件与委托

.Net Framework的编码规范：

委托类型的名称都应该以EventHandler结束。
委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
事件的命名为委托去掉 EventHandler之后剩余的部分。
继承自EventArgs的类型应该以EventArgs结尾。

委托声明原型中的Object类型的参数代表监视对象，回调函数可以通过它访问触发事件的对象。
EventArgs 对象包含了Observer（监视者）所感兴趣的数据。

C#中的事件处理实际上是一种具有特殊签名的delegate

结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：
1．定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
2．定义事件参数类，此类应当从System.EventArgs类派生。如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。
3．定义"事件处理方法，它应当与delegate对象具有相同的参数和返回值类型"。
4．用event关键字定义事件对象，它同时也是一个delegate对象。
5．用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
6．在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
7．在适当的地方调用事件触发方法触发事件。

例子

//定义一个委托
    public delegate void TimeEventHandler(object obj, TimeEventArgs args);
    class Program
    {
        static void Main(string[] args)
        {
            Clock clock = new Clock();//实例化一个时钟
            MyTimeEventHandlerClass tehc = new MyTimeEventHandlerClass();
            clock.TimeChanged += new TimeEventHandler(tehc.ShowTime);
            clock.go();
            Console.ReadKey();

        }
    }

    /// <summary>
    /// 保存事件中的参数
    /// </summary>
    public class TimeEventArgs:EventArgs
    {
        private int hour;
        private int minute;
        private int second;
        public TimeEventArgs(int hour,int minute,int second)
        {
            this.hour = hour;
            this.minute = minute;
            this.second = second;
        }
        public int Hour
        {
            get { return hour; }
        }
        public int Minute
        {
            get
            {
                return minute;
            }
        }
        public int Second
        {
            get
            {
                return second;
            }
        }
    }
    /// <summary>
    /// 观察者类，符合定义的“委托”的方法,ShowTime:关心的只是返回类型和方法的参数，参数名无所谓
    /// </summary>
    class MyTimeEventHandlerClass
    {
        public void ShowTime(object obj,TimeEventArgs args)
        {
            Console.WriteLine("现在时间是：" + args.Hour + ":" + args.Minute + ":" + args.Second);
        }
    }
    /// <summary>
    /// 时钟类
    /// </summary>
    class Clock
    {
        public event TimeEventHandler TimeChanged;
        public Clock()
        {
            TimeChanged = null;
        }
        public void go()
        {
            DateTime initi = DateTime.Now;
            int h1 = initi.Hour;
            int m1 = initi.Minute;
            int s1 = initi.Second;
            while(true)
            {
                DateTime now = DateTime.Now;
                int h2 = now.Hour;
                int m2 = now.Minute;
                int s2 = now.Second;
                if(s2!=s1)
                {
                    h1 = h2;
                    m1 = m2;
                    s1 = s2;
                    //首先建立一个TimeEventArgs对象来保存相关参数，这里是时分秒。
                    TimeEventArgs args = new TimeEventArgs(h2, m2, s2);
                    TimeChanged(this, args);
                }
            }
        }
    }

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

namespace Delegate
{



    public delegate void DoSomeThing(string name);
    class Program
    {
        static void Main(string[] args)
        {
            Alarm alarm = new Alarm();
            Display display = new Display();
            Heater heater = new Heater();
            heater.boildhandler += alarm.MakeAlter;
            heater.boildhandler += display.ShowMsg;
            heater.Boiled();
            Console.ReadKey();
        }
    }
    public class Heater
    {
        public int temp;
        public string type = "adb";
        public string area = "北京";
        public delegate void BoildHandler(Object sender,HeaterEventErgs e);
        public event BoildHandler boildhandler;
        public class HeaterEventErgs : EventArgs
        {
            public readonly int temp;
            public HeaterEventErgs(int temp)
            {
                this.temp = temp;
            }
        }
        // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
        protected virtual void OnBoiled(HeaterEventErgs e)
        {
            if (boildhandler != null)
            { // 如果有对象注册
                boildhandler(this, e);  // 调用所有注册对象的方法
            }
        }
       //烧水
        public void Boiled()
        {
            for(int i=1;i<100;i++)
            {
                temp = i;
                if(temp>=96)
                {
                    HeaterEventErgs e = new HeaterEventErgs(temp);
                    OnBoiled(e);
                }
            }
        }
    }
    /// <summary>
    /// 报警器
    /// </summary>
    public class Alarm
    {
        public void MakeAlter(Object sender,Heater.HeaterEventErgs e)
        {
            Heater heater = (Heater)sender;
            Console.WriteLine("热水器类型是{0}",heater.type);
            Console.WriteLine("热水器生产地是{0}", heater.area);
            Console.WriteLine("嘀嗒嘀嗒，温度到达{0}了", e.temp);
        }
    }
    public class Display
    {
        public void ShowMsg(Object sender,Heater.HeaterEventErgs e)
        {
            Heater heater = (Heater)sender;
            Console.WriteLine("热水器类型是{0}", heater.type);
            Console.WriteLine("热水器生产地是{0}", heater.area);
            Console.WriteLine("显示温度为{0}", e.temp);
        }
    }
}

5.续

1.事件应该由事件发布者触发，而不应该由客户端（客户程序）来触发

单独讨论事件，会说发布者，订阅者，客户端；讨论Observer模式，会说主题(subject)和观察者(observer)。客户端通常是包含Main()方法的Program类。

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

namespace Delegate
{



    public delegate void Numbereventhandler(int count);
    public class publisher
    {
        public int count;
        //public Numbereventhandler number;
        public event Numbereventhandler number;
        public void dosomething(int count)
        {
            if(number!=null)
            {
               number(count);
            }
        }
    }
    public class subscriber
    {
        public void Onnumber(int count)
        {
            Console.WriteLine("Subscriber notified: count = {0}",count);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            publisher pub = new publisher();
            //pub.number(100);
            pub.number += sub.Onnumber;
            pub.dosomething(100);
            Console.ReadKey();
        }
    }
}

当使用委托变量时，可以在客户端直接通过委托变量来出发事件，直接用pub.number(100)这将会影响到所有注册了该委托的订阅者；而事件的本意应该为在事件发布者在其本身的某个行为中触发，比如说在方法DoSomething()中满足某个条件后触发。通过添加event关键字来发布事件，事件发布者的封装性会更好，事件仅仅是供其他类型订阅，而客户端不能直接触发事件（语句pub.number(100)无法通过编译），事件只能在事件发布者Publisher类的内部触发（比如在方法pub.DoSomething()中），换言之，就是Number(100)语句只能在Publisher内部被调用。

2.为什么委托定义的返回值通常都为void？

因为委托可以提供多个订阅者注册，如果定义了返回值，那么多个订阅者的方法都会向发布者返回数值，结果就是后一个返回的方法值把前一个覆盖掉，因此，实际上只能获得最后一个方法调用的返回值；发布者和订阅者是松耦合的，发布者根本不关心谁订阅了它的事件、为什么要订阅，更别说订阅者的返回值了，所以返回订阅者的方法返回值大多数情况下根本没有必要。


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

namespace Delegate
{



    public delegate int Numbereventhandler(int count);
    public class publisher
    {
        public int count;
        //public Numbereventhandler number;
        public event Numbereventhandler number;
        public void dosomething(int count)
        {
            if(number!=null)
            {
               int i= number(count);
               Console.WriteLine(i);
            }
        }
    }
    public class subscriber
    {
        public int Onnumber1(int count)
        {
            Console.WriteLine("Subscriber notified: count = {0}",count);
            return 1;
        }
        public int Onnumber2(int count)
        {
            Console.WriteLine("Subscriber notified: count = {0}", count);
            return 2;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            publisher pub = new publisher();
            pub.number += sub.Onnumber1;
            pub.number += sub.Onnumber2;
            pub.dosomething(100);
            Console.ReadKey();
        }
    }
}

3.如何让事件只允许一个客户订阅？

少数情况下，比如像上面，为了避免发生“值覆盖”的情况（更多是在异步调用方法时，后面会讨论），我们可能想限制只允许一个客户端注册。将事件声明为private的，然后提供两个方法来进行注册和取消注册；更好的是使用事件访问器

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

namespace Delegate
{



    public delegate void Numbereventhandler(int count);
    public class publisher
    {
        public int count;
        private Numbereventhandler number;
        public  event Numbereventhandler Number
        {
            add
            {
                number = value;
            }
            remove
            {
                number -= value;
            }

        }
        public void dosomething(int count)
        {
            if(number!=null)
            {
               number(count);
            }
        }
    }
    public class subscriber
    {
        public void Onnumber(int count)
        {
            Console.WriteLine("Subscriber notified: count = {0}",count);
        }
    }
    public class subscriber1
    {
        public void Onnumber(int count)
        {
            Console.WriteLine("Subscriber1 notified: count = {0}", count);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            subscriber1 sub1 = new subscriber1();
            publisher pub = new publisher();
            pub.Number -= sub.Onnumber;
            pub.Number += sub.Onnumber;
            pub.Number += sub1.Onnumber;
            pub.dosomething(100);
            Console.ReadKey();
        }
    }
}

上面代码中类似属性的public event Numbereventhandler Number {add{...}remove{...}}语句便是事件访问器。使用了事件访问器以后，在DoSomething方法中便只能通过number委托变量来触发事件，而不能Number事件访问器（注意它们的大小写不同）触发，它只用于注册和取消注册

4.获得多个返回值与异常处理

委托定义在编译时会生成一个继承自MulticastDelegate的类，而这个MulticastDelegate又继承自Delegate，在Delegate内部，维护了一个委托链表，链表上的每一个元素，为一个只包含一个目标方法的委托对象。而通过Delegate基类的GetInvocationList()静态方法，可以获得这个委托链表。随后我们遍历这个链表，通过链表中的每个委托对象来调用方法，这样就可以分别获得每个方法的返回值：

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

namespace Delegate
{



    public delegate int Numbereventhandler(int count);
    public class publisher
    {
        public int count;
        //private Numbereventhandler number;
        public event Numbereventhandler number;
        public List<int> dosomething(int count)
        {
            List<int> list = new List<int>();
            if(number==null)
            {
                return list;
            }
            System.Delegate[] delarray = number.GetInvocationList();
            foreach(Numbereventhandler num in delarray)
            {
                list.Add(num(count));
            }
            return list;


        }
    }
    public class subscriber
    {
        public int Onnumber(int count)
        {
            Console.WriteLine("Subscriber notified: count = {0}",count);
            return 1;
        }
    }
    public class subscriber1
    {
        public int Onnumber(int count)
        {
            Console.WriteLine("Subscriber1 notified: count = {0}", count);
            return 2;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            subscriber1 sub1 = new subscriber1();
            publisher pub = new publisher();
            pub.number += sub.Onnumber;
            pub.number += sub1.Onnumber;
           List<int> num= pub.dosomething(100);
           for (int i = 0; i < num.Count;i++ )
           {
               Console.WriteLine(num[i]);
           }
               Console.ReadKey();
        }
    }
}

通过这种方式来触发事件最常见的情况应该是在异常处理中，因为很有可能在触发事件时，订阅者的方法会抛出异常，而这一异常会直接影响到发布者，使得发布者程序中止，而后面订阅者的方法将不会被执行。因此我们需要加上异常处理，例子如下：

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

namespace Delegate
{



    public delegate void Numbereventhandler(Object sender,EventArgs e);
    public class publisher
    {
        public int count;
        //private Numbereventhandler number;
        public event Numbereventhandler number;
        public void dosomething()
        {
            if (number != null)
            {
                System.Delegate[] delarray = number.GetInvocationList();
                foreach (Numbereventhandler num in delarray)
                {
                    try
                    {
                        num(this, EventArgs.Empty);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Exception:{0}", e.Message);
                    }
                }
                
              
            }
        }
    }
    public class subscriber
    {
        public void Onnumber(Object sender,EventArgs e)
        {
            Console.WriteLine("success");
        }
    }
    public class subscriber1
    {
        public void Onnumber(Object sender, EventArgs e)
        {
            throw new Exception("failed");
        }
    }
    public class subscriber2
    {
        public void Onnumber(Object sender, EventArgs e)
        {
            Console.WriteLine("success");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            subscriber1 sub1 = new subscriber1();
            subscriber2 sub2=new subscriber2();
            publisher pub = new publisher();
            pub.number += sub.Onnumber;
            pub.number += sub1.Onnumber;
            pub.number += sub2.Onnumber;
            pub.dosomething();
            Console.ReadKey();
        }
    }
}

5.委托中订阅者方法超时的处理

订阅者除了可以通过异常的方式来影响发布者以外，还可以通过另一种方式：超时。超时和异常的区别就是超时并不会影响事件的正确触发和程序的正常运行，却会导致事件触发后需要很长才能够结束。在依次执行订阅者的方法这段期间内，客户端程序会被中断，什么也不能做。因为当执行订阅者方法时（通过委托，相当于依次调用所有注册了的方法），当前线程会转去执行方法中的代码，调用方法的客户端会被中断，只有当方法执行完毕并返回时，控制权才会回到客户端，从而继续执行下面的代码。

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

namespace Delegate
{



    public delegate void Numbereventhandler(Object sender,EventArgs e);
    public class publisher
    {
        public int count;
        //private Numbereventhandler number;
        public event Numbereventhandler number;
        public void dosomething()
        {
            if (number != null)
            {
                System.Delegate[] delarray = number.GetInvocationList();
                //foreach (Numbereventhandler num in delarray)
                //{
                //    try
                //    {
                //        num(this, EventArgs.Empty);
                //    }
                //    catch (Exception e)
                //    {
                //        Console.WriteLine("Exception:{0}", e.Message);
                //    }
                //}
                foreach (System.Delegate num in delarray)
                {
                    try
                    {
                        num.DynamicInvoke(this, EventArgs.Empty);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Exception:{0}", e.Message);
                    }
                }
                
              
            }
        }
    }
    public class subscriber
    {
        public void Onnumber(Object sender,EventArgs e)
        {
            Thread.Sleep(TimeSpan.FromSeconds(3));
            Console.WriteLine("success");
        }
    }
    public class subscriber1
    {
        public void Onnumber(Object sender, EventArgs e)
        {
            throw new Exception("failed");
        }
    }
    public class subscriber2
    {
        public void Onnumber(Object sender, EventArgs e)
        {
            Thread.Sleep(TimeSpan.FromSeconds(3));
            Console.WriteLine("success");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            subscriber1 sub1 = new subscriber1();
            subscriber2 sub2=new subscriber2();
            publisher pub = new publisher();
            pub.number += sub.Onnumber;
            pub.number += sub1.Onnumber;
            pub.number += sub2.Onnumber;
            pub.dosomething();
            Console.WriteLine("\ncontorl back to client!");
            Console.ReadKey();
        }
    }
}

很多情况下，尤其是远程调用的时候（比如说在Remoting中），发布者和订阅者应该是完全的松耦合，发布者不关心谁订阅了它、不关心订阅者的方法有什么返回值、不关心订阅者会不会抛出异常，当然也不关心订阅者需要多长时间才能完成订阅的方法，它只要在事件发生的那一瞬间告知订阅者事件已经发生并将相关参数传给订阅者就可以了。然后它就应该继续执行它后面的动作。而订阅者不管失败或是超时都不应该影响到发布者，但在上面的例子中，发布者却不得不等待订阅者的方法执行完毕才能继续运行。

委托的定义会生成继承自MulticastDelegate的完整的类，其中包含Invoke()、BeginInvoke()和EndInvoke()方法。当我们直接调用委托时，实际上是调用了Invoke()方法，它会中断调用它的客户端，然后在客户端线程上执行所有订阅者的方法（客户端无法继续执行后面代码），最后将控制权返回客户端。注意到BeginInvoke()、EndInvoke()方法，在.Net中，异步执行的方法通常都会配对出现，并且以Begin和End作为方法的开头（最常见的可能就是Stream类的BeginRead()和EndRead()方法了）。它们用于方法的异步执行，即是在调用BeginInvoke()之后，客户端从线程池中抓取一个闲置线程，然后交由这个线程去执行订阅者的方法，而客户端线程则可以继续执行下面的代码。BeginInvoke()接受“动态”的参数个数和类型，为什么说“动态”的呢？因为它的参数是在编译时根据委托的定义动态生成的，其中前面参数的个数和类型与委托定义中接受的参数个数和类型相同，最后两个参数分别是AsyncCallback和Object类型。

注意：

在委托类型上调用BeginInvoke()时，此委托对象只能包含一个目标方法，所以对于多个订阅者注册的情况，必须使用GetInvocationList()获得所有委托对象，然后遍历它们，分别在其上调用BeginInvoke()方法。如果直接在委托上调用BeginInvoke()，会抛出异常，提示“委托只能包含一个目标方法”。
如果订阅者的方法抛出异常，.NET会捕捉到它，但是只有在调用EndInvoke()的时候，才会将异常重新抛出。而在本例中，我们不使用EndInvoke()（因为我们不关心订阅者的执行情况），所以我们无需处理异常，因为即使抛出异常，也是在另一个线程上，不会影响到客户端线程（客户端甚至不知道订阅者发生了异常，这有时是好事有时是坏事）。
BeginInvoke()方法属于委托定义所生成的类，它既不属于MulticastDelegate也不属于Delegate基类，所以无法继续使用可重用的FireEvent()方法，我们需要进行一个向下转换，来获取到实际的委托类型。

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

namespace Delegate
{



    public delegate void Numbereventhandler(Object sender,EventArgs e);
    public class publisher
    {
        public int count;
        //private Numbereventhandler number;
        public event Numbereventhandler number;
        public void dosomething()
        {
            if (number != null)
            {
                System.Delegate[] delarray = number.GetInvocationList();
                foreach (Numbereventhandler num in delarray)
                {
                    try
                    {
                        num.BeginInvoke(this, EventArgs.Empty,null,null);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Exception:{0}", e.Message);
                    }
                }
                //foreach (System.Delegate num in delarray)
                //{
                //    try
                //    {
                //        num.DynamicInvoke(this, EventArgs.Empty);
                //    }
                //    catch (Exception e)
                //    {
                //        Console.WriteLine("Exception:{0}", e.Message);
                //    }
                //}
                
              
            }
        }
    }
    public class subscriber
    {
        public void Onnumber(Object sender,EventArgs e)
        {
            Thread.Sleep(TimeSpan.FromSeconds(3));
            Console.WriteLine("success");
        }
    }
    public class subscriber1
    {
        public void Onnumber(Object sender, EventArgs e)
        {
            throw new Exception("failed");
        }
    }
    public class subscriber2
    {
        public void Onnumber(Object sender, EventArgs e)
        {
            Thread.Sleep(TimeSpan.FromSeconds(3));
            Console.WriteLine("success");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            subscriber sub = new subscriber();
            subscriber1 sub1 = new subscriber1();
            subscriber2 sub2=new subscriber2();
            publisher pub = new publisher();
            pub.number += sub.Onnumber;
            pub.number += sub1.Onnumber;
            pub.number += sub2.Onnumber;
            pub.dosomething();
            Console.WriteLine("\ncontorl back to client!");
            Console.ReadKey();
        }
    }
}

从结果可以看到：

我们需要在客户端程序中调用Console.ReadKey()方法来暂停客户端，以提供足够的时间来让异步方法去执行完代码，不然的话客户端的程序到此处便会运行结束，程序会退出，不会看到任何订阅者方法的输出，因为它们根本没来得及执行完毕。原因是这样的：客户端所在的线程我们通常称为主线程，而执行订阅者方法的线程来自线程池，属于后台线程(Background Thread），当主线程结束时，不论后台线程有没有结束，都会退出程序。（当然还有一种前台线程(Foreground Thread)，主线程结束后必须等前台线程也结束后程序才会退出，关于线程的讨论可以开辟另一个庞大的主题，这里就不讨论了）。
在打印完“Press any thing to exit...”之后，两个订阅者的方法会以2秒、1秒的间隔显示出来，且尽管我们先注册了subscirber1，但是却先执行了subscriber3，这是因为执行它需要的时间更短。除此以外，注意到这两个方法是并行执行的，所以执行它们的总时间是最长的方法所需要的时间，也就是3秒，而不是他们的累加5秒。
如同前面所提到的，尽管subscriber2抛出了异常，我们也没有针对异常进行处理，但是客户程序并没有察觉到，程序也没有因此而中断。

6.委托和方法的异步调用

如果需要异步执行一个耗时的操作，我们会新起一个线程，然后让这个线程去执行代码。但是对于每一个异步调用都通过创建线程来进行操作显然会对性能产生一定的影响，同时操作也相对繁琐一些。.Net中可以通过委托进行方法的异步调用，就是说客户端在异步调用方法时，本身并不会因为方法的调用而中断，而是从线程池中抓取一个线程去执行该方法，自身线程（主线程）在完成抓取线程这一过程之后，继续执行下面的代码，这样就实现了代码的并行执行。使用线程池的好处就是避免了频繁进行异步调用时创建、销毁线程的开销。

当我们在委托对象上调用BeginInvoke()时，便进行了一个异步的方法调用。上面的例子中是在事件的发布和订阅这一过程中使用了异步调用，而在事件发布者和订阅者之间往往是松耦合的，发布者通常不需要获得订阅者方法执行的情况；而当使用异步调用时，更多情况下是为了提升系统的性能，而并非专用于事件的发布和订阅这一编程模型。

参考：C# 中的委托和事件(详解：简单易懂的讲解)

C#事件与委托详解【精华多看看】

chunchunlaila

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C#中的事件与委托

目录1.引言2.委托delegate例子：3.事件例子1.引言学习和使用C#有一段时间了，但是对于事件和委托一直一直没有跨过去，到底是怎么一回事呢，今天好好探索一下。2.委托delegatedelegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它"只能持...
复制链接

扫一扫