十一、C#入门基础11(委托，事件，反射）

一、委托

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。
委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。
引用可在运行时被改变。
委托（Delegate）特别用于实现事件和回调方法。
所有的委托（Delegate）都派生自 System.Delegate 类。

声明委托
委托声明决定了可由该委托引用的方法。
委托可指向一个与其具有相同标签的方法。
delegate

实例化委托
一旦声明了委托类型，委托对象必须使用 new 关键字来创建，且与 一个特定的方法有关。
当创建委托时，传递到 new 语句的参数就像方法调用一样书写，但 是不带有参数。

二、事件

事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或 者是一些出现，如系统生成的通知。应用程序需要在事件发生时响应事件。例 如，中断。事件是用于进程间通信。

事件的概念：
通过事件使用委托
事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。
包含事件的类用于发布事件。这被称为发布器（publisher） 类。
其他接受该事件的类被称为订阅器（subscriber） 类。
事件使用发布-订阅（publisher-subscriber） 模型。
发布器（publisher）是一个包含事件和委托定义的对象。
事件和委托之间的联系也定义在这个对象中。
发布器（publisher）类的对象调用这个事件，并通知其他的对象。
订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。
在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。

声明事件:
在类的内部声明事件，首先必须声明该事件的委托类型。
声明事件本身，使用 event 关键字

实现的代码（委托，事件）：

Hello类(发布器)：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11
{
    public class Hello
    {
        /// <summary>
        /// 定义好事件的委托
        /// </summary>
        public delegate void ShowHiDelegate();
        /// <summary>
        /// 定义好一个你好的事件
        /// </summary>
        public event ShowHiDelegate ShowHievent;
        /// <summary>
        /// 执行问好的方法 
        /// </summary>
        public void ClickShowHievent()
        {
            if (ShowHievent!=null)
            {           
                //执行问好的方法   
                ShowHievent();
            }
        }

    }
}

Jp类(订阅器)：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11
{
    /// <summary>
    /// 日本人
    /// </summary>
    public class Jp
    {
        public void ShowHi()
        {
            Console.WriteLine("日本人说你好");
        }


    }
}

USA类(订阅器)：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11
{
    public class USA
    {
        public void ShowHi()
        {
            Console.WriteLine("美国人说你好");
        }


    }
}

Program类(实现的类)：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11
{
    class Program
    {
        /// <summary>
        /// 可以将方法作为参数进行传递的特殊的引用类型变量
        /// 实现方法的模板->抽象类 接口 (针对于方法)
        /// 实现委托的方法必须和委托定义的是一模一样  (不能有任何改变 参数的名称可以不一样)
        /// </summary>
        //声明一个委托
        //delegate void ShowHi(string str);
        static void Main(string[] args)
        {
            //ShowHi sh = new ShowHi(ShowHi2);
            //sh("zs");


            //委托是C#中的灵魂  从软件开发的角度讲我们应该了解整个系统的流程(业务逻辑)
            //开发应该了解底层 底层:怎么走的怎么来的  



            //加事件用 +=  取消事件 -=
            //实际上事件的运行的规则和过程与委托一致
            //事件最终执行的内容依然是委托
            //事件和委托的关联是因为 在定义事件的时候就会有一个委托的定义 并且事件的类型 就是当前的委托
            //1 需要实例化你的发布器
            Hello h = new Hello();
            //2 需要实例化你的订阅器
            Jp j = new Jp();
            USA u = new USA();
            //3 给发布器加上订阅器
            h.ShowHievent += new Hello.ShowHiDelegate(j.ShowHi);
            h.ShowHievent += new Hello.ShowHiDelegate(u.ShowHi);               
            //4 给发布器去除订阅器
            h.ShowHievent -= new Hello.ShowHiDelegate(u.ShowHi);
            //执行事件
            h.ClickShowHievent();

            Console.ReadKey();

        }

        //public static void ShowHi2(string str1)
        //{
        //    Console.WriteLine("你好"+str1);
        //    Console.ReadKey();
        //}
       
            
    }
}

三、反射

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。
程序集包含模块，而模块包含类型，类型又包含成员。
反射则提供了封装程序集、模块和类型的对象。
您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。
然后，可以调用类型的方法或访问其字段和属性。

扫描二维码关注公众号，回复： 4142805 查看本文章

