这也是今天讨论到的一个话题,其实还是比较简单的。因为事件处理程序都是在主线程被执行的,所以主线程肯定是依次执行他们。那么究竟是什么决定了这个顺序呢?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
///这个例子解释了如果为一个事件绑定了多个事件处理程序,那么他们处理的顺序与绑定顺序是一致的
Console.WriteLine("主线程号是:{0}", Thread.CurrentThread.ManagedThreadId);
Employee e = new Employee();
e.NameChanged += new EventHandler(e_NameChanged);
e.NameChanged += new EventHandler(e_NameChanged2);
e.Name = "ares chen";
Console.Read();
}
static void e_NameChanged2(object sender, EventArgs e)
{
Console.WriteLine("第2个事件处理程序触发的时间是:{0}", DateTime.Now);
Console.WriteLine("当前线程号是:{0}", Thread.CurrentThread.ManagedThreadId);
}
static void e_NameChanged(object sender, EventArgs e)
{
Console.WriteLine("第1个事件处理程序触发的时间是:{0}", DateTime.Now);
Console.WriteLine("当前线程号是:{0}", Thread.CurrentThread.ManagedThreadId);
}
}
class Employee
{
public event EventHandler NameChanged;
private string name;
public string Name
{
get
{
return name;
}
set
{
name = value;
if (NameChanged != null)
NameChanged(this, null);
}
}
}
}
其实要深入看的话,这是因为事件的处理程序是通过一个列表来管理的,就是EventHandlerList
[HostProtection(SecurityAction.LinkDemand, SharedState=true)]
public sealed class EventHandlerList : IDisposable
{
// Fields
private ListEntry head;
private Component parent;
// Methods
public EventHandlerList()
{
}
internal EventHandlerList(Component parent)
{
this.parent = parent;
}
public void AddHandler(object key, Delegate value)
{
ListEntry entry = this.Find(key);
if (entry != null)
{
entry.handler = Delegate.Combine(entry.handler, value);//这里的关键在于Delegate.Combine,所以根据注册顺序不一样,是一个顺序型的组合
}
else
{
this.head = new ListEntry(key, value, this.head);
}
}
public void AddHandlers(EventHandlerList listToAddFrom)
{
for (ListEntry entry = listToAddFrom.head; entry != null; entry = entry.next)
{
this.AddHandler(entry.key, entry.handler);
}
}
public void Dispose()
{
this.head = null;
}
private ListEntry Find(object key)
{
ListEntry head = this.head;
while (head != null)
{
if (head.key == key)
{
return head;
}
head = head.next;
}
return head;
}
public void RemoveHandler(object key, Delegate value)
{
ListEntry entry = this.Find(key);
if (entry != null)
{
entry.handler = Delegate.Remove(entry.handler, value);
}
}
// Properties
public Delegate this[object key]
{
get
{
ListEntry entry = null;
if ((this.parent == null) || this.parent.CanRaiseEventsInternal)
{
entry = this.Find(key);
}
if (entry != null)
{
return entry.handler;
}
return null;
}
set
{
ListEntry entry = this.Find(key);
if (entry != null)
{
entry.handler = value;
}
else
{
this.head = new ListEntry(key, value, this.head);
}
}
}
// Nested Types
private sealed class ListEntry
{
// Fields
internal Delegate handler;
internal object key;
internal EventHandlerList.ListEntry next;
// Methods
public ListEntry(object key, Delegate handler, EventHandlerList.ListEntry next)
{
this.next = next;
this.key = key;
this.handler = handler;
}
}
}
所以,既然是通过线性表来保存的,那么就有一个先后顺序的情况。其实,一个更好的写法是下面这样的
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Threading;
using System.ComponentModel;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
///这个例子解释了如果为一个事件绑定了多个事件处理程序,那么他们处理的顺序与绑定顺序是一致的
Console.WriteLine("主线程号是:{0}", Thread.CurrentThread.ManagedThreadId);
Employee e = new Employee();
e.NameChanged += new EventHandler(e_NameChanged);
e.NameChanged += new EventHandler(e_NameChanged2);
e.Name = "ares chen";
Console.Read();
}
static void e_NameChanged2(object sender, EventArgs e)
{
Console.WriteLine("第2个事件处理程序触发的时间是:{0}", DateTime.Now);
Console.WriteLine("当前线程号是:{0}", Thread.CurrentThread.ManagedThreadId);
}
static void e_NameChanged(object sender, EventArgs e)
{
Console.WriteLine("第1个事件处理程序触发的时间是:{0}", DateTime.Now);
Console.WriteLine("当前线程号是:{0}", Thread.CurrentThread.ManagedThreadId);
}
}
class Employee
{
//public event EventHandler NameChanged;
protected EventHandlerList listEventDelegates = new EventHandlerList();
private object NameChangedEventKey = new object();
public event EventHandler NameChanged {
add {
listEventDelegates.AddHandler(NameChangedEventKey, value);
}
remove {
listEventDelegates.RemoveHandler(NameChangedEventKey, value);
}
}
private string name;
public string Name
{
get
{
return name;
}
set
{
name = value;
if (listEventDelegates[NameChangedEventKey] != null) {
listEventDelegates[NameChangedEventKey].DynamicInvoke(new object[] { this, null });
}
}
}
}
}
为什么使用EventHandlerList? 这个问题之前就谈论过,默认情况下,客户端程序每为事件绑定一个处理程序,就需要在类型中产生一个delegate的引用,如此一来,如果事件很多的话,不利于较好地控制内存。但如果用EventHandlerList的话,则有利于统一管理所有的delegate