C#反射应用

已于 2023-01-07 22:26:19 修改
阅读量341 收藏
点赞数
分类专栏： C#基础点 文章标签： c# 开发语言
于 2023-01-07 22:23:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/againknow/article/details/128585449
版权

目录

一、前期准备

二、反射概念

三、反射加载dll方式 

四、反射遍历类

1、遍历dll中的类

2、遍历类中的各种字段

3、遍历类中的各种属性

4、遍历类中的各种方法

五、类中值的应用

1、字段的使用

2、属性的使用

3、方法的使用

1、构造方法 

2、重构方法

3、泛型方法

4、普通方法

涉及知识点: 反射遍历并使用类

一、前期准备

using System;
using System.Reflection;
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.CompilerServices;

二、反射概念

        通过工程文件中的dll文件,获取并使用内部的类中所有内容

三、反射加载dll方式 

加载一：使用dll文件名

//加载一：使用dll文件名 -- 当前目录 -- 引用->添加引用
  Assembly assembly = Assembly.Load("反射");

加载二：使用完整路径名 

//加载二：使用完整路径名
Assembly assembly = Assembly.LoadFile(@"C:\\Users\\Rush\\Desktop\\C#\\反射\\bin\\Debug\\netcoreapp3.1\\反射.dll");

加载三：使用完全限定名 --(推荐)

//加载三：使用完全限定名 -- 当前目录 -- 引用->添加引用 --(推荐)
Assembly assembly = Assembly.LoadFrom("反射.dll");

加载四：使用完整路径名

 //加载四：使用完整路径名
Assembly assembly = Assembly.LoadFrom(@"C:\\Users\\Rush\\Desktop\\C#\\反射\\bin\\Debug\\netcoreapp3.1\\反射.dll");

四、反射遍历类

1、遍历dll中的类

前期准备：

namespace 反射
{
 internal class Program
 {
   static void Main(string[] args)
    {
    }
 }
 //普通类
 class Student{}
 //泛型类
 class Children<T, K, S>{}
 //接口
 interface ISchool { }
 //秘密类
 sealed class University { }
 //静态类
 static class Company { }
}

 获取dll中类（包括接口）：

 GetType("XXX") -- 获取指定类名

 GetTypes()   -- 获取所有类

    internal class Program
    {
        static void Main(string[] args)
        {
            //加载dll
            Assembly assembly = Assembly.LoadFrom("反射.dll");
            //遍历dll 所有类(包括接口)
            foreach (Type type in assembly.GetTypes())
            {
                Console.WriteLine(type.Name);
            }
        }
    }

结果显示： 

2、遍历类中的各种字段

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓字段↓↓↓↓↓↓↓↓
        //内部字段
        internal string name;
        //受保护字段
        protected float grade;
        //静态字段
        public static int age;
        //公开字段
        public int id;
        //私有字段
        private string sex;
    }

 获取类中的各类型字段：

type.GetField("XXX") ; -- 获取指定字段

type.GetFields(); -- 获取所有字段

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //遍历dll 所有类(包括接口)
        foreach (Type type in assembly.GetTypes())
        {
            //显示类名
            Console.WriteLine($"类名:{type.Name}");
            //遍历所有公开字段
            foreach (FieldInfo field in type.GetFields())
            {
                Console.WriteLine($"字段类型:{field.FieldType.Name} " +
                                  $"字段名:{field.Name}");
            }
            //遍历所有私有字段
            foreach (FieldInfo privateField in type.GetFields(BindingFlags.Instance
                                                            | BindingFlags.NonPublic))
            {
                Console.WriteLine($"私有 -- " +
                                  $"字段类型{privateField.FieldType.Name} " +
                                  $"字段名:{privateField.Name}");
            }
        }
    }
}

结果显示： 

