C#基础知识之事件和委托

public void GreetPeople(string name)
{
EnglishGreeting(name);
}
public void EnglishGreeting(string name)
{
Console.WriteLine("Morning, " + name);
}

public enum Language
{
English, Chinese
}
public void GreetPeople(string name, Language lang)
{
swith(lang){
case Language.English:
EnglishGreeting(name);
break;
case Language.Chinese:
ChineseGreeting(name);
break;
}
}

using System;
using System.Collections.Generic;
using System.Text; namespace Delegate {
public delegate void GreetingDelegate(string name);
class Program {
private static void EnglishGreeting(string name) {
Console.WriteLine("Morning, " + name);
} private static void ChineseGreeting(string name) {
Console.WriteLine("早上好, " + name);
} //注意此方法，它接受一个GreetingDelegate类型的方法作为参数
private static void GreetPeople(string name, GreetingDelegate MakeGreeting) {
MakeGreeting(name);
} static void Main(string[] args) {
GreetPeople("Jimmy Zhang", EnglishGreeting);
GreetPeople("张子阳", ChineseGreeting);
Console.ReadKey();
}
}
}
输出如下：
Morning, Jimmy Zhang
早上好, 张子阳

static void Main(string[] args) {
GreetingDelegate delegate1;
delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
// 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
delegate1 ("Jimmy Zhang");
Console.ReadKey();
}

static void Main(string[] args) {
GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法 // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
GreetPeople("Jimmy Zhang", delegate1);
Console.WriteLine(); delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
// 将仅调用 ChineseGreeting
GreetPeople("张子阳", delegate1);
Console.ReadKey();
}
输出为：
Morning, Jimmy Zhang
早上好, Jimmy Zhang
早上好, 张子阳

namespace Delegate {
//定义委托，它定义了可以代表的方法的类型
public delegate void GreetingDelegate(string name);
//新建的GreetingManager类
public class GreetingManager{
public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
MakeGreeting(name);
}
} class Program {
private static void EnglishGreeting(string name) {
Console.WriteLine("Morning, " + name);
} private static void ChineseGreeting(string name) {
Console.WriteLine("早上好, " + name);
} static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gm.GreetPeople("Jimmy Zhang", EnglishGreeting);
gm.GreetPeople("张子阳", ChineseGreeting);
}
}
}
输出结果：
Morning, Jimmy Zhang
早上好, 张子阳

static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
GreetingDelegate delegate1;
delegate1 = EnglishGreeting;
delegate1 += ChineseGreeting;
gm.GreetPeople("Jimmy Zhang", delegate1);
}
输出：
Morning, Jimmy Zhang
早上好, Jimmy Zhang

public class GreetingManager{
//在GreetingManager类的内部声明delegate1变量
public GreetingDelegate delegate1;
public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
MakeGreeting(name);
}
}

static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gm.delegate1 = EnglishGreeting;
gm.delegate1 += ChineseGreeting;
gm.GreetPeople("Jimmy Zhang", gm.delegate1);
}输出为：
Morning, Jimmy Zhang
早上好, Jimmy Zhang

public class GreetingManager{
//在GreetingManager类的内部声明delegate1变量
public GreetingDelegate delegate1; public void GreetPeople(string name) {
if(delegate1!=null){ //如果有方法注册委托变量
delegate1(name); //通过委托调用方法
}
}
}

static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gm.delegate1 = EnglishGreeting;
gm.delegate1 += ChineseGreeting; gm.GreetPeople("Jimmy Zhang"); //注意，这次不需要再传递 delegate1变量
}输出为：
Morning, Jimmy Zhang
早上好, Jimmy Zhang

public class GreetingManager{
//这一次我们在这里声明一个事件
public event GreetingDelegate MakeGreet; public void GreetPeople(string name) {
MakeGreet(name);
}
}

static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gm.MakeGreet = EnglishGreeting; // 编译错误1
gm.MakeGreet += ChineseGreeting;
gm.GreetPeople("Jimmy Zhang");
}

