反射--获取成员函数

通过Type类的GetMethod可以获取类的成员函数信息，并且可以调用。

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

namespace Reflection1
{
    public class Pet
    {
        public string name;
        public Pet(string name)
        {
            this.name = name;
        }
        public void Name()
        {
            Console.WriteLine("父类公有 Name(): My name is " + name);
        }
        protected void Name2()
        {
            Console.WriteLine("父类保护 Name2(): My name is " + name);
        }
        public virtual void Kind()
        {
            Console.WriteLine("父类重写 Kind(): I am a animal");
        }
        static void Animal()
        {
            Console.WriteLine("父类私有静态 Animal(): we are anaimals");
        }
        protected static void Animal2()
        {
            Console.WriteLine("父类保护静态 Animal2(): we are anaimals");
        }
    }
    public class Cat:Pet
    {
        public Cat(string name):base(name)
        {
            Console.WriteLine("构造：Cat constructor");
        }
        void Miaow()
        {
            Console.WriteLine("私有 Miaow(): Miaow");
        }
        public override void Kind()
        {
            Console.WriteLine("子类重写 Kind(): I am a cat");
        }
    }
    public class Dog:Pet
    {
        public Dog(string name)
            : base(name)
        {
            Console.WriteLine("构造：Doc constructor");
        }
        public override void Kind()
        {
            Console.WriteLine("子类重写 Kind(): I am a dog");
        }
        public void Bark()
        {
            Console.WriteLine("公有重载 Bark() void：bark");
        }
        public int Bark(int num)
        {
            Console.WriteLine("公有重载 Bark(int num) int: bark " + num);
            return num + 1;
        }
        public void Bark(ref int num)
        {
            Console.WriteLine("公有重载 Bark(ref int num) ref：bark "+ num);
        }
        public void Bark2(out int num)
        {
            num = 100;
            Console.WriteLine("公有重载 Bark(out int num) out：bark");
        }
        void Bark3<T>(T param)
        {
            Console.WriteLine("私有泛型："+param.ToString());
        }
        static void All_Bark()
        {
            Console.WriteLine("私有静态 All_Bark()：bark");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Cat cat = new Cat("Tom");
            Dog dog = new Dog("Jack");
            Type catType = cat.GetType();
            Type dogType = dog.GetType();

            MethodInfo mInfo = null;
            Type[] types = null;
            
            //********父类公有
            mInfo = catType.GetMethod("Name");
            if (null != mInfo)
            {
                mInfo.Invoke(cat, null);
            }
            //********父类  (父类的protected 可以通过子类BindingFlags.NonPublic访问，但private不行)
            mInfo = catType.GetMethod("Name2", BindingFlags.NonPublic | BindingFlags.Instance);
            if (null != mInfo)
            {
                mInfo.Invoke(cat, new object[] { });//如果没有参数可以使空数组，也可以是null
            }
            //********父类  (父类private可以通过父类Type去拿，然后通过子类对象来调用)
            mInfo = typeof(Pet).GetMethod("Name2", BindingFlags.NonPublic | BindingFlags.Instance);
            if (null != mInfo)
            {
                mInfo.Invoke(cat, null);
            }
            //********父类静态   (BindingFlags.FlattenHierarchy  不可或缺,private要通过父类Type去拿)
            mInfo = typeof(Pet).GetMethod("Animal", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy);
            if (null != mInfo)
            {
                mInfo.Invoke(cat, null);
            }
            //********父类静态   (BindingFlags.FlattenHierarchy  不可或缺,private则拿不到)
            mInfo = catType.GetMethod("Animal2", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy);
            if (null != mInfo)
            {
                mInfo.Invoke(cat, null);
            }
            //********静态   
            mInfo = dogType.GetMethod("All_Bark", BindingFlags.NonPublic | BindingFlags.Static);
            if (null != mInfo)
            {
                mInfo.Invoke(dog, null);
            }
            //********子类重写   （此处也可以是  typeof(Pet)等价于 使用子类 Type）
            mInfo = typeof(Pet).GetMethod("Kind", BindingFlags.Public | BindingFlags.Instance);
            if (null != mInfo)
            {
                mInfo.Invoke(cat, null);//重载函数通过哪个子类调用，就调用像影子类的重写
                mInfo.Invoke(dog, null);//
            }

            //********私有  
            mInfo = catType.GetMethod("Miaow", BindingFlags.NonPublic | BindingFlags.Instance);
            //Miaow是私有，必须使用BindingFlags.NonPublic标志和BindingFlags.Instance标志，否则取不到信息
            if (null != mInfo)
            {
                mInfo.Invoke(cat, null);
            }

            //***** 重载 void 
            types = new Type[] { };
            mInfo = dogType.GetMethod("Bark", BindingFlags.Public | BindingFlags.Instance,null,types,null);
            if (null != mInfo)
            {
                mInfo.Invoke(dog, null);
            }
            //***** 重载 int 
            types = new Type[] { typeof(int)};
            mInfo = dogType.GetMethod("Bark", BindingFlags.Public | BindingFlags.Instance, null, types, null);
            if (null != mInfo)
            {
                object ret =  mInfo.Invoke(dog, new object[]{10});//处理返回值
                Console.WriteLine("             ret="+(int)ret);
            }
            //***** 重载 ref int 
            types = new Type[] { typeof(int).MakeByRefType() };
            mInfo = dogType.GetMethod("Bark", BindingFlags.Public | BindingFlags.Instance, null, types, null);
            if (null != mInfo)
            {
                mInfo.Invoke(dog, new object[] { 10 });//处理返回值
            }
            //***** 重载 out int （注意：两个函数仅在out 和 ref上有区别是不能构成重载的）
            types = new Type[] { typeof(int).MakeByRefType() };
            mInfo = dogType.GetMethod("Bark2", BindingFlags.Public | BindingFlags.Instance, null, types, null);
            int num = 0;
            if (null != mInfo)
            {
                var arrayParams = new object[] { num };
                mInfo.Invoke(dog, arrayParams);//处理返回值
                Console.WriteLine("             out int=" + arrayParams[0]);
            }

            //***** 泛型
            mInfo = dogType.GetMethod("Bark3", BindingFlags.NonPublic | BindingFlags.Instance);
            if (null != mInfo)
            {
                mInfo = mInfo.MakeGenericMethod(new Type[] { typeof(float) });
                mInfo.Invoke(dog, new object[] { 3.5f });//处理返回值
            }

           
            Console.Read();
        }
    }
}