3、遍历类中的各种属性

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓属性↓↓↓↓↓↓↓↓
        //内部属性
        internal string Sex { get; set; }
        //受保护属性
        protected int Id { get; set; }
        //公共属性
        public int Age { get; set; }
        //静态属性
        public static float Grade { get; set; }
        //私有属性
        private string Hobby { get; set; }
    }

 获取dll中类（包括接口）：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //遍历dll 所有类(包括接口)
        foreach (Type type in assembly.GetTypes())
        {
            //显示类名
            Console.WriteLine($"类名:{type.Name}");
            //遍历所有公开属性
            foreach (PropertyInfo property in type.GetProperties())
            {
                Console.WriteLine($"属性类型:{property.PropertyType.Name} " +
                                  $"属性名:{property.Name}");
            }
            //遍历所有私有属性
            foreach (PropertyInfo privateField in type.GetProperties(
                               BindingFlags.Instance | BindingFlags.NonPublic))
            {
                Console.WriteLine($"私有 -- " +
                                  $"属性类型{privateField.PropertyType.Name} " +
                                  $"属性名:{privateField.Name}");
            }
        }
    }
}

结果显示： 

4、遍历类中的各种方法

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓构造方法↓↓↓↓↓↓↓↓
        public Student() { }
        internal Student(int id) { }
        protected Student(int id, string sex) { }
        private Student(int id, string sex, float grade) { }
        

        //↓↓↓↓↓↓↓↓重构方法↓↓↓↓↓↓↓↓
        public void Music() { }
        internal void Music(int id) { }
        protected void Music(int id, string name) { }
        private void Music(int id, string name, float grade) { }

        //↓↓↓↓↓↓↓↓泛型方法↓↓↓↓↓↓↓↓
        public void Math<T>() { }
        public void Art<T>(T t) { }

        //↓↓↓↓↓↓↓↓静态方法↓↓↓↓↓↓↓↓
        public static void Chinese() { }

        //↓↓↓↓↓↓↓↓普通方法↓↓↓↓↓↓↓↓
        public int English() => 10;
    }

 获取dll中类（包括接口）：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //遍历dll 所有类(包括接口)
        foreach (Type type in assembly.GetTypes())
        {
            //显示类名
            Console.WriteLine($"类名:{type.Name}");
            //遍历所有公共的方法
            foreach (MethodInfo method in type.GetMethods())
            {
                Console.Write($"方法: {method.ReturnType.Name} " +
                              $"{method.Name}");
                if (method.GetParameters().Length == 0)
                {
                    Console.WriteLine("();");
                    continue;
                }
                foreach (ParameterInfo parameter in method.GetParameters())
                {
                    Console.Write($"({parameter.ParameterType.Name} " +
                                  $"{parameter.Name});");
                }
                Console.WriteLine();
            }
            //遍历所有受保护的方法
            foreach (MethodInfo privateMethod in type.GetMethods(
                                                 BindingFlags.Instance 
                                               | BindingFlags.NonPublic))
            {
                Console.Write($"受保护方法: {privateMethod.ReturnType.Name} " +
                              $"{privateMethod.Name}");
                if (privateMethod.GetParameters().Length == 0)
                {
                    Console.WriteLine("();");
                    continue;
                }
                foreach (ParameterInfo parameter in privateMethod.GetParameters())
                {
                    Console.Write($"({parameter.ParameterType.Name} " +
                                  $"{parameter.Name});");
                }
                Console.WriteLine();
            }
            //遍历所有构造方法
            foreach (ConstructorInfo constructor in type.GetConstructors())
            {
                Console.Write($"构造方法: {constructor.Name}");
                if (constructor.GetParameters().Length == 0)
                {
                    Console.WriteLine("();");
                    continue;
                }
                foreach (ParameterInfo parameter in constructor.GetParameters())
                {
                    Console.Write($"({parameter.ParameterType.Name} " +
                                  $"{parameter.Name});");
                }
                Console.WriteLine();
            }
            //遍历所有受保护的构造方法
            foreach (ConstructorInfo constructor in type.GetConstructors(
                                                         BindingFlags.Instance 
                                                       | BindingFlags.NonPublic))
            {
                Console.Write($"受保护的构造方法: {constructor.Name}");
                if (constructor.GetParameters().Length == 0)
                {
                    Console.WriteLine("();");
                    continue;
                }
                foreach (ParameterInfo parameter in constructor.GetParameters())
                {
                    Console.Write($"({parameter.ParameterType.Name} " +
                                  $"{parameter.Name});");
                }
                Console.WriteLine();
            }
        }
    }
}

