您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496netnet中的反射,完成数据库访问类反射

新葡亰496netnet中的反射,完成数据库访问类反射

发布时间:2019-08-23 13:06编辑:奥门新萄京娱乐场浏览(116)

    那篇来看一下反光的利用!举例!

    反射是.NET中的首要机制,通过反射,能够在运转时获得程序或程序集中每二个品类(包罗类、结构、委托、接口和枚举等)的成员和成员的音讯。有了反光,就可以对每三个项目了然于胸。其它作者仍是能够直接创设对象,尽管那一个指标的品种在编写翻译时还不知情。 
        
    反射的用处:
        (1)使用Assembly定义和加载程序集,加载在程序集清单中列出模块,以及以往程序聚焦查找类型并创立该类型的实例。 
        (2)使用Module领悟包蕴模块的先后集以及模块中的类等,还足以获取在模块上定义的具有全局方法或其余特定的非全局方法。 
        (3)使用ConstructorInfo理解构造函数的称呼、参数、访谈修饰符(如pulic 或private)和促成详细音信(如abstract或virtual)等。 
        (4)使用MethodInfo精通方法的称呼、重临类型、参数、访谈修饰符(如pulic 或private)和达成详细音信(如abstract或virtual)等。
        (5)使用FiedInfo理解字段的称号、访谈修饰符(如public或private)和达成详细音讯(如static)等,并收获或设置字段值。
        (6)使用伊夫ntInfo掌握事件的称号、事件管理程序数据类型、自定义属性、注脚类型和反光类型等,增加或移除事件管理程序。 
        (7)使用PropertyInfo领悟属性的名号、数据类型、注解类型、反射类型和只读或可写状态等,获取或安装属性值。 
        (8)使用ParameterInfo理解参数的名号、数据类型、是输入参数依然出口参数,以及参数在措施具名中的地方等。

    反射是.NET中的首要机制,通过反射,能够在运行时获得程序或程序聚焦每一个品种(包涵类、结构、委托、接口和枚举等)的积极分子和成员的消息。有了反光,就能够对每一个种类心中有数。其他作者还足以一贯创立对象,即便这么些指标的品类在编写翻译时还不知道。

    初稿地址:

    反射(Reflection)

    新葡亰496net 1

    反射用到的命名空间:     System.Reflection
        System.Type
        System.Reflection.Assembly
        
    反射用到的显要类:
        System.Type 类--通过那一个类能够访谈任何给定数据类型的消息。
        System.Reflection.Assembly类--它可以用于访谈给定程序集的新闻,恐怕把这些顺序集加载到程序中。
        
    System.Type类:
        System.Type 类对于反射起着主导的法力。但它是三个浮泛的基类,Type有与每一个数据类型对应的派生类,大家选用那几个派生类的对象的章程、字段、属性来寻觅有关该项指标保有音信。
        获取给定类型的Type引用有3种常用方式:
        ●使用 C# typeof 运算符。
            Type t = typeof(string);
        ●使用对象GetType()方法。
            string s = "grayworm";
            Type t = s.GetType();
     
        ●还足以调用Type类的静态方法GetType()。
            Type t = Type.GetType("System.String");
           
        上边那三类代码都以获得string类型的Type,在抽出string类型的Type援用t后,大家就足以因而t来探测string类型的布局了。 
                string n = "grayworm";
                Type t = n.GetType();
                foreach (MemberInfo mi in t.GetMembers())
                {
                    Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name);
                }
        
        Type类的属性:         Name 数据类型名
            FullName 数据类型的一点一滴限定名(富含取名空间名)
            Namespace 定义数据类型的命名空间名
            IsAbstract 提示该类型是或不是是抽象类型
            IsArray   提示该品种是或不是是数组
            IsClass   提示该品种是还是不是是类
            IsEnum   提醒该项目是或不是是枚举
            IsInterface    指示该类型是不是是接口
            IsPublic 提示该品种是或不是是公有的
            IsSealed 提醒该品种是还是不是是密封类
            IsValueType 提示该项目是不是是值类型
        Type类的措施:         GetConstructor(), GetConstructors():重临ConstructorInfo类型,用于获取该类的构造函数的新闻
            Get伊夫nt(), GetEvents():重临EventInfo类型,用于获取该类的平地风波的音讯
            GetField(), GetFields():重临菲尔德Info类型,用于获取该类的字段(成员变量)的音信
            GetInterface(), GetInterfaces():重返InterfaceInfo类型,用于获取该类完毕的接口的消息
            GetMember(), GetMembers():再次来到MemberInfo类型,用于获取该类的富有成员的音讯
            GetMethod(), GetMethods():重返MethodInfo类型,用于获取该类的格局的新闻
            GetProperty(), GetProperties():重返PropertyInfo类型,用于获取该类的品质的新闻
        能够调用那个分子,其方法是调用Type的InvokeMember()方法,只怕调用MethodInfo, PropertyInfo和任何类的Invoke()方法。 
        
        查看类中的构造方法:
            NewClassw nc = new NewClassw();
            Type t = nc.GetType();         ConstructorInfo[] ci = t.GetConstructors();    //获取类的拥有构造函数
            foreach (ConstructorInfo c in ci) //遍历种种构造函数
            {
                ParameterInfo[] ps = c.GetParameters();    //收取每一种构造函数的享有参数
                foreach (ParameterInfo pi in ps)   //遍历并打字与印刷所该构造函数的持有参数
                {
                    Console.Write(pi.ParameterType.ToString() " " pi.Name ",");
                }
                Console.WriteLine();
            }
        
        用构造函数动态变化对象:         Type t = typeof(NewClassw);
            Type[] pt = new Type[2];         pt[0] = typeof(string);
            pt[1] = typeof(string);
            //依据参数类型获取构造函数 
            ConstructorInfo ci = t.GetConstructor(pt);          //构造Object数组,作为构造函数的输入参数 
            object[] obj = new object[2]{"grayworm","hi.baidu.com/grayworm"};   
            //调用构造函数生成对象 
            object o = ci.Invoke(obj);             //调用生成的目的的格局测量检验是不是对象生成成功 
            //((NewClassw)o).show();    
        
        用Activator生成对象:         Type t = typeof(NewClassw);
            //构造函数的参数 
            object[] obj = new object[2] { "grayworm", "hi.baidu.com/grayworm" };   
            //用Activator的CreateInstance静态方法,生成新对象 
            object o = Activator.CreateInstance(t,"grayworm","hi.baidu.com/grayworm");          //((NewClassw)o).show();

    反射的用处:
    (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、B型超声检查判断:大家体格检查的时候大概都做过B型超声会诊吧,B型超声检查判断能够经过肚皮探测到您内脏的生理处境。那是怎么产生的吧?B型超声检查判断是B型超声波,它可以由此肚皮通过向你体内发出B型超声波,当超声波遇到内脏壁的时候就能够时有爆发一定的“回音”反射,然后把“回音”举行拍卖就能够来得出内脏的意况了(小编不是先生亦非声学专家,不知说得是否正确^_^)。
    2、地球内部结构:地球的内部结构概略能够分成三层:地壳、地幔和地核。地壳是固体,地核是液体,地幔则是半液半固的结构(中学地理的情节,我们还记得呢?)。怎样在地表不用深刻地球内部就了解当中间的协会呢?对,向地球发射“地震波”,“地震波”分三种一种是“横波”,另一种是“纵波”。“横波”只好穿透固体,而“纵波”既可穿透固体又足以穿透液体。通过在地头对纵波和横波的反回意况,我们就足以概况剖断地球内部的结构了。

    2008年01月02日 星期三 11:21

    譬如子,确定需求二个类,先建二个上学的儿童类:

        查看类中的属性:         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            PropertyInfo[] pis = t.GetProperties();         foreach(PropertyInfo pi in pis)
            {
                Console.WriteLine(pi.Name);
            }
        
        查看类中的public方法:         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            MethodInfo[] mis = t.GetMethods();         foreach (MethodInfo mi in mis)
            {
                Console.WriteLine(mi.ReturnType " " mi.Name);
            }
        
        查看类中的public字段         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            FieldInfo[] fis = t.GetFields();
            foreach (FieldInfo fi in fis)
            {
                Console.WriteLine(fi.Name);
            } ()
           
        用反射生成对象,并调用属性、方法和字段进行操作          NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            object obj = Activator.CreateInstance(t);
            //取得ID字段 
            FieldInfo fi = t.GetField("ID");
            //给ID字段赋值 
            fi.SetValue(obj, "k001");
            //取得MyName属性 
            PropertyInfo pi1 = t.GetProperty("MyName");
            //给MyName属性赋值 
            pi1.SetValue(obj, "grayworm", null);
            PropertyInfo pi2 = t.GetProperty("MyInfo");
            pi2.SetValue(obj, "hi.baidu.com/grayworm", null);
            //取得show方法 
            MethodInfo mi = t.GetMethod("show");
            //调用show方法 
            mi.Invoke(obj, null);
            
    System.Reflection.Assembly类 
         Assembly类可以获取程序集的音信,也得以动态的加载程序集,以及在前后相继聚焦查找类型音信,并制造该品种的实例。
        使用Assembly类能够下跌程序集以内的耦合,有助于软件结构的合理化。
        
        经过程序集名称再次回到Assembly对象
            Assembly ass = Assembly.Load("ClassLibrary831");
        通过DLL文件名称重回Assembly对象
            Assembly ass = Assembly.LoadFrom("ClassLibrary831.dll");
        通过Assembly获取程序集中类
     
            Type t = ass.GetType("ClassLibrary831.NewClass");   //参数必得是类的真名
        通过Assembly获取程序聚集具备的类
            Type[] t = ass.GetTypes();
           
        //通进程序集的名目反射     Assembly ass = Assembly.Load("ClassLibrary831");
        Type t = ass.GetType("ClassLibrary831.NewClass");
        object o = Activator.CreateInstance(t, "grayworm", "");
        MethodInfo mi = t.GetMethod("show");
        mi.Invoke(o, null);

    反射用到的命名空间: System.Reflection
    System.Type
    System.Reflection.Assembly

    世家小心到这两个例证的联合特征,正是从贰个对象的外表去打听对象内部的结构,何况都以行使了波的反光成效。在.NET中的反射也能够达成从指标的表面来了然对象(或程序集)内部结构的功力,哪怕你不知晓那些目的(或程序集)是个什么东西,别的.NET中的反射还足以运态创制出指标并实施它个中的点子。

    七个有血有肉中的例子:
    1、B型超声会诊:咱们体格检查的时候大致都做过B型超声会诊吧,B型超声检查判断能够经过肚皮探测到您内脏的生理情形。那是哪些产生的啊?B超是B型超声波,它能够由此肚皮通过向你体内发出B型超声波,当超声波碰着内脏壁的时候就能产生一定的“回音”反射,然后把“回音”实行拍卖就能够呈现出内脏的图景了(作者不是先生亦非声学专家,不知说得是否精确^_^)。
    2、地球内部结构:地球的内部结构轮廓能够分成三层:地壳、地幔和地核。地壳是固体,地核是液体,地幔则是半液半固的结构(中学地理的剧情,我们还记得呢?)。如何在地表不用深刻地球内部就通晓在那之中间的协会呢?对,向地球发射“地震波”,“地震波”分三种一种是“横波”,另一种是“纵波”。“横波”只可以穿透固体,而“纵波”既可穿透固体又足以穿透液体。通过在地点对纵波和横波的反回境况,大家就足以大约推断地球内部的结构了。

    public class Student
    {
      public int Status;
        public int Id { get; set; }
        public string Name { get; set; }
        public string Sex { get; set; }
    
        public void Show()
        {
           Console.WriteLine("姓名:{0}", Name);
        }
    }
    

       //通过DLL文件全名反射在那之中的富有项目
        Assembly assembly = Assembly.LoadFrom("xxx.dll的路径");
        Type[] aa = a.GetTypes();

    反射用到的机要类:
    System.Type 类--通过那个类可以访问任何给定数据类型的音信。
    System.Reflection.Assembly类--它能够用于访谈给定程序集的音讯,恐怕把这一个顺序集加载到程序中。

    反射是.NET中的主要机制,通过反射,能够在运转时获得程序或程序集中每二个品种(富含类、结构、委托、接口和枚举等)的积极分子和成员的信息。有了反光,就可以对每贰个体系了然于胸。其他我还足以一向创造对象,纵然这些指标的项目在编写翻译时还不精通。 
        
    反射的用处:
        (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理解参数的名目、数据类型、是输入参数照旧出口参数,以及参数在艺术具名中的地方等。

    世家只顾到那七个例证的一同特征,就是从一个对象的外表去询问对象内部的布局,况且都以行使了波的反光成效。在.NET中的反射也可以达成从目的的外表来打探对象(或程序集)内部结构的效用,哪怕你不知情这一个目的(或程序集)是个什么样东西,别的.NET中的反射还可以运态创设出目的并推行它个中的不二诀要。

    多个属性,Id,Name,Sex。三个字段Status,七个艺术Show.

        foreach(Type t in aa)
        {
            if(t.FullName == "a.b.c")
            {
                object o = Activator.CreateInstance(t);
            }
        }

    System.Type类:
    System.Type 类对于反射起着主导的功用。但它是三个空洞的基类,Type有与每个数据类型对应的派生类,大家运用那一个派生类的靶子的方式、字段、属性来搜求有关该类型的拥有音信。
    赢得给定类型的Type援引有3种常用格局:
    ●使用 C# typeof 运算符。
    Type t = typeof;
    ●使用对象GetType()方法。
    string s = "grayworm";
    Type t = s.GetType();**

    ●还能调用Type类的静态方法GetType()。
    Type t =Type.GetType("System.String");
    **
    地方那三类代码都以获得string类型的Type,在抽出string类型的Type援用t后,大家就足以由此t来探测string类型的布局了。
    string n = "grayworm";
    Type t =n.GetType();
    foreach(MemberInfo mi in t.GetMembers
    {
    Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name);
    }

    反射用到的命名空间:     System.Reflection
        System.Type
        System.Reflection.Assembly
        
    反射用到的首要类:
        System.Type 类--通过那几个类能够访问任何给定数据类型的音讯。
        System.Reflection.Assembly类--它能够用来访谈给定程序集的新闻,或许把那一个程序集加载到程序中。
        
    System.Type类:
        System.Type 类对于反射起着主导的作用。但它是三个华而不实的基类,Type有与种种数据类型对应的派生类,大家利用那几个派生类的对象的方法、字段、属性来查找有关该项指标享有信息。
        获取给定类型的Type援用有3种常用方式:
        ●使用 C# typeof 运算符。
            Type t = typeof(string);
        ●使用对象GetType()方法。
            string s = "grayworm";
            Type t = s.GetType(); 
        ●还足以调用Type类的静态方法GetType()。
            Type t = Type.GetType("System.String");
           
        上边那三类代码都是获取string类型的Type,在收取string类型的Type引用t后,大家就足以透过t来探测string类型的组织了。 
                string n = "grayworm";
                Type t = n.GetType();
                foreach (MemberInfo mi in t.GetMembers())
                {
                    Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name);
                }
        
        Type类的习性:         Name 数据类型名
            FullName 数据类型的通通限定名(包涵取名空间名)
            Namespace 定义数据类型的命名空间名
            IsAbstract 提醒该类型是或不是是抽象类型
            IsArray   提醒该品种是或不是是数组
            IsClass   提醒该项目是还是不是是类
            IsEnum   提示该项目是不是是枚举
            IsInterface    提醒该类型是或不是是接口
            IsPublic 提醒该品种是或不是是公有的
            IsSealed 提示该品种是不是是密封类
            IsValueType 提示该项目是或不是是值类型
        Type类的法子:         GetConstructor(), GetConstructors():再次来到ConstructorInfo类型,用于获取该类的构造函数的消息
            GetEvent(), Get伊夫nts():重回伊夫ntInfo类型,用于获取该类的风浪的新闻
            GetField(), GetFields():重临菲尔德Info类型,用于获取该类的字段(成员变量)的音讯
            GetInterface(), GetInterfaces():重返InterfaceInfo类型,用于获取该类达成的接口的音讯
            GetMember(), GetMembers():重回MemberInfo类型,用于获取该类的有所成员的新闻
            GetMethod(), GetMethods():再次回到MethodInfo类型,用于获取该类的点子的新闻
            GetProperty(), GetProperties():重临PropertyInfo类型,用于获取该类的习性的音讯
        能够调用这么些成员,其情势是调用Type的InvokeMember()方法,只怕调用MethodInfo, PropertyInfo和其他类的Invoke()方法。 
        
        查看类中的构造方法:
            NewClassw nc = new NewClassw();
            Type t = nc.GetType();         ConstructorInfo[] ci = t.GetConstructors();    //获取类的全数构造函数
            foreach (ConstructorInfo c in ci) //遍历每三个构造函数
            {
                ParameterInfo[] ps = c.GetParameters();    //抽出每一个构造函数的持有参数
                foreach (ParameterInfo pi in ps)   //遍历并打字与印刷所该构造函数的有着参数
                {
                    Console.Write(pi.ParameterType.ToString() " " pi.Name ",");
                }
                Console.WriteLine();
            }
        
        用构造函数动态变化对象:         Type t = typeof(NewClassw);
            Type[] pt = new Type[2];         pt[0] = typeof(string);
            pt[1] = typeof(string);
            //依据参数类型获取构造函数 
            ConstructorInfo ci = t.GetConstructor(pt);          //构造Object数组,作为构造函数的输入参数 
            object[] obj = new object[2]{"grayworm","hi.baidu.com/grayworm"};   
            //调用构造函数生成对象 
            object o = ci.Invoke(obj);             //调用转变的指标的主意测量试验是不是对象生成成功 
            //((NewClassw)o).show();    
        
        用Activator生成对象:         Type t = typeof(NewClassw);
            //构造函数的参数 
            object[] obj = new object[2] { "grayworm", "hi.baidu.com/grayworm" };   
            //用Activator的CreateInstance静态方法,生成新对象 
            object o = Activator.CreateInstance(t,"grayworm","hi.baidu.com/grayworm");          //((NewClassw)o).show();

    反射是.NET中的首要体制,通过反射,能够在运作时收获程序或程序集中每多个门类(包罗类、结构、委托、接口和枚举等)的分子和分子的新闻。有了反光,就能够对每八个品种成竹在胸。其余笔者还足以平素创立对象,固然那一个指标的种类在编写翻译时还不知底。
       
    反射的用途:
        (1)使用Assembly定义和加载程序集,加载在前后相继集清单中列出模块,以及以往程序集中查找类型并创设该项指标实例。
        (2)使用Module领悟富含模块的主次集以及模块中的类等,还能收获在模块上定义的具有全局方法或其余特定的非全局方法。
        (3)使用ConstructorInfo领会构造函数的称谓、参数、访谈修饰符(如pulic 或private)和促成详细音信(如abstract或virtual)等。
        (4)使用MethodInfo领悟方法的称谓、重返类型、参数、访问修饰符(如pulic 或private)和达成详细音讯(如abstract或virtual)等。
        (5)使用FiedInfo明白字段的称呼、访谈修饰符(如public或private)和完毕详细音信(如static)等,并拿走或安装字段值。
        (6)使用伊芙ntInfo明白事件的称呼、事件管理程序数据类型、自定义属性、注解类型和反光类型等,增多或移除事件管理程序。
        (7)使用PropertyInfo领会属性的称号、数据类型、申明类型、反射类型和只读或可写状态等,获取或设置属性值。
        (8)使用ParameterInfo驾驭参数的名号、数据类型、是输入参数仍然出口参数,以及参数在措施签名中的地点等。

    嗯~,破费科特。

     

    Type类的习性: Name 数据类型名
    FullName 数据类型的一心限定名(包含取名空间名)
    Namespace 定义数据类型的命名空间名
    IsAbstract 提醒该项目是不是是抽象类型
    IsArray 提醒该类型是还是不是是数组
    IsClass 提示该品种是不是是类
    IsEnum 提示该项目是不是是枚举
    IsInterface 提示该类型是还是不是是接口
    IsPublic 提示该品种是或不是是公有的
    IsSealed 提示该项目是或不是是密闭类
    IsValueType 提醒该类型是或不是是值类型
    Type类的格局: GetConstructor(), GetConstructors():再次回到ConstructorInfo类型,用于获取该类的构造函数的新闻
    GetEvent(), Get伊夫nts():重临EventInfo类型,用于获取该类的事件的音讯
    GetField(), Get菲尔德s():重临FieldInfo类型,用于获取该类的字段的消息
    GetInterface(), GetInterfaces():重回InterfaceInfo类型,用于获取该类完成的接口的消息
    GetMember(), GetMembers():重回MemberInfo类型,用于获取该类的全部成员的音信
    GetMethod(), GetMethods():重回MethodInfo类型,用于获取该类的情势的音讯
    GetProperty(), GetProperties():重临PropertyInfo类型,用于获取该类的性质的新闻
    可以调用这么些分子,其艺术是调用Type的InvokeMember()方法,或许调用MethodInfo, PropertyInfo和其余类的Invoke()方法。

        查看类中的属性:         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            PropertyInfo[] pis = t.GetProperties();         foreach(PropertyInfo pi in pis)
            {
                Console.WriteLine(pi.Name);
            }
        
        查看类中的public方法:         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            MethodInfo[] mis = t.GetMethods();         foreach (MethodInfo mi in mis)
            {
                Console.WriteLine(mi.ReturnType " " mi.Name);
            }
        
        查看类中的public字段         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            FieldInfo[] fis = t.GetFields();
            foreach (FieldInfo fi in fis)
            {
                Console.WriteLine(fi.Name);
            } ()
           
        用反射生成对象,并调用属性、方法和字段举行操作          NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            object obj = Activator.CreateInstance(t);
            //取得ID字段 
            FieldInfo fi = t.GetField("ID");
            //给ID字段赋值 
            fi.SetValue(obj, "k001");
            //取得MyName属性 
            PropertyInfo pi1 = t.GetProperty("MyName");
            //给MyName属性赋值 
            pi1.SetValue(obj, "grayworm", null);
            PropertyInfo pi2 = t.GetProperty("MyInfo");
            pi2.SetValue(obj, "hi.baidu.com/grayworm", null);
            //取得show方法 
            MethodInfo mi = t.GetMethod("show");
            //调用show方法 
            mi.Invoke(obj, null);
            
    System.Reflection.Assembly类 
         Assembly类能够博得程序集的消息,也得以动态的加载程序集,以及在程序集中查找类型音讯,并创设该类型的实例。
        使用Assembly类能够下跌程序集以内的耦合,有助于软件结构的合物理和化学。
        
        因此程序集名称重临Assembly对象
            Assembly ass = Assembly.Load("ClassLibrary831");
        通过DLL文件名称重返Assembly对象
            Assembly ass = Assembly.LoadFrom("ClassLibrary831.dll");
        通过Assembly获取程序聚焦类 
            Type t = ass.GetType("ClassLibrary831.NewClass");   //参数必需是类的人名
        通过Assembly获取程序集中具有的类
            Type[] t = ass.GetTypes();
           
        //通进度序集的称呼反射     Assembly ass = Assembly.Load("ClassLibrary831");
        Type t = ass.GetType("ClassLibrary831.NewClass");
        object o = Activator.CreateInstance(t, "grayworm", "");
        MethodInfo mi = t.GetMethod("show");
        mi.Invoke(o, null);

    反射用到的命名空间:     System.Reflection
        System.Type
        System.Reflection.Assembly
       
    反射用到的主要性类:
        System.Type 类--通过这么些类能够访谈任何给定数据类型的消息。
        System.Reflection.Assembly类--它能够用于访谈给定程序集的音信,大概把那一个顺序集加载到程序中。
       
    System.Type类:
        System.Type 类对于反射起着主导的功效。但它是二个浮泛的基类,Type有与每一个数据类型对应的派生类,大家运用那么些派生类的目的的艺术、字段、属性来搜寻有关该品种的兼具音信。
        获取给定类型的Type引用有3种常用格局:
        ●使用 C# typeof 运算符。
            Type t = typeof(string);
        ●使用对象GetType()方法。
            string s = "grayworm";
            Type t = s.GetType();
        ●还能调用Type类的静态方法GetType()。
            Type t = Type.GetType("System.String");
          
        上边这三类代码都以收获string类型的Type,在收取string类型的Type援引t后,大家就能够经过t来探测string类型的构造了。
                string n = "grayworm";
                Type t = n.GetType();
                foreach (MemberInfo mi in t.GetMembers())
                {
                    Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name);
                }
       
        Type类的属性:         Name 数据类型名
            FullName 数据类型的一心限定名(包括取名空间名)
            Namespace 定义数据类型的命名空间名
            IsAbstract 提醒该项目是还是不是是抽象类型
            IsArray   提醒该类型是不是是数组
            IsClass   提醒该品种是不是是类
            IsEnum   提示该品种是还是不是是枚举
            IsInterface    提醒该项目是或不是是接口
            IsPublic 提醒该类型是不是是公有的
            IsSealed 提醒该类型是或不是是密闭类
            IsValueType 提醒该品种是还是不是是值类型
        Type类的不二诀窍:         GetConstructor(), GetConstructors():再次来到ConstructorInfo类型,用于获取该类的构造函数的新闻
            Get伊夫nt(), GetEvents():再次回到EventInfo类型,用于获取该类的平地风波的音讯
            GetField(), GetFields():再次回到FieldInfo类型,用于获取该类的字段(成员变量)的音讯
            GetInterface(), GetInterfaces():重回InterfaceInfo类型,用于获取该类实现的接口的新闻
            GetMember(), GetMembers():重临MemberInfo类型,用于获取该类的具有成员的信息
            GetMethod(), GetMethods():重临MethodInfo类型,用于获取该类的方法的音讯
            GetProperty(), GetProperties():再次来到PropertyInfo类型,用于获取该类的性质的消息
        能够调用这个分子,其方法是调用Type的InvokeMember()方法,或然调用MethodInfo, PropertyInfo和别的类的Invoke()方法。
       
        查看类中的构造方法:
            NewClassw nc = new NewClassw();
            Type t = nc.GetType();         ConstructorInfo[] ci = t.GetConstructors();    //获取类的有着构造函数
            foreach (ConstructorInfo c in ci) //遍历每一个构造函数
            {
                ParameterInfo[] ps = c.GetParameters();    //抽取每一种构造函数的全数参数
                foreach (ParameterInfo pi in ps)   //遍历并打字与印刷所该构造函数的富有参数
                {
                    Console.Write(pi.ParameterType.ToString() " " pi.Name ",");
                }
                Console.WriteLine();
            }
       
        用构造函数动态变化对象:         Type t = typeof(NewClassw);
            Type[] pt = new Type[2];         pt[0] = typeof(string);
            pt[1] = typeof(string);
            //依照参数类型获取构造函数
            ConstructorInfo ci = t.GetConstructor(pt);         //构造Object数组,作为构造函数的输入参数
            object[] obj = new object[2]{"grayworm","hi.baidu.com/grayworm"};  
            //调用构造函数生成对象
            object o = ci.Invoke(obj);            //调用转换的靶子的法子测试是还是不是对象生成成功
            //((NewClassw)o).show();   
       
        用Activator生成对象:         Type t = typeof(NewClassw);
            //构造函数的参数
            object[] obj = new object[2] { "grayworm", "hi.baidu.com/grayworm" };  
            //用Activator的CreateInstance静态方法,生成新对象
            object o = Activator.CreateInstance(t,"grayworm","hi.baidu.com/grayworm");         //((NewClassw)o).show();

    来看看反射的相继艺术或品质怎么着使用!

    查看类中的构造方法:
    NewClassw nc = new NewClassw();
    Type t = nc.GetType();
    ConstructorInfo[]ci = t.GetConstructors();
    //获取类的持有构造函数
    foreach (ConstructorInfo c in ci) //遍历每多少个构造函数
    {
    ParameterInfo[]ps = c.GetParameters(); //抽取每一种构造函数的兼具参数
    foreach (ParameterInfopi in ps) //遍历并打字与印刷所该构造函数的全数参数
    {
    Console.Write(pi.ParameterType.ToString() " " pi.Name ",");
    }
    Console.WriteLine();
    }

       //通过DLL文件全名反射其中的享有类型
        Assembly assembly = Assembly.LoadFrom("xxx.dll的路径");
        Type[] aa = a.GetTypes();

        查看类中的属性:         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            PropertyInfo[] pis = t.GetProperties();         foreach(PropertyInfo pi in pis)
            {
                Console.WriteLine(pi.Name);
            }
       
        查看类中的public方法:         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            MethodInfo[] mis = t.GetMethods();         foreach (MethodInfo mi in mis)
            {
                Console.WriteLine(mi.ReturnType " " mi.Name);
            }
       
        查看类中的public字段         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            FieldInfo[] fis = t.GetFields();
            foreach (FieldInfo fi in fis)
            {
                Console.WriteLine(fi.Name);
            } (http://hi.baidu.com/grayworm)
          
        用反射生成对象,并调用属性、方法和字段实行操作         NewClassw nc = new NewClassw();
            Type t = nc.GetType();
            object obj = Activator.CreateInstance(t);
            //取得ID字段
            FieldInfo fi = t.GetField("ID");
            //给ID字段赋值
            fi.SetValue(obj, "k001");
            //取得MyName属性
            PropertyInfo pi1 = t.GetProperty("MyName");
            //给MyName属性赋值
            pi1.SetValue(obj, "grayworm", null);
            PropertyInfo pi2 = t.GetProperty("MyInfo");
            pi2.SetValue(obj, "hi.baidu.com/grayworm", null);
            //取得show方法
            MethodInfo mi = t.GetMethod("show");
            //调用show方法
            mi.Invoke(obj, null);
           
    System.Reflection.Assembly类
         Assembly类能够取得程序集的音信,也能够动态的加载程序集,以及在前后相继聚集查找类型音讯,并创办该项目标实例。
        使用Assembly类能够减低程序集以内的耦合,有助于软件结构的合理化。
       
        通进度序集名称再次来到Assembly对象
            Assembly ass = Assembly.Load("ClassLibrary831");
        通过DLL文件名称重临Assembly对象
            Assembly ass = Assembly.LoadFrom("ClassLibrary831.dll");
        通过Assembly获取程序聚集类
            Type t = ass.GetType("ClassLibrary831.NewClass");   //参数必需是类的全名
        通过Assembly获取程序集中具备的类
            Type[] t = ass.GetTypes();
          
        //通进程序集的名称反射    Assembly ass = Assembly.Load("ClassLibrary831");
        Type t = ass.GetType("ClassLibrary831.NewClass");
        object o = Activator.CreateInstance(t, "grayworm", "http://hi.baidu.com/grayworm");
        MethodInfo mi = t.GetMethod("show");
        mi.Invoke(o, null);

    获得项指标公用属性的不二秘籍(GetProperties)

    Type t = typeof(Student);    //获取类型
    PropertyInfo[] pro = t.GetProperties();//获取公用属性
    foreach (var p in pro)
        Console.WriteLine(p.Name);//输出属性名称
    

    输出结果为:

    Id
    Name
    Sex
    

    GetProperties能够获取项目中有所的公用属性,再次来到二个属性新闻数组PropertyInfo(类型中的公用属性>= 0 ,用数组),

    回来三个属性音讯数组,大家循环输出了它公用属性的名号。

    用构造函数动态变化对象: Type t = typeof(NewClassw);
    Type[] pt = newType[2]; 新葡亰496netnet中的反射,完成数据库访问类反射封装。 pt[0] = typeof;
    pt[1] = typeof;
    //依据参数类型获取构造函数
    ConstructorInfo ci =t.GetConstructor; //构造Object数组,作为构造函数的输入参数
    object[] obj = newobject[2]{"grayworm","hi.baidu.com/grayworm"};
    //调用构造函数生成对象
    object o =ci.Invoke; //调用转换的对象的方式测量检验是还是不是对象生成成功
    //((NewClassw)o).show();

        foreach(Type t in aa)
        {
            if(t.FullName == "a.b.c")
            {
                object o = Activator.CreateInstance(t);
            }
        }

       //通过DLL文件全名反射当中的装有项目
       Assembly assembly = Assembly.LoadFrom("xxx.dll的路径");
        Type[] aa = a.GetTypes();

    猎取具备公用字段字段(GetFields)

    Type t = typeof(Student);//获取类型
    FieldInfo[] fields = t.GetFields(); //获取所有公用字段
    foreach (var f in fields)
        Console.WriteLine(f.Name);//输出
    

     输出结果为:

    Status
    

    Student里的公用字段Status输出了。

    GetFields能够赢得项目中装有的公用字段,再次回到的是二个字段音讯数组(类型中的公用字段>=0的,用数组),然后大家把这些数组举行巡回输出。

    用Activator生成对象: Type t = typeof(NewClassw);
    //构造函数的参数
    object[] obj = new object[2] {"grayworm", "hi.baidu.com/grayworm" };
    //用Activator的CreateInstance静态方法,生成新对象
    object o =Activator.CreateInstance(t,"grayworm","hi.baidu.com/grayworm"); //((NewClassw)o).show();

        foreach(Type t in aa)
        {
            if(t.FullName == "a.b.c")
            {
                object o = Activator.CreateInstance(t);
            }
        }

    获得所公用方法(GetMethods)

    Type type = typeof(Student);//获取类型
    MethodInfo[] methods = type.GetMethods();//获取所有公用方法
    foreach (var m in methods)
      Console.WriteLine(m.Name);//输出方法名
    

    出口结果为:

    get_Id
    set_Id
    get_Name
    set_Name
    get_Sex
    set_Sex
    Show
    

    GetMethods能够博得项目中存有的公用方法,重返二个办法新闻数组(MethodInfo[]),大家循环输出公用方法的称呼。

    不但输出了Show公用方法,还输出了public 类型 字段名{ get; set; }中的get与set的公用方法。

    查看类中的属性: NewClassw nc = new NewClassw();
    Type t = nc.GetType();
    PropertyInfo[] pis =t.GetProperties(); foreach(PropertyInfo pi inpis)
    {
    Console.WriteLine;
    }

     

    GetProperty寻找钦命名称的公用属性,SetValue设置钦点对象的属性值

    Student stu = new Student();//实例化一个Student
    Type type = stu.GetType();  //获取Student的类型
    PropertyInfo pro = type.GetProperty("Name");//搜索Student里名称为Name的公用属性
    pro.SetValue(stu,"小明"); //设置stu里公用属性Name为"小明"
    stu.Show(); //调用stu.Show()方法
    

    出口结果为:

    姓名:小明
    

    ╭(╯^╰)╮,你会发觉自身并不曾经过stu对那么些Name属性赋值,就张开输出,输出内容显示Name已经被赋值了。

    那都以拜GetProperty与SetValue所赐。

    PropertyInfo pro = 类型.GetProperty(属性名);
    

    type.GetProperty("Name")能够搜索类型里名称叫Name的公用属性,重返壹特质量音信类 "PropertyInfo "(寻找结果是纯粹的,不行使数组)

    属性信息.SetValue("对象实例", "值" );
    

    pro.SetValue(stu,"小明");可以安装stu对象中名为“Name”的特性音信(pro)值。

    这边设置为"小明",还索要传一个对象实例,因为你要钦命是哪二个实例,不钦命的话怎么能精通你改改的是哪一个实例中的Name属性值呢。

    查看类中的public方法: NewClassw nc = new NewClassw();
    Type t = nc.GetType();
    MethodInfo[] mis =t.GetMethods(); foreach (MethodInfo mi inmis)
    {
    Console.WriteLine(mi.ReturnType " " mi.Name);
    }

    转载自 

    GetMethod搜索钦点名称的公用方法与Inovke使用钦命参数调用当前实例所代表的不二等秘书籍

    将那一个从前大家先给Student加点东西

     public class Student
     {
         public int Status;
         public int Id { get; set; }
         public string Name { get; set; }
         public string Sex { get; set; }
    
         public void Show()
         {
            Console.WriteLine("姓名:{0}", Name);
         }
    
          //新加入
          public void Show(int id, string name, string sex)
          {
             Console.WriteLine("Id:{0},Name:{1},Sex:{2}", id,name,sex);
          }
    }
    

    我们重载了一个新的Show方法,多了七个参数。

    加完方法后,大家来探究切磋这几个GetMethod与Invoke

    上代码:

    Student stu = new Student();
    Type type = stu.GetType();
    MethodInfo me = type.GetMethod("Show");//搜索stu对象里名称为Show的公用方法
    me.Invoke(stu,new object[] { 1,"小明","男"});//调用新加入的Show,传入三个参数分别对应方法的三个参数
    

    先拿走stu的等级次序然后采用GetMethod来查究名为"Show"的公用方法。

    谈起底来调用stu里名为"Show"的主意,并且传入三个参数(无参数字传送入null,有参数字传送入object[]数组)

    编程进度异常顺利,可是运转时报错!

    心灵是崩溃的!

    新葡亰496net 2

     

    新葡亰496net 3

    全面想了想,开掘寻找的时候好像就招来错误了。重载了二个八个参数的主意,大家好像寻找成无参数的主意了。

    有参数的措施该怎么寻觅呢?

    通过种种询问与切磋后,发掘了GetMethod的另多少个重载。

    Student stu = new Student();
    Type type = stu.GetType();
    Type[] types = new Type[] { typeof(int), typeof(string), typeof(string) };//一个Type数组
    MethodInfo me = type.GetMethod("Show", types);//搜索stu对象里名称为Show的公用方法
    me.Invoke(stu,new object[] { 1,"小明","男"});
    

    咱俩新建了二个Type[]数组,然后定义了int,string,string多个类型,然后将它传给了GetMethod方法。

    出乎预料开采成功了。大家在GetMethod中传出了三个种类数组,规定了搜寻方法的参数类型。所以依赖那些连串GetMethod就会活动寻觅到我们新重载的法子了。

    Id:1,Name:小明,Sex:男
    

    新葡亰496net 4

    果真不出笔者所料   ~。~!

    查看类中的public字段 NewClassw nc = new NewClassw();
    Type t = nc.GetType();
    FieldInfo[] fis = t.GetFields();
    foreach (FieldInfo fi in fis)
    {
    Console.WriteLine;
    }()

    总结:

    上学反射的岁月相当少,在书上找到反射的知识点也比相当少,在天涯论坛,csdn,各个贴吧找到的知识明白了下,就写了几篇博客记录一下。

    或许是反光已经不复被平日利用,或然他的品质略差被轮换,或者他的留存位于框架相当多,可是她真就是二个至极又去何况令人有着思虑的东西。

    在放学疏才浅,错误在劫难逃,若是有错误请各位大佬提议。多谢!

    新葡亰496net 5

    用反射生成对象,并调用属性、方法和字段进行操作**
    **NewClassw nc = new NewClassw();
    Type t = nc.GetType();
    object obj =Activator.CreateInstance;
    //取得ID字段
    FieldInfo fi =t.GetField;
    //给ID字段赋值
    fi.SetValue(obj, "k001");
    //取得MyName属性
    PropertyInfo pi1 =t.GetProperty;
    //给MyName属性赋值
    pi1.SetValue(obj,"grayworm", null);
    PropertyInfo pi2 =t.GetProperty;
    pi2.SetValue(obj,"hi.baidu.com/grayworm", null);
    //取得show方法
    MethodInfo mi =t.GetMethod;
    //调用show方法
    mi.Invoke(obj, null);

    System.Reflection.Assembly类
    Assembly类能够博得程序集的音讯,也足以动态的加载程序集,以及在程序聚集查找类型消息,并成立该类型的实例。
    使用Assembly类能够下落程序集以内的耦合,有助于软件结构的合理化。

    因而程序集名称再次来到Assembly对象
    Assembly ass =Assembly.Load("ClassLibrary831");
    经过DLL文件名称重返Assembly对象
    Assembly ass =Assembly.LoadFrom("ClassLibrary831.dll");
    由此Assembly获取程序聚焦类**

    Type t =ass.GetType("ClassLibrary831.NewClass"); //参数必需是类的真名
    通过Assembly获取程序集中具备的类
    Type[] t = ass.GetTypes();
    //通进度序集的称号反射
    **Assembly ass = Assembly.Load("ClassLibrary831");
    Type t = ass.GetType("ClassLibrary831.NewClass");
    object o =Activator.CreateInstance(t, "grayworm", "");
    MethodInfo mi = t.GetMethod;
    mi.Invoke;

    //通过DLL文件全名反射当中的具有品种
    Assembly assembly =Assembly.LoadFrom("xxx.dll的路径");
    Type[] aa = a.GetTypes();

    foreach(Type t in aa)
    {
    if(t.FullName == "a.b.c")
    {
    object o =Activator.CreateInstance;
    }
    }

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496netnet中的反射,完成数据库访问类反射

    关键词: