自定义事件
试一试：自定义事件
//事件发送者
class Dog
{
//1.声明关于事件的委托；
public delegate void AlarmEventHandler(object sender, EventArgs e);
//2.声明事件；
public event AlarmEventHandler Alarm;
//3.编写引发事件的函数；
public void OnAlarm()
{
if (this.Alarm != null)
{
Console.WriteLine("\n狗报警: 有小偷进来了,汪汪~~~~~~~");
this.Alarm(this, new EventArgs()); //发出警报
}
}
}
//事件接收者
class Host
{
//４.编写事件处理程序
void HostHandleAlarm(object sender, EventArgs e)
{
Console.WriteLine("主 人: 抓住了小偷！");
}
//５.注册事件处理程序
public Host(Dog dog)
{
dog.Alarm += new Dog.AlarmEventHandler(HostHandleAlarm);
}
}
//６.现在来触发事件
class Program
{
static void Main(string[] args)
{
Dog dog = new Dog();
Host host = new Host(dog);
//当前时间，从2008年12月31日23:59:50开始计时
DateTime now = new DateTime(2008, 12, 31, 23, 59, 50);
DateTime midnight = new DateTime(2009, 1, 1, 0, 0, 0);
//等待午夜的到来
Console.WriteLine("时间一秒一秒地流逝... ");
while (now < midnight)
{
Console.WriteLine("当前时间: " + now);
System.Threading.Thread.Sleep(1000); //程序暂停一秒
now = now.AddSeconds(1); //时间增加一秒
}
//午夜零点小偷到达,看门狗引发Alarm事件
Console.WriteLine("\n月黑风高的午夜: " + now);
Console.WriteLine("小偷悄悄地摸进了主人的屋内... ");
dog.OnAlarm();
}
}
当午夜时分小偷到达时，dog调用dog.OnAlarm()函数，从而触发Alarm事件，于是系统找到并执行了注册在Alarm事件中的事件处理程序HostHandleAlarm()。
事件处理委托习惯上以EventHandler结尾，比如AlarmEventHandler。事件Alarm实际上是事件处理委托AlarmEventHandler的一个实例。引发事件的代码常常被编写成一个函数，.NET约定这种函数的名称为“OnEventName”，比如OnAlarm()的函数。在Host类中，我们定义了事件处理程序HostHandleAlarm()，并把它注册到dog.Alarm事件中。
事件处理程序的参数应该和事件委托相同。一般情况下，事件处理程序接受两个参数，一个是事件的发送者sender，一个是事件参数e[①]。事件参数用于在发送者和接收者之间传递信息。
.NET提供了100个事件参数类，这些都继承于EventArgs类。一般情况下，使用.NET自带的类足够了，但为了说明原理，我们自定义一个事件参数类。
试一试：使用事件参数
//事件参数
public class NumberOfThiefEventArgs : EventArgs
{
public int numberOfThief;
//构造函数
public NumberOfThiefEventArgs(int number)
{
numberOfThief = number;
}
}
//事件发送者
class Dog
{
//1.声明关于事件的委托；
public delegate void AlarmEventHandler(object sender, NumberOfThiefEventArgs e);
//2.声明事件；
public event AlarmEventHandler Alarm;
//3.编写引发事件的函数，注意多了个参数；
public void OnAlarm(NumberOfThiefEventArgs e)
{
if (this.Alarm != null)
{
Console.WriteLine("\n狗报警: 有小偷进来了,汪汪~~~~~~~\n");
this.Alarm(this, e);
}
}
}
//事件接收者
class Host
{
//４.编写事件处理程序，参数中包含着numberOfThief信息
void HostHandleAlarm(object sender, NumberOfThiefEventArgs e)
{
if (e.numberOfThief <= 1)
{
Console.WriteLine("主 人: 抓住了小偷！");
}
else
{
Console.WriteLine("主 人:打110报警，我家来了{0}个小偷！", e.numberOfThief);
}
}
//５.注册事件处理程序
public Host(Dog dog)
{
dog.Alarm += new Dog.AlarmEventHandler(HostHandleAlarm);
}
}
//６.现在来触发事件
class Program
{
static void Main(string[] args)
{
Dog dog = new Dog();
Host host = new Host(dog);
//当前时间，从2008年12月31日23:59:50开始计时
DateTime now = new DateTime(2008, 12, 31, 23, 59, 50);
DateTime midnight = new DateTime(2009, 1, 1, 0, 0, 0);
//等待午夜的到来
Console.WriteLine("时间一秒一秒地流逝... ");
while (now < midnight)
{
Console.WriteLine("当前时间: " + now);
System.Threading.Thread.Sleep(1000); //程序暂停一秒
now = now.AddSeconds(1); //时间增加一秒
}
//午夜零点小偷到达,看门狗引发Alarm事件
Console.WriteLine("\n月黑风高的午夜: " + now);
Console.WriteLine("小偷悄悄地摸进了主人的屋内... ");
//创建事件参数
NumberOfThiefEventArgs e = new NumberOfThiefEventArgs(3);
dog.OnAlarm(e);
}
}
运行结果如下：
在修改过的代码中，我们定义了一个名为NumberOfThiefEventArgs的事件参数类，它继承于EventArgs类。在该类中我们声明了一个名为numberOfThief的成员变量，用来记录来了几个小偷。当事件发生时，狗通过事件参数传告诉主人具体信息。
http://www.cnblogs.com/BeginnerClassroom/archive/2009/01/11/1373689.html
namespace 事件
{
//发布事件的类
public class TestEventSource
{
//定义事件参数类
public class TestEventArgs : EventArgs
{
public readonly char KeyToRaiseEvent;
public TestEventArgs(char keyToRaiseEvent)
{
KeyToRaiseEvent = keyToRaiseEvent;
}
}
//定义delegate
public delegate void TestEventHandler(object sender, TestEventArgs e);
//用event 关键字声明事件对象
public event TestEventHandler TestEvent;
//事件触发方法
protected virtual void OnTestEvent(TestEventArgs e)
{
if (TestEvent != null)
TestEvent(this, e);
}
//引发事件
public void RaiseEvent(char keyToRaiseEvent)
{
TestEventArgs e = new TestEventArgs(keyToRaiseEvent);
OnTestEvent(e);
}
}
//监听事件的类
public class TestEventListener
{
//定义处理事件的方法，他与声明事件的delegate具有相同的参数和返回值类型
public void KeyPressed(object sender, TestEventSource.TestEventArgs e)
{
Console.WriteLine("发送者：{0}，所按得健为：{1}", sender, e.KeyToRaiseEvent);
}
//订阅事件
public void Subscribe(TestEventSource evenSource)
{
evenSource.TestEvent += new TestEventSource.TestEventHandler(KeyPressed);
}
//取消订阅事件
public void UnSubscribe(TestEventSource evenSource)
{
evenSource.TestEvent -= new TestEventSource.TestEventHandler(KeyPressed);
}
}
//测试类
public class Test
{
public static void Main()
{
//创建事件源对象
TestEventSource es = new TestEventSource();
//创建监听对象
TestEventListener el = new TestEventListener();
//订阅事件
Console.WriteLine("订阅事件\n");
el.Subscribe(es);
//引发事件
Console.WriteLine("输入一个字符，再按enter键");
string s = Console.ReadLine();
es.RaiseEvent(s.ToCharArray()[0]);
//取消订阅事件
Console.WriteLine("\n取消订阅事件\n");
el.UnSubscribe(es);
//引发事件
Console.WriteLine("输入一个字符，再按enter健");
s = Console.ReadLine();
es.RaiseEvent(s.ToCharArray()[0]);
}
}
}
程序执行结
订阅事件
输入一个字符，再按enter键
aaaa
发送者：事件.TestEventSource，所按得健为：a
取消订阅事件
输入一个字符，再按enter健
一、C#委托类
委托类似于函数指针，但函数指针只能引用静态方法，而委托既能引用静态方法，也能引用实例方法。
委托使用分三步：1、委托声明；2、委托实例化；3、委托调用。
例程一：
程序代码
- using System;
- namespace 委托
- {
- delegate int NumOpe(int a,int b); //第一步:委托声明
- class Class1
- {
- static void Main(string[] args)
- {
- Class1 c1 = new Class1();
- NumOpe p1 = new NumOpe(c1.Add); //委托实例化,注意参数是要使用的参数名,且不带括号
- Console.WriteLine(p1(1,2)); //委托调用
- Console.ReadLine();
- }
- private int Add(int num1,int num2)
- {
- return(num1+num2);
- }
- }
- }
例中，委托NumOpe引用了方法Add。
委托声明了以后，就可以象类一样进行实例化，实例化时把要引用的方法（如：Add）做为参数，这样委托和方法就关联了起来，就可以用委托来引用方法了。
委托和所引用的方法必须保持一致：
1、参数个数、类型、顺序必须完全一致。
2、返回值必须一致。
二、C#事件
事件有很多，比如说鼠标的事件：MouserMove,MouserDown等，键盘的事件：KeyUp,KeyDown,KeyPress。
有事件，就会有对事件进行处理的方法，而事件和处理方法之间是怎么联系起来的呢？委托就是他们中间的桥梁，事件发生时，委托会知道，然后将事件传递给处理方法，处理方法进行相应处理。
比如在WinForm中最常见的是按钮的Click事件，它是这样委托的：this.button1.Click += new System.EventHandler(this.button1_Click);按按钮后就会出发button1_Click方法进行处理。EventHandler就是系统类库里已经声明的一个委托。-------委托实例化,this.buttion1_click为方法名
三、C#自定义事件及其处理
EventHandler以及其它自定义的事件委托都是一类特殊的委托，他们有相同的形式：
delegate void 事件委托名(object sender,EventArgs e);
object用来传递事件的发生者，比如二中的Button控件就是一个事件发生者；EventArgs用来传递事件的细节。
例程二：
程序代码
- using System;
- namespace 最简单的自定义事件
- {
- /// < summary>
- /// 事件发送类
- /// < /summary>
- class Class1
- {
- public delegate void UserRequest(object sender,EventArgs e); //定义委托
- public event UserRequest OnUserRequest; //定义一个委托类型的事件
- public void run()
- {
- while(true)
- {
- if(Console.ReadLine()=="a")
- {//事件监听
- OnUserRequest(this,new EventArgs()); //产生事件
- }
- }
- }
- }
- /// < summary>
- /// 事件接收类
- /// < /summary>
- class Class2
- {
- static void Main(string[] args)
- {
- Class1 c1 = new Class1();
- c1.OnUserRequest += new Class1.UserRequest(c1_OnUserRequest); //委托实例化后绑定到事件
- c1.run();
- }
- private static void c1_OnUserRequest(object sender, EventArgs e)
- {//事件处理方法
- Console.WriteLine("\t你触发了事件！");
- }
- }
- }
例程三：
程序代码
- using System;
- namespace 带事件数据的事件
- {
- /// < summary>
- /// 带事件数据的事件类，从EventArgs继承
- /// < /summary>
- class OnUserRequestEventArgs:EventArgs
- {
- private string inputText;
- public string InputText
- {
- get
- {
- return inputText;
- }
- set
- {
- inputText = value;
- }
- }
- }
- /// < summary>
- /// 事件发送类
- /// < /summary>
- class Class1
- {
- public delegate void UserRequest(object sender,OnUserRequestEventArgs e);------------->声明委托
- public event UserRequest OnUserRequest;------->定义一个委托类型的事件
- public void run()
- {
- while(true)
- {
- Console.WriteLine("请输入内容：");
- string a=Console.ReadLine();
- //if(a=="a")
- //{
- OnUserRequestEventArgs e1 = new OnUserRequestEventArgs();
- e1.InputText = a;
- OnUserRequest(this,e1);
- //}
- }
- }
- }
- /// < summary>
- /// 事件接收类
- /// < /summary>
- class Class2
- {
- [STAThread]
- static void Main(string[] args)
- {
- Class1 c1 = new Class1();
- c1.OnUserRequest += new Class1.UserRequest(c1_OnUserRequest);
- c1.run();
- }
- private static void c1_OnUserRequest(object sender, OnUserRequestEventArgs e)
- {
- Console.WriteLine("\t你输入的是："+e.InputText);
- }
- }
- }
例程三跟例程二唯一的差别在于自定义了一个类OnUserRequestEventArgs，从EventArgs继承。
至此，C#委托类、C#事件及C#自定义事件就介绍到这里。