private GreetingDelegate MakeGreet; //对事件的声明 实际是 声明一个私有的委托变量
[MethodImpl(MethodImplOptions.Synchronized)]
public void add_MakeGreet(GreetingDelegate value){
this.MakeGreet = (GreetingDelegate) Delegate.Combine(this.MakeGreet, value);
}
[MethodImpl(MethodImplOptions.Synchronized)]
public void remove_MakeGreet(GreetingDelegate value){
this.MakeGreet = (GreetingDelegate) Delegate.Remove(this.MakeGreet, value);
}

public sealed class GreetingDelegate:System.MulticastDelegate{
public GreetingDelegate(object @object, IntPtr method);
public virtual IAsyncResult BeginInvoke(string name, AsyncCallback callback, object @object);
public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(string name);
}

namespace Delegate {
class Heater {
private int temperature; // 水温
// 烧水
public void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i; if (temperature > ) {
MakeAlert(temperature);
ShowMsg(temperature);
}
}
} // 发出语音警报
private void MakeAlert(int param) {
Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：" , param);
} // 显示水温
private void ShowMsg(int param) {
Console.WriteLine("Display：水快开了，当前温度：{0}度。" , param);
}
}class Program {
static void Main() {
Heater ht = new Heater();
ht.BoilWater();
}
}
}

// 热水器
public class Heater {
private int temperature; // 烧水
private void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
}
}
}// 警报器
public class Alarm{
private void MakeAlert(int param) {
Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：" , param);
}
}// 显示器
public class Display{
private void ShowMsg(int param) {
Console.WriteLine("Display：水已烧开，当前温度：{0}度。" , param);
}
}

using System;
using System.Collections.Generic;
using System.Text;namespace Delegate {
// 热水器
public class Heater {
private int temperature;
public delegate void BoilHandler(int param); //声明委托
public event BoilHandler BoilEvent; //声明事件 // 烧水
public void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
if (temperature > ) {
if (BoilEvent != null) { //如果有对象注册
BoilEvent(temperature); //调用所有注册对象的方法
}
}
}
}
} // 警报器
public class Alarm {
public void MakeAlert(int param) {
Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", param);
}
} // 显示器
public class Display {
public static void ShowMsg(int param) { //静态方法
Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", param);
}
} class Program {
static void Main() {
Heater heater = new Heater();
Alarm alarm = new Alarm(); heater.BoilEvent += alarm.MakeAlert; //注册方法
heater.BoilEvent += (new Alarm()).MakeAlert; //给匿名对象注册方法
heater.BoilEvent += Display.ShowMsg; //注册静态方法
heater.BoilWater(); //烧水，会自动调用注册过对象的方法
}
}
}
输出为：
Alarm：嘀嘀嘀，水已经 度了：
Alarm：嘀嘀嘀，水已经 度了：
Display：水快烧开了，当前温度：96度。
// 省略...