结果显示： 

五、类中值的应用

1、字段的使用

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓字段↓↓↓↓↓↓↓↓
        //公共字段
        public int id;
        //静态字段
        public static int age;
        //内部字段
        internal string name;
        //受保护字段
        protected float grade;
        //私有字段
        private string sex;
    }

字段应用：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        Type studentClass = assembly.GetType("反射.Student");
        object studentObject = Activator.CreateInstance(studentClass);

        //公共字段
        FieldInfo idField = studentClass.GetField("id");
        idField.SetValue(studentObject, 2);
        Console.WriteLine(idField.GetValue(studentObject));

        //公共静态字段
        //!!!设置时: studentObject 可以用 null 代替
        FieldInfo ageField = studentClass.GetField("age");
        ageField.SetValue(null, 3);
        Console.WriteLine(ageField.GetValue(null));

        //-----------------私有字段创建---------------------------
        Type studentPrivateClass = assembly.GetType("反射.Student");
        object studentPrivateObject = Activator.CreateInstance(studentPrivateClass);
            
        //内部字段
        FieldInfo nameField = studentPrivateClass.GetField("name", 
                                                            BindingFlags.Instance 
                                                          | BindingFlags.NonPublic);
        nameField.SetValue(studentPrivateObject, "小王");
        Console.WriteLine(nameField.GetValue(studentPrivateObject));

        //受保护字段
        FieldInfo gradeField = studentPrivateClass.GetField("grade",
                                                             BindingFlags.Instance
                                                           | BindingFlags.NonPublic);
        gradeField.SetValue(studentPrivateObject, 95.6f);
        Console.WriteLine(gradeField.GetValue(studentPrivateObject));

        //私有字段
        FieldInfo sexField = studentPrivateClass.GetField("sex", 
                                                           BindingFlags.Instance
                                                         | BindingFlags.NonPublic);
        sexField.SetValue(studentPrivateObject, "男");
        Console.WriteLine(sexField.GetValue(studentPrivateObject));
    }
}

结果显示：

2、属性的使用

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓属性↓↓↓↓↓↓↓↓
        //公共属性
        public int Id { get; set; }
        //公共静态属性
        public static string Name { get; set; }
        //内部属性
        internal string Sex { get; set; }
        //受保护属性
        protected float Grade { get; set; }
        //私有属性
        private string Hobby { get; set; }
    }

属性应用：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        Type studentClass = assembly.GetType("反射.Student");
        Object studentObject = Activator.CreateInstance(studentClass);

        //公共属性
        PropertyInfo idProperty = studentClass.GetProperty("Id");
        idProperty.SetValue(studentObject, 2);
        Console.WriteLine(idProperty.GetValue(studentObject));

        //公共静态属性
        //!!!静态时: studentObject 可以用 null 代替
        PropertyInfo nameProperty = studentClass.GetProperty("Name");
        nameProperty.SetValue(null, "小王");
        Console.WriteLine(nameProperty.GetValue(null));

        //-----------------私有字段创建-------------------------- -
        Type studentPrivateClass = assembly.GetType("反射.Student");
        object studentPrivateObject = Activator.CreateInstance(studentPrivateClass);

        //内部属性
        PropertyInfo sexProperty = studentPrivateClass.GetProperty("Sex", 
                                                           BindingFlags.Instance 
                                                         | BindingFlags.NonPublic);
        sexProperty.SetValue(studentPrivateObject, "男");
        Console.WriteLine(sexProperty.GetValue(studentPrivateObject));

        //受保护属性
        PropertyInfo gradeProperty = studentPrivateClass.GetProperty("Grade",
                                                           BindingFlags.Instance
                                                         | BindingFlags.NonPublic);
        gradeProperty.SetValue(studentPrivateObject, 99.6f);
        Console.WriteLine(gradeProperty.GetValue(studentPrivateObject));

        //受私有属性
        PropertyInfo hobbyProperty = studentPrivateClass.GetProperty("Hobby",
                                                           BindingFlags.Instance
                                                         | BindingFlags.NonPublic);
        hobbyProperty.SetValue(studentPrivateObject, "打羽毛球");
        Console.WriteLine(hobbyProperty.GetValue(studentPrivateObject));
    }
}

