当前位置：网站首页>C Advanced Learning -- Reflection

C Advanced Learning -- Reflection

2022-06-23 06:35:00 【Ambassador Tengyun】

One . The definition of reflection

The ability to review metadata and gather information about its types .

Two . Basic concepts

（1）Assembly： Define and load assemblies , Load all modules in the assembly and find a type from this assembly and create an instance of that type .

（2）Module： Get the assembly containing the module and the classes in the module , You can also get all global methods defined on the module or other specific non global methods .

（3）ConstructorInfo： Gets the name of the constructor 、 Parameters 、 Access modifier （ Such as pulic or private） And implementation details （ Such as abstract or virtual） etc. .

（4）MethodInfo(GetMethod/GetMethods)： Get the name of the method 、 Return type 、 Parameters 、 Access modifier （ Such as pulic or private） And implementation details （ Such as abstract or virtual） etc. .

（5）FiedInfo(GetField/GetFields)： Gets the name of the field 、 Access modifier （ Such as public or private） And implementation details （ Such as static） etc. , And get or set the field value .

（6）EventInfo(GetEvent/GetEvents)： Gets the name of the event 、 Event handler data type 、 Custom properties 、 Declaration type, reflection type, etc , Add or remove event handlers .

（7）PropertyInfo(GetProperty/GetProperties)： Gets the name of the property 、 data type 、 Declaration type 、 Reflection type and read-only or writable state, etc , Gets or sets the property value .

（8）ParameterInfo： Get the name of the parameter 、 data type 、 Input parameter or output parameter , And the position of the parameter in the method signature .

（9）MemberInfo(GetMember/GetMembers): Get field 、 event 、 Attributes and so on

3、 ... and . Reflex action

Before demonstrating the effect of reflection , Let's first define the following entity classes , Suppose that the entity class is under a third-party class library , The library name is “TestClass”, Class called "Person"

    public class Person
    {
        private int id;
        public int Id { get => id; set => id = value; }
        public string Name { set; get; }
        public string Phone { get; set; }      
        public Person()
        {
           
        }
        public Person(string a, int b)
        {
            this.Name = a;
            this.Phone = b.ToString();
        }
        public Person(int id, string name, string phone)
        {
            this.Id = id;
            this.Name = name;
            this.Phone = phone;
        }        
        public string getName()
        {
            return this.Name;            
        }
        public string getName1(string str)
        {
            return str;
        }       
        public string getPhone()
        {
            return this.Phone;
        }
        public string getPhone(string str)
        {
            return this.Phone+str;
        }
        public string getPhone(string str,int num)
        {
            return this.Phone + str+num;
        }
        private void privateMethod(string a)
        {
            Console.WriteLine(" This is a private method , The parameter passed in is ："+a);
        }  
    }

1. Create an object without parameters

Create objects without maturity , The essence is to call a parameterless constructor , The specific implementation is as follows

        /// <summary>
        ///  Create an object without parameters 
        /// </summary>
        /// <returns></returns>
        private static Person CreateWithoutParms()
        {
            Assembly assembly = Assembly.Load("TestClass");// Load assembly 
            Type type = assembly.GetType("TestClass.Person");// Get class name （ Take the namespace with you ）
            object o = Activator.CreateInstance(type);// establish Person Entity , No arguments structure 
            Person person = o as Person;
            return person;
        }

Call in console

            Person person = CreateWithoutParms();
            person.Name = " Zhang San ";
            Console.WriteLine("person.Name:"+ person.Name);

The results are as follows ：

Successfully called, created Person, And called Person Is a parameter - free construction method

2. Create an object with parameters

Create objects with maturity , The essence is to call the constructor with parameters , The specific implementation is as follows

        /// <summary>
        ///  Create an object with parameters 
        /// </summary>
        /// <returns></returns>
        private static Person CreateWithParms()
        {
            Assembly assembly = Assembly.Load("TestClass");// Load assembly 
            Type type = assembly.GetType("TestClass.Person");// Get class name （ Take the namespace with you ）
            object o = Activator.CreateInstance(type, new object[] {"a",666 });// establish Person Entity , There are parametric structures 
            Person person = o as Person;
            return person;
        }

Call in console

            Person person = CreateWithParms();
            Console.WriteLine("person.Name:"+person.Name+ " person.Phone:" + person.Phone);

The results are as follows ：

Successfully called, created Person, And use the construction with parameters to assign values to attributes directly

#### explain ： If the constructor is private , When you create an instance , take CreateInstance Medium nonPublic Parameter set to true, You can use the private constructor to create an instance

            object o = Activator.CreateInstance(type,true);

3. Call the public method

Using reflection to call methods of third-party classes , You can get the corresponding object through reflection , Use the resulting object to execute methods in the object , But here , Mainly through reflection , Directly call methods in third-party classes , The specific implementation is as follows

        /// <summary>
        ///  Call a method with parameters （ No overload ）
        /// </summary>
        /// <returns></returns>
        private static string CallFunction()
        {
            Assembly assembly= Assembly.Load("TestClass");
            Type type = assembly.GetType("TestClass.Person");
            object o = Activator.CreateInstance(type);
            MethodInfo methodInfo = type.GetMethod("getName1");
            string result=methodInfo.Invoke(o, new object[] { " This is the incoming parameter " }).ToString();
            return result;
        }

Call in console

            string rsult = CallFunction();
            Console.WriteLine(rsult);

The results are as follows ：

Here we see , Successfully called with reflection getName1 Method , It should be noted that ,getName1 Method has no overload , If you need to call methods with overloads , You need to use the following method , Here we assume that we need to call getPhone(string str,int num) Method

        private static string CallFunctionWithOverload()
        {
            Assembly assembly = Assembly.Load("TestClass");
            Type type = assembly.GetType("TestClass.Person");
            object o = Activator.CreateInstance(type);
            MethodInfo methodInfo = type.GetMethod("getPhone", new Type[] { typeof(string), typeof(int) });// In this case, you need to pass an array of parameter types to GetMethod Method 
            string result=methodInfo.Invoke(o, new object[] { " This is incoming String Parameters ", 666 }).ToString();
            return result;
        }

Call in console

            string rsult = CallFunctionWithOverload();
            Console.WriteLine(rsult);

The results are as follows ：

Through the above example , We can see , The key to calling overloaded and unloaded methods , Is in the GetMethod Whether to pass the type of the parameter in .

Let's write a comprehensive example , call Person All methods in class , And output the result , If the parameter type is String, The default is "AAA", If the parameter type is Int, The default is 666, The implementation method is as follows ：

        private static void CallAllFunction()
        {
            Assembly assembly = Assembly.Load("TestClass");
            Type type = assembly.GetType("TestClass.Person");
            object o = Activator.CreateInstance(type);
            foreach (MethodInfo methodInfoItem in type.GetMethods())
            {
                Console.WriteLine(" perform "+ methodInfoItem.Name+ " Method ");
                List<object> objectList = new List<object>();
                foreach (ParameterInfo parameterInfoItem in methodInfoItem.GetParameters())
                {
                    if (parameterInfoItem.ParameterType == typeof(String))
                    {
                        objectList.Add("AAA");
                    }
                    else if (parameterInfoItem.ParameterType == typeof(int))
                    {
                        objectList.Add(666);
                    }
                }
                try// Use here try...catch... It is to simplify the problem of processing the program error caused by attribute acquisition failure 
                {
                    string result = methodInfoItem.Invoke(o, objectList.ToArray()).ToString();
                    Console.WriteLine(" The result is ：" + result);
                }
                catch 
                {
                }
            }
        }