using System;
using System.Collections.Generic;
using System.Text;namespace Delegate {
// 热水器
public class Heater {
private int temperature;
public string type = "RealFire 001"; // 添加型号作为演示
public string area = "China Xian"; // 添加产地作为演示
//声明委托
public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);
public event BoiledEventHandler Boiled; //声明事件 // 自定义EventArgs类 定义BoiledEventArgs类，传递给Observer所感兴趣的信息
public class BoiledEventArgs : EventArgs {
public readonly int temperature;
public BoiledEventArgs(int temperature) {
this.temperature = temperature;
}
} // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
protected virtual void OnBoiled(BoiledEventArgs e) {
if (Boiled != null) { // 如果有对象注册
Boiled(this, e); // 调用所有注册对象的方法
}
} // 烧水。
public void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
if (temperature > ) {
//建立BoiledEventArgs 对象。
BoiledEventArgs e = new BoiledEventArgs(temperature);
OnBoiled(e); // 调用 OnBolied方法
}
}
}
} // 警报器
public class Alarm {
public void MakeAlert(Object sender, Heater.BoiledEventArgs e) {
Heater heater = (Heater)sender; //这里是不是很熟悉呢？
//访问 sender 中的公共字段
Console.WriteLine("Alarm：{0} - {1}: ", heater.area, heater.type);
Console.WriteLine("Alarm: 嘀嘀嘀，水已经 {0} 度了：", e.temperature);
Console.WriteLine();
}
} // 显示器
public class Display {
public static void ShowMsg(Object sender, Heater.BoiledEventArgs e) { //静态方法
Heater heater = (Heater)sender;
Console.WriteLine("Display：{0} - {1}: ", heater.area, heater.type);
Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", e.temperature);
Console.WriteLine();
}
} class Program {
static void Main() {
Heater heater = new Heater();
Alarm alarm = new Alarm(); heater.Boiled += alarm.MakeAlert; //注册方法
heater.Boiled += (new Alarm()).MakeAlert; //给匿名对象注册方法
heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert); //也可以这么注册
heater.Boiled += Display.ShowMsg; //注册静态方法 heater.BoilWater(); //烧水，会自动调用注册过对象的方法
}
}
}输出为：
Alarm：China Xian - RealFire :
Alarm: 嘀嘀嘀，水已经 度了：
Alarm：China Xian - RealFire :
Alarm: 嘀嘀嘀，水已经 度了：
Alarm：China Xian - RealFire :
Alarm: 嘀嘀嘀，水已经 度了：
Display：China Xian - RealFire :
Display：水快烧开了，当前温度：96度。
// 省略 ...

class Program
{
// 泛型委托，与普通委托类似，不同之处只在于使用泛型委托要指定泛型参数
public delegate T MyGenericDelegate<T>(T obj1,T obj2);
int AddInt(int x, int y)
{
return x + y;
}
string AddString(string s1, string s2)
{
return s1 + s2;
}
static void Main(string[] args)
{
Program p = new Program();
MyGenericDelegate<int> intDel;
intDel = p.AddInt;
Console.WriteLine("int代理的值是{0}", intDel(, ));
MyGenericDelegate<string> stringDel;
stringDel = p.AddString;
Console.WriteLine("string代理的值是{0}", stringDel("aaa", "bbb"));
}
}

delegate void DisplayMessage(string message);
public class TestCustomDelegate
{
public static void Main()
{
DisplayMessage messageTarget;
messageTarget = ShowWindowsMessage;
messageTarget("Hello, World!");
}
private static void ShowWindowsMessage(string message)
{
MessageBox.Show(message);
}
}

public class TestAction1
{
public static void Main()
{
Action<string> messageTarget;
messageTarget = ShowWindowsMessage;
messageTarget("Hello, World!");
}
private static void ShowWindowsMessage(string message)
{
MessageBox.Show(message);
}
}

private delegate string Say();
public static string SayHello()
{
return "Hello";
}static void Main(string[] args)
{
Say say = SayHello;
Console.WriteLine(say());
Console.ReadKey();
}

public static string SayHello()
{
return "Hello";
}
static void Main(string[] args)
{
Func<string> say = SayHello;
Console.WriteLine(say());
Console.ReadKey();
}

public static string SayHello(string str)
{
return str + str;
}
static void Main(string[] args)
{
Func<string, string> say = SayHello;
string str = say("abc");
Console.WriteLine(str); //输出abcabc
Console.ReadKey();
}

using System;
using System.Drawing;
public class Example
{
public static void Main()
{
// Create an array of Point structures.
Point[] points = { new Point(, ),
new Point(, ), new Point(, ),
new Point(, ), new Point(, ) }; // Find the first Point structure for which X times Y
// is greater than 100000.
Point first = Array.Find(points, x => x.X * x.Y > ); // Display the first structure found.
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
}
}