优点：
1、反射提高了程序的灵活性和扩展性。
2、降低耦合性，提高自适应能力。
3、它允许程序创建和控制任何类的对象，无需提前硬编码目标 类。

缺点：
1、性能问题：使用反射基本上是一种解释操作，用于字段和方 法接入时要远慢于直接代码。因此反射机制主要应用在对灵 活性和拓展性要求很高的系统框架上，普通程序不建议使 用。
2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到 程序的逻辑，反射却绕过了源代码的技术，因而会带来维护 的问题，反射代码比相应的直接代码更复杂。

反射的用途:
1.使用Assembly定义和加载程序集，加载在程序集中的所有模 块以及从此程序集中查找类型并创建该类型的实例。
2.使用Module了解包含模块的程序集以及模块中的类等，还可 以获取在模块上定义的所有全局方法或其他特定的非全局 方法。
3.使用ConstructorInfo了解构造函数的名称、参数、访问修饰 符(如pulic 或private）和实现详细信息（如abstract或 virtual)等。
4.使用MethodInfo了解方法的名称、返回类型、参数、访问修 饰符(如pulic 或private)和实现详细信息(如abstract或 virtual)等。
5.使用FiedInfo了解字段的名称、访问修饰符(如public或 private)和实现详细信息(如static)等，并获取或设置字段 值。
6.使用EventInfo了解事件的名称、事件处理程序数据类型、自 定义属性、声明类型和反射类型等，添加或移除事件处理 程序。
7.使用PropertyInfo了解属性的名称、数据类型、声明类型、 反射类型和只读或可写状态等，获取或设置属性值。
8.使用ParameterInfo了解参数的名称、数据类型、是输入参数 还是输出参数，以及参数在方法签名中的位置等。

反射用到的主要类:
1.System.Type 类
通过这个类可以访问任何给定数据类型的信息。

2.System.Reflection.Assembly 类
它可以用于访问给定程序集的信息，或者把这个程序集加载 到程序中。

System.Type类用法:
System.Type类对于反射起着核心的作用。但它是一个抽象的基类，Type有与每种数据类型对应的派生类，我们使用这个派生类的对象的方法、字段、属性来查找有关该类型的所有信息。获取给定类型的Type引用有3种常用方式：
1.使用 C# typeof 运算符
2.使用对象GetType()方法
3.调用Type类的静态方法GetType(“类的全路径”)

Type类的属性:
1.Name数据类型名
2.FullName 数据类型的完全限定名(包括命名空间名)
3.Namespace 定义数据类型的命名空间名
4.IsAbstract 指示该类型是否是抽象类型
5.IsArray 指示该类型是否是数组
6.IsClass 指示该类型是否是类
7.IsEnum 指示该类型是否是枚举
8.IsInterface 指示该类型是否是接口
9.IsPublic 指示该类型是否是公有的
10.IsSealed 指示该类型是否是密封类
11.IsValueType 指示该类型是否是值类型

Type类的方法:
1.GetConstructor(), GetConstructors()：
返回ConstructorInfo类型，用于取得该类的构造函数的信息

2.GetEvent(), GetEvents()：
返回EventInfo类型，用于取得该类的事件的信息

3.GetField(), GetFields()：
返回FieldInfo类型，用于取得该类的字段（成员变量）的 信息

4.GetInterface(), GetInterfaces()：
返回InterfaceInfo类型，用于取得该类实现的接口的信息

5.GetMember(), GetMembers()：
返回MemberInfo类型，用于取得该类的所有成员的信息

6.GetMethod(), GetMethods()：
返回MethodInfo类型，用于取得该类的方法的信息

7.GetProperty(), GetProperties()：
返回PropertyInfo类型，用于取得该类的属性的信息

System.Reflection.Assembly类的用法:
Assembly类可以获得程序集的信息，也可以动态的加载程序集，以及在程序集中查找类型信息，并创建该类型的实例。使用Assembly类可以降低程序集之间的耦合性，有利于软件结构的合理化。
1.通过程序集名称返回Assembly对象
Assembly.Load(“类名”);
2.通过DLL文件名称返回Assembly对象 Assembly.LoadFrom(@“c:\ReflectionDemo2.dll”);
3.通过Assembly获取程序集中类
Assembly对象名.GetType(“参数必须是类的全名”);
4.通过Assembly获取程序集中所有的类
Assembly对象名.GetTypes();

