简单说说委托和事件

委托：
首先说委托，委托其实是代表了一类方法，这一类方法有相同的返回值和参数。比如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