简单说说委托和事件

委托：
首先说委托，委托其实是代表了一类方法，这一类方法有相同的返回值和参数。比如public delegate string ActionHandle(string str,int i);就表示返回值是string并且传入两个参数，第一个参数是字符串，第二个参数是int型的一类方法。

OperateDelegate通过三种不同的方法使用委托，包括匿名委托，lamda表达式和单独的方法。总的来说，在我的印象中，委托比起事件来，更加面向过程，属于过程中出现的东西

事件：
相对来说，事件是更加面向对象的，我们知道，一个类一般肯定有属性（没有属性的类是在不多）。我们早已习惯了这样的代码：
var dog=new Dog();
dog.Name="herry";
这是因为Dog类中有Name这个属性，即 public string Name{get;set;}
那么如果Dog类中有这样的一个事件，即 public event Handle.ActionHandle Hungry;我们该怎么赋值呢？（ActionHandle是一个委托，我们可以看作是事件的“类型”，就如同string是Name的类型一样，ActionHandle自然是Hungry的类型，蓦然看去，属性和事件其实是如此相似）
我们可以那样赋值：
dog.Hungry+=(str,i)=>{return string.Format("{0} is hungry, she is {1} years old.", str, i);}（有了lamda表达式后，属性和事件就更加相似了）。
其实，我是反对事件是一种特殊的委托这一种说法的，我感觉事件和属性更加相似。说事件是一种特殊的委托，就如同说属性是一种特殊的object，感觉很是奇怪。
当然，我们可以用如下的方法注册事件（初始化事件）：
dog.Hungry += new ActionHandle(pet_Hungry);
static string pet_Hungry(string str, int i)
{
    return string.Format("{0} is hungry for {1} days", str, i);
}
我这里只说了将事件理解为属性的感悟，代码如下：

MyDelegate.cs

代码

namespace DelegateEvent.Handle
{
/// <summary>
/// 定义一个委托，返回值为string，传入参数分别为string和int
/// 使用委托，更加面向过程一些。
/// </summary>
/// <param name="str"></param>
/// <param name="i"></param>
/// <returns></returns>
public delegate string ActionHandle( string str, int i);

public static class TestDelegate
{
/// <summary>
/// 该方法展示了对于委托的三种常用的使用方法
/// </summary>
public static void OperateDelegate()
{
// 1、使用匿名委托。
ActionHandle action1 = delegate ( string name, int age) { return string .Format( " name:{0},age:{1} " , name, age); };
Console.WriteLine(action1( " zhangsan " , 23 ));

// 2、使用lamda表达式
ActionHandle action2 = (job, years) => { return string .Format( " He has job of {0} {1} years " , job, years); };
Console.WriteLine(action2( " doctor " , 10 ));

// 3、使用已知函数
ActionHandle action3 = Action;
Console.WriteLine(action3( " aaa " , 3 ));
}

/// <summary>
/// 符合委托形式的方法
/// </summary>
/// <param name="str"></param>
/// <param name="i"></param>
/// <returns></returns>
public static string Action( string str, int i)
{
return str + " & " + i.ToString();
}

public static void OperateEvent()
{
var pet1 = new Dog() { Name = " Jim " };
pet1.Hungry += new ActionHandle(pet_Hungry);
// pet1.Hungry += (str, i) => { return str + i.ToString(); };
pet1.OnHungry();

var pet2 = new Cat() { Name = " Bill " };
pet2.Hungry += (str, i) => { return string .Format( " {0} is hungry, she is {1} years old. " , str, i); };
pet2.OnHungry();
}

static string pet_Hungry( string str, int i)
{
return string .Format( " {0} is hungry for {1} days " , str, i);
}


}
}

Pet.cs

 

代码

namespace DelegateEvent.Pet
{
public abstract class Pet
{
public abstract string Name { get ; set ; }
public abstract event DelegateEvent.Handle.ActionHandle Hungry;
public abstract void OnHungry();
}
}

Cat.cs

 

代码

namespace DelegateEvent.Pet
{
/// <summary>
/// 都是继承自抽象的类pet，重写了字段名Name，事件Hungry和方法OnHungry
/// </summary>
public class Cat : Pet
{
// 重写name方法
public override string Name
{
get ;
set ;
}

// 重写事件Hungry
public override event Handle.ActionHandle Hungry;

// 重写方法OnHungry
public override void OnHungry()
{
if (Hungry != null )
{
var info = Hungry( " cat " + Name, 6 );
Console.WriteLine(info);
}
}
}
}

Dog.cs

转载于:https://www.cnblogs.com/sinianyufang/archive/2010/06/21/1762301.html