实现的代码：

Person类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11_1
{
    public class Person
    {
        //字段
        private int _pid;
        public  string _pname;

        //属性
        public int Pid
        {
            get
            {
                return _pid;
            }

            set
            {
                _pid = value;
            }
        }

        public string Pname
        {
            get
            {
                return _pname;
            }

            set
            {
                _pname = value;
            }
        }

        //public Person() { }

        //public Person(int _pid, string _pname)
        //{
        //    this.Pid = _pid;
        //    this.Pname = _pname;
        //}

        /// <summary>
        /// 定义好事件的委托
        /// </summary>
        public delegate void ShowHiDelegate();
        /// <summary>
        /// 定义好一个你好的事件
        /// </summary>
        public event ShowHiDelegate ShowHievent;

       
        public void PersonShow(string str)
        {
            Console.WriteLine("人"+str);
        }



    }
}

Program类(实现的类)：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace _11_1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Person p = new Person();
            //使用对象GetType()方法
            //Type t = p.GetType(); 
            //调用Type类的静态方法GetType("类的全路径")  像java class.fromname
            //Type t = Type.GetType("_11_1.Person");
            //数据类型名
            //Console.WriteLine(t.Name);
            //数据类型的完全限定名(包括命名空间名)
            //Console.WriteLine(t.FullName);
            //定义数据类型的命名空间名
            //Console.WriteLine(t.Namespace);
            //指示该类型是否是抽象类型
            //Console.WriteLine(t.IsAbstract);
            //指示该类型是否是数组
            //Console.WriteLine(t.IsArray);
            //指示该类型是否是类
            //Console.WriteLine(t.IsClass);
            //指示该类型是否是枚举
            //Console.WriteLine(t.IsEnum);
            //指示该类型是否是接口
            //Console.WriteLine(t.IsInterface);
            //指示该类型是否是公有的
            //Console.WriteLine(t.IsPublic);
            //指示该类型是否是密封类
            //Console.WriteLine(t.IsSealed);
            //指示该类型是否是值类型
            //Console.WriteLine(t.IsValueType);
            //Console.ReadKey();

            //Type t = Type.GetType("_11_1.Person");
            //object objects =Activator.CreateInstance(t);

            //1.返回ConstructorInfo类型，用于取得该类的构造函数的信息
            //Type[] types = new Type[0];
            //ConstructorInfo c=t.GetConstructor(types);
            //Console.WriteLine(c.IsPublic);

            //2.返回EventInfo类型，用于取得该类的事件的信息
            //EventInfo[] ei= t.GetEvents();
            //foreach (EventInfo e in ei)
            //{
            //    Console.WriteLine(e.Name);
            //}

            //3.返回FieldInfo类型，用于取得该类的字段（成员变量）的信息
            //FieldInfo fi = t.GetField("_pname");
            //Person p=new Person(); p.setpname="zs";            
            //fi.SetValue(objects,"zs");
            //Console.WriteLine(fi.GetValue(objects));   

            //4.返回MemberInfo类型，用于取得该类的所有成员的信息
            //MemberInfo[] mb=t.GetMember("ShowHiDelegate");
            //foreach (MemberInfo m in mb)
            //{
            //    Console.WriteLine(m.Name);
            //}

            //5.返回MethodInfo类型，用于取得该类的方法的信息
            //MethodInfo[] mi=t.GetMethods();
            //foreach (MethodInfo item in mi)
            //{
            //    Console.WriteLine(item.Name);
            //}

            //6.返回PropertyInfo类型，用于取得该类的属性的信息
            //PropertyInfo pi =t.GetProperty("Pname");
            //set_Pname
            //pi.SetValue(objects,"zs");
            //get_Pname
            //Console.WriteLine(pi.GetValue(objects));

            //反射调用方法
            //MethodInfo mi=t.GetMethod("PersonShow");
            //object[] oo =new object[1];
            //oo[0] = "zs";
            //mi.Invoke(objects,oo);

            //Assembly as1=Assembly.Load("Person");
            Assembly as1 = Assembly.LoadFrom(@"D:\Visual Studio 2015\Projects\217Base\11\bin\Debug\11.dll");
            Type[] t=as1.GetTypes();
            foreach (Type item in t)
            {
                Console.WriteLine(item.Name);
            }

            Console.ReadKey();



        }
    }
}