结果显示：

3、方法的使用

1、构造方法 

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓构造方法↓↓↓↓↓↓↓↓
        public Student() 
            => Console.WriteLine("public 无参构造");
        internal Student(int id) 
            => Console.WriteLine("internal 一个参数构造");
        protected Student(int id, string sex) 
            => Console.WriteLine("protected 两个参数构造");
        private Student(int id, string sex, float grade) 
            => Console.WriteLine("private 三个参数构造");
    }

构造方法应用：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //获取Student类
        Type studentClass = assembly.GetType("反射.Student");

        //实例化创建Student类
        object studentObject = Activator.CreateInstance(studentClass);
        //public 无参构造
        ConstructorInfo studentConstructor = studentClass
                                            .GetConstructor(Type.EmptyTypes);
        studentConstructor.Invoke(studentObject, null);

        //实例化创建Student类
        object studentObject_1 = Activator.CreateInstance(studentClass, true);
        //internal 一个参数构造
        ConstructorInfo studentConstructor_1 = studentClass
                                              .GetConstructor(
                                               BindingFlags.Instance 
                                             | BindingFlags.NonPublic, null, 
                                               new Type[] { typeof(int) }, null);
        studentConstructor_1.Invoke(new object[] { 2 });

        //实例化创建Student类
        object studentObject_2 = Activator.CreateInstance(studentClass, true);
        //protected 两个参数构造
        ConstructorInfo studentConstructor_2 = studentClass
                                              .GetConstructor(
                                               BindingFlags.Instance 
                                             | BindingFlags.NonPublic, null, 
                                               new Type[] { typeof(int),
                                               typeof(string) }, null);
        studentConstructor_2.Invoke(new object[] { 2, "abc" });

        //实例化创建Student类
        object studentObject_3 = Activator.CreateInstance(studentClass, true);
        //private 三个参数构造
        ConstructorInfo studentConstructor_3 = studentClass
                                              .GetConstructor(
                                               BindingFlags.Instance 
                                             | BindingFlags.NonPublic, null, 
                                               new Type[] { typeof(int),
                                               typeof(string), typeof(float)}, null);
        studentConstructor_3.Invoke(new object[] { 2, "abc", 3.4f });
    }
}

结果显示：

2、重构方法

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓重构方法↓↓↓↓↓↓↓↓
        public void Music() 
                    => Console.WriteLine("public 无参重构");
        internal void Music(int id) 
                    => Console.WriteLine("internal 一个参数重构");
        protected void Music(int id, string sex) 
                    => Console.WriteLine("protected 两个参数重构");
        private void Music(int id, string sex, float grade) 
                    => Console.WriteLine("private 三个参数重构");
    }