using System;
using System.Drawing;
public class Example
{
public static void Main()
{
// Create an array of Point structures.
Point[] points = { new Point(, ),
new Point(, ), new Point(, ),
new Point(, ), new Point(, ) }; // Define the Predicate<T> delegate.
Predicate<Point> predicate = FindPoints;
// Find the first Point structure for which X times Y
// is greater than 100000.
Point first = Array.Find(points, predicate);
// Display the first structure found.
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
}
private static bool FindPoints(Point obj)
{
return obj.X * obj.Y > ;
}
}

class Program
{
static void Main(string[] args)
{
Func<int,int,int> add = (a, b) => a + b;
Calculate(add, , );
Console.ReadKey();
}
static void Calculate<T, Y, U>(Func<T, Y, U> ex, T a, Y b)
{
Console.WriteLine(ex(a, b) + "\n");
}
}

namespace ConsoleApplication1
{
public class Program
{
static void Main(string[] args)
{
Console.WriteLine("该做的东西做完，然后触发事件!");
EventSample es = new EventSample();
es.ShowComplete += es.MyEventHandler;
es.OnShowComplete();
Console.ReadKey();
}
}
public class EventSample
{
//定义一个事件
public event EventHandler ShowComplete;

//触发事件
public void OnShowComplete()
{
//判断是否绑定了事件处理方法，null表示没有事件处理方法
if (ShowComplete != null)
{
//像调用方法一样触发事件
ShowComplete(this, new EventArgs());
}
} //事件处理方法
public void MyEventHandler(object sender, EventArgs e)
{
Console.WriteLine("谁触发了我？" + sender.ToString());
}
}
}

public class Program
{
static void ShowMemory()
{
Console.WriteLine("共用内存:{0}M", GC.GetTotalMemory(true) / / );
}
static void Main(string[] args)
{
ShowMemory();
for (int i = ; i < ; i++)
{
EventSample es = new EventSample();
es.ShowComplete += es.MyEventHandler;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
ShowMemory();
}
Console.ReadKey();
}
}public class EventSample
{
byte[] m_ExtraMemory = new byte[ * * ];
//定义一个事件
public event EventHandler ShowComplete;
//触发事件
public void OnShowComplete()
{
//判断是否绑定了事件处理方法，null表示没有事件处理方法
if (ShowComplete != null)
{
//像调用方法一样触发事件
ShowComplete(this, new EventArgs());
}
}
//事件处理方法
public void MyEventHandler(object sender, EventArgs e)
{
Console.WriteLine("谁触发了我？" + sender.ToString());
}
}

public class Program
{
static void ShowMemory()
{
Console.WriteLine("共用内存:{0}M", GC.GetTotalMemory(true) / / );
}
static void Main(string[] args)
{
ShowMemory();
for (int i = ; i < ; i++)
{
Microsoft.Win32.SystemEvents.DisplaySettingsChanged += new EventHandler(new MyMethod().SystemEvents_DisplaySettingsChanged);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
ShowMemory();
}
Console.ReadKey();
}
}
public class MyMethod
{
byte[] m_ExtraMemory = new byte[ * * ];
public void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e){ }
}

public class Program
{
static void ShowMemory()
{
Console.WriteLine("共用内存:{0}M", GC.GetTotalMemory(true) / / );
}
static void Main(string[] args)
{
ShowMemory();
for (int i = ; i < ; i++)
{
using (MyMethod myMethod = new MyMethod())
{
Microsoft.Win32.SystemEvents.DisplaySettingsChanged += new EventHandler(myMethod.SystemEvents_DisplaySettingsChanged);
}
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
ShowMemory();
}
Console.ReadKey();
}
}public class MyMethod : IDisposable
{
byte[] m_ExtraMemory = new byte[ * * ];
public void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e) { }
public void Dispose()
{
Microsoft.Win32.SystemEvents.DisplaySettingsChanged -= new EventHandler(SystemEvents_DisplaySettingsChanged);
}
}