接口、委托、事件

接口和抽象类： 

     为了更好的理解接口，最常见的问题莫过于接口和抽象类的区别。接口和抽象类却存在实实在在的差异，具体体现在：

1.一个类可以实现任意多个接口，但是最多只能对一个抽象类进行子类化；

2.一个抽象类可以包括非抽象方法，而一个接口的所有方法在效果上都是抽象的；

3.一个抽象类可以声明并使用变量，而一个接口不能；

4.一个抽象类中的方法的访问修饰符可以是：public，internal，protected，protected internal，或者private，而接口中默认情况下都是public，而且在声明接口成员时，不允许使用访问修饰符；

5.一个抽象类可以定义构造函数，而一个接口不能； 

上述5点区别主要是使用上，之所以将其区分开，是因为其使用场景是不同的 ，即功用性所在，主要可概括为：抽象类用在具有族层关系的继承关系上；而接口用在具有功能性意义上。

接口中属性的实现： 

     通常情况下接口中都是对应方法，然而其确实可以对属性 进行同样操作,先看如下代码：

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication5
{
    public interface CeShi
    {
        int DA { get; }//只读
        string wenben { get; set; }
    }
    public class Jc : CeShi
    {
        private int da;
        private string Wenben;
        public int DA
        {
            get { return da; }
        }
        public string wenben
        {
            get { return Wenben; }
            set { Wenben = value; }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Jc jc = new Jc();
            jc.wenben = "测试";
            Console.WriteLine("da:{0},wenben:{1}", jc.DA, jc.wenben);
            Console.ReadLine();
        }
    }
}

委托概述： 

   在 C 语言 的多种类型指针中，有一种叫做“函数指针”，即是指函数的入口地址。在 C# 中委托的概念与其相类似。而与C 语言中函数指针不同的是，.NET 中的委托是类型安全的。

委托的使用：

　　同使用一个类相类似，首先定义要使用的委托，这里规定了委托所代表的哪种类型的方法； 其次创建该委托的一个或多个实例。这里举一示范代码：

namespace ConsoleApplication5
{
   
    class Program
    {
        //委托的定义，制定对应方法的类型
        public delegate int DelegateShowInt(int i);
        public static int ShowData(int i)
        {
            return i + 1;
        }

        static void Main(string[] args)
        {
            DelegateShowInt showInt = new DelegateShowInt(ShowData);
            Console.WriteLine("结果:{0}", showInt(1));
            Console.ReadLine();
        }
    }
}

　　上例可见一般情况下，委托的应用，即在对应一个方法使用委托的情况下。

　　注意：

 　　对于式：DelegateShowInt showInt = new DelegateShowInt(ShowData) 可以认为是所有委托都有的“构造函数”形式——其参数是函数引用。

多播委托： 

　　前面例子中是最为简单、常用的一种形式（一个委托实例，调用一个方法）。因为我们可以实例化一个或多个某种委托的实例，另一方面，我们也可以让一个委托调用多个方法，这里称作多播委托。 

namespace ConsoleApplication5
{
   
    class Program
    {
        //定义委托,注意返回类型为 ：void
        public delegate void DelegateShowInt(int i);
        public static void ShowData(int i)
        {
            Console.WriteLine("输出结果:{0}", i);
        }
        public static void ShowData2(int i)
        {
            Console.WriteLine("输出结果:{0}", i + 1);
        }


        static void Main(string[] args)
        {
            //多播委托的使用方法：+=
            //委托可以使用“+”运算符号将多个委托组合在一起，或使用“-”运算符号从组合委托中减去一个委托
            DelegateShowInt showInt = new DelegateShowInt(ShowData);//实例委托实例
            showInt += new DelegateShowInt(ShowData2);
            showInt(1);//可以直接使用委托调用ShowData方法
            showInt(2);
            Console.ReadLine();
        }
    }
}

　　通过实例，可见我们对委托对象，实现了多个方法的绑定。

　　注意： 之所以要求多播委托的返回类型为void，是因为如果有返回值，将没有意义，起到作用的只有最后一个被调用的函数而已！

事件概述： 

   有了前述对委托的讲述，为这里讲解事件做好了铺垫。事件，其在Windows Form中得到极大应用，这里举一最常见的点击按钮，触发事件的例子。 

　　　　　　　this.button.Location = new System.Drawing.Point(458, 125);
            this.button.Name = "button";
            this.button.Size = new System.Drawing.Size(75, 23);
            this.button.TabIndex = 2;
            this.button.Text = "测算";
            this.button.UseVisualStyleBackColor = true;
            this.button.Click += new System.EventHandler(this.button_Click);

这是Windows Form中加入的一个Button按钮，在第7行，对对象button的事件Click赋予了委托，该委托指定了形式：

private void button_Click(object sender, EventArgs e)
        {

        }

 　对应类型的参数含有object和EventArgs，并且返回为void形式。这样事件就与委托相联系上。

综上可见：

1.委托，作为一种特殊的类型，雷同于定义一个类（实际上，后台即是将其作为类处理） ；

2.事件，规范了其类型（委托类型）；

综上之，之所以接口不能包含委托，而接口为什么可以包含事件呢？

因为委托是一种与类同等地位的特殊类型（类的实例是存储数据的托管内存空间，而委托则只有方法地址而已），故接口不能包含委托；事件从地位上不与类、接口同一层次，事件的独特机制使得事件可以是一个接口的标准组成部分，只要继承的类包含一个public事件成员。

自定义事件：

namespace ConsoleApplication5
{
    //先定义一委托类型
    public delegate void DelegateDog();
    public class Dog
    {
        //定义事件类型，其类型对应于自定义委托类型
        public event DelegateDog EventDog;
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public void Invoked()
        {
            //使用事件方法：像使用其对应方法一样使用
            EventDog();
        }
        class Program
        {
            public static void Response()
            {
                Console.WriteLine("输出内容");
            }
            static void Main(string[] args)
            {
                Dog dog = new Dog();
                dog.Name = "AA";
                //对事件的操作，使之与对应委托相关，委托调用Response方法
                dog.EventDog += new DelegateDog(Response);
                //触发事件
                dog.Invoked();
                Console.ReadLine();
            }

        }
    }
}

从上例，可以看到自定义事件的从定义、赋值、使用等个部分的方法，也可以加深对事件的了解。