重构方法应用：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //获取Student类
        Type studentClass = assembly.GetType("反射.Student");

        //实例化创建Student类
        object studentObject = Activator.CreateInstance(studentClass);
        //public 无参构造
        MethodInfo MusicMethod = studentClass.GetMethod("Music");
        MusicMethod.Invoke(studentObject, null);

        //internal 一个参构造
        MethodInfo MusicMethod_1 = studentClass.GetMethod("Music",
                                                           BindingFlags.Instance 
                                                         | BindingFlags.NonPublic,
                                                           null, 
                                                         new Type[] { typeof(int)},
                                                           null);
        MusicMethod_1.Invoke( studentObject,new object[] { 2 });

        //protected 两个个参构造
        MethodInfo MusicMethod_2 = studentClass.GetMethod("Music",
                                                           BindingFlags.Instance 
                                                         | BindingFlags.NonPublic,
                                                           null, 
                                          new Type[] { typeof(int), typeof(string) },
                                                           null);
        MusicMethod_2.Invoke(studentObject, new object[] { 2, "abc" });

        //private 三个参构造
        MethodInfo MusicMethod_3 = studentClass.GetMethod("Music",
                                                           BindingFlags.Instance 
                                                         | BindingFlags.NonPublic,
                                                           null, 
                           new Type[] { typeof(int), typeof(string), typeof(float) },
                                                           null);
        MusicMethod_3.Invoke(studentObject, new object[] { 2, "abc", 3.4f });
    }
}

结果显示：

3、泛型方法

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓泛型方法↓↓↓↓↓↓↓↓
        public void Music<T>() => Console.WriteLine("public 无参泛型");
        internal void Art<T>(T id) => Console.WriteLine("internal 一个参数泛型");
        protected void Math<T>(T id) => Console.WriteLine("protected 一个参数泛型");
        private void Chinese<T>(T id) => Console.WriteLine("private 一个参数泛型");
    }

泛型方法应用：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //获取Student类
        Type studentClass = assembly.GetType("反射.Student");

        //实例化创建Student类
        object studentObject = Activator.CreateInstance(studentClass);

        //public 无参泛型方法
        MethodInfo MusicMethod = studentClass.GetMethod("Music",Type.EmptyTypes);
        MethodInfo Music = MusicMethod.MakeGenericMethod(studentClass);
        Music.Invoke(studentObject, null);

        //internal 一个参数泛型方法
        MethodInfo ArtMethod = studentClass.GetMethod("Art",
                                                       BindingFlags.Instance 
                                                     | BindingFlags.NonPublic);
        MethodInfo Art = ArtMethod.MakeGenericMethod(new Type[] { typeof(int)});
        Art.Invoke(studentObject, new object[] { 2 });


        //protected 一个参数泛型方法
        MethodInfo MathMethod = studentClass.GetMethod("Math", 
                                                        BindingFlags.Instance 
                                                      | BindingFlags.NonPublic);
        MethodInfo Math = MathMethod.MakeGenericMethod(new Type[] { typeof(int) });
        Math.Invoke(studentObject, new object[] { 2 });

        //private 一个参数泛型方法
        MethodInfo ChineseMethod= studentClass.GetMethod("Chinese", 
                                                          BindingFlags.Instance 
                                                        | BindingFlags.NonPublic);
        MethodInfo Chinese = ChineseMethod.MakeGenericMethod(
                                                        new Type[] { typeof(int)});
        Chinese.Invoke(studentObject, new object[] { 2 });
    }
}

结果显示：

4、普通方法

前期准备：

    class Student
    {
        //↓↓↓↓↓↓↓↓普通方法↓↓↓↓↓↓↓↓
        public void Music() => Console.WriteLine("public 无参方法");
        public static int English()
        {
            Console.WriteLine("public static 无参方法");
            return 2;
        }
        internal void Art(int id) => Console.WriteLine("internal 一个参数方法");
        protected void Math(int id) => Console.WriteLine("protected 一个参数方法");
        private void Chinese(int id) => Console.WriteLine("private 一个参数方法");
    }

普通方法应用：

internal class Program
{
    static void Main(string[] args)
    {
        //加载dll
        Assembly assembly = Assembly.LoadFrom("反射.dll");
        //获取Student类
        Type studentClass = assembly.GetType("反射.Student");
        //实例化创建Student类
        object studentObject = Activator.CreateInstance(studentClass);

        //public 无参方法
        MethodInfo MusicMethod = studentClass.GetMethod("Music", Type.EmptyTypes);
        MusicMethod.Invoke(studentObject, null);

        //public static 静态无参方法
        //!!!静态时: studentObject 可以用 null 代替
        MethodInfo EnglishMethod = studentClass.GetMethod("English",
                                                           Type.EmptyTypes);
        Console.WriteLine(EnglishMethod.Invoke(null, null).ToString());

        //internal 一个参数方法
        MethodInfo ArtMethod = studentClass.GetMethod("Art",BindingFlags.Instance 
                                                    | BindingFlags.NonPublic,null,
                                                    new Type[] { typeof(int) },null);
        ArtMethod.Invoke(studentObject, new object[] { 2 });


        //protected 一个参数方法
        MethodInfo MathMethod = studentClass.GetMethod("Math", BindingFlags.Instance
                                                      | BindingFlags.NonPublic, null,
                                                        new Type[] { typeof(int) },
                                                        null);
        MathMethod.Invoke(studentObject, new object[] { 2 });

        //private 一个参数方法
        MethodInfo ChineseMethod = studentClass.GetMethod("Chinese",
                                                           BindingFlags.Instance 
                                                         | BindingFlags.NonPublic,
                                                           null, 
                                                         new Type[] { typeof(int) },
                                                           null);
        ChineseMethod.Invoke(studentObject, new object[] { 2 });
    }
}

结果显示：

如有错误，烦请批评指正

**启程**
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c# 反射应用几乎最全面的实例
09-18
是一个 关于c#反射的几乎最好最全面的例子。
C#通过反射加载外部程序集（dll库文件）
加加油！
03-22 1890
C#通过反射加载外部程序集（dll库文件）   本文章使用了一个C#通过反射加载一个类库的dll文件，获取库文件中的公共成员，执行这些变量 反射基础整理传送门 说明： 这个dll文件和我们的反射不在同一个程序集中 测试代码 将这个脚本类库打包成dll库文件 namespace 程序集 { public enum E_Type { Cat, Dog } class TestClass { public int id = 01;
C#反射的基本应用
weixin_30544657的博客
06-24 114
反射描述了在运行过程中检查和处理程序元素的功能。反射可以完成以下任务： 枚举类型的成员； 实例化新对象； 执行对象的成员； 查找类型的信息； 查询程序集的信息； 检查应用于某种类型的自定义特性； 创建和编译新程序集。 1、Type类 Type类是一个抽象的基类。只要实例化一个Type对象，实际上就是实例化了Type的一个派生类。获取给定类型的Type引用三种方式...
C#反射的应用
xie2172188的博客
10-12 507
无处不在的反射： 什么是反射 反射创建对象 反射调用方法 反射黑科技 反射的好处和局限 在线封装ORM数据库访问
C#反射(Reflection)的应用
weixin_33724059的博客
09-07 194
　　反射(Reflection)是C#里很重要的一个特性，其它语言也有这个特性，比如JAVA。反射这个特性是很实用的，这个到底有多实用呢，我也说不清，如果使用过struts, hibernate, spring等等这些框架的话，便会知道反射这个特性是多么的强大了。好像我列出的都是JAVA的框架，.NET的框架我不了解，有没有我都不知道。但在我接触过的那些框架中，没有一个框架是不使用反射的，没有反射...
C#反射的简单应用
李公子的博客
06-02 2579
使用场景 假如我们需要做这样一个功能，用户可以修改一个列表里的信息，但是系统里需要记录用户修改了哪一条记录的哪几个字段，把改变的的字段之前的旧的数据保留下来，方便用户可以追溯数据，就好像QQ可以查看历史头像一样，User表需要更新，但是同时需要在UserHistory表里把旧的记录保存起来，我们可以怎么做呢？ 这里我们把问题简单梳理下，每一条记录可以抽象为一个实体UserDto，用户修改之后提交的也抽象为UserDto，那就变成了比较同一个实体的不同属性的值了。 那就简单了，上代码。 public st
C#反射应用实例
09-04
主要介绍了C#反射应用,实例分析了通过反射实现多系统数据库的配置方法,是比较实用的技巧,需要的朋友可以参考下
C#反射的一些应用
01-01
对于反射贫道也是很陌生的，所以趁现在有时间就把反射看了一下，记下笔记！！！反射的定义：反射（Reflection）是.NET中的重要机制，通过放射，可以在运行时获得.NET中每一个类型（包括类、结构、委托、接口和枚举等...
C#反射之基础应用实例总结
09-04
主要介绍了C#反射之基础应用实例总结,包括了反射的基本原理与用法实例,需要的朋友可以参考下
C# 反射技术应用
05-28
C# 反射技术应用 　反射（Reflection）是.NET中的重要机制，通过放射，可以在运行时获得.NET中每一个类型（包括类、结构、委托、接口和枚举等）的成员，包括方法、属性、事件，以及构造函数等。还可以获得每个...
C# 反射实例代码 接口方式动态加载dll方式
09-16
C# 反射实例代码 接口方式动态加载dll方式
关于C#反射的一些应用
charlsdm的博客
05-20 477
下边分别是访问一个类的字段，属性，还有方法通过反射来获取对应的东西，下面就附上详细的代码 ```csharp public void ReflectionClassGetFieldsInfoFunction<T>() where T : new() { T myInstance = new T(); Type myType = typeof(T); try { Fi
详谈C#反射及应用
热门推荐
菜鸟厚非
10-16 2万+
反射 什么是元数据？什么是反射？ 程序数用来处理数据的，文本和特性都是数据，而程序本身（类的定义和BLC中的类）这些也是数据。 有关程序及其类型的数据被称为元数据，他们保存在程序集中。 程序在运行时，可以查看其他程序集或其本身元数据。一个运行的程序查看本身的元数据或其他程序集的元数据的行为称为反射。 Type 使用 Type 类进行反射，使用特性给类型添加元数据 对于程序中用到的每个类型，CLR 都会创建一个包含这个类型信息的 Type 对象。 程序中每用到一个类型都会关联到独立的 Type 类的对象
c# 反射应用之工厂
weixin_30235225的博客
08-19 118
反射是.net的核心功能，十分的强大。但是好像微软封装的太过了，作为程序员，在实际项目中我很少用到反射（估计是参加的大型项目太少了，需要交互第三方的项目太少了）。 工厂模式是软件设计模式中重要的一种，在面向接口编程中，怎么把接口与实现接口的类进行关联而不是在程序中直接使用 SupportLaw.Dal.Dic_Table dal = new SupportL...
C# 反射功能的使用（很详细）
北京谢吉华的专栏
11-14 3813
一、使用方法过程及步骤 1. 定义要访问类的全名 2. 获取该类的类型 3. 实例化该类 4. 获取该类的字段、属性，方法 5. 设置该字段或属性内容，或调用其方法 从而达到使用字符串访问相应类的目的 二、代码示例 1. 根据窗口类的名称，产生一个新的窗口，相当于new 窗口类 /// 1. 定义窗口类名称：（窗口类的字符串名字，需要全路径名,否则获取不到TYPE） ...
C#反射的实现原理及简单应用
hack_yin的博客
06-19 2294
C#反射技术主要基于System.Type类和System.Reflection.Assemble类，通过Type类可以访问关于任何数据类型的信息，Assemble类用于访问给定程序集的相关信息，或把这个程序集，加载到程序中。
C# 反射的应用
SoftEnger
01-02 469
在网上查找了不少的资料，可以说大同小异，概念性的东西网上一搜一堆， 今天把反射的东西整理了一下,供大家使用,我保证我这里是最全面的东西,当然也是基础的东西, 在学好了这一切的基础上,大家可以学习反射的具体插件等应用,老鸟就不用看了. 首先我们建立一个类库,将它生成为HelloWorld.dll, using System;  namespace Webtest  {   
c# 反射
最新发布
05-31
C# 反射是指在运行时动态地获取类的信息，通过反射可以获取类的属性、方法、事件等信息，以及动态创建对象、调用方法...以上是 C# 反射的一些基本操作，反射的应用非常广泛，可以用来实现插件式开发、ORM 映射等功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值