C#反射调用程序集类中方法

建立类

class OperatorClass
    {
        /// <summary>
        /// 加法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        ///
        public static int Add(int x, int y)
        {
            return x + y;
        }
        /// <summary>
        /// 减法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static int Subtract(int x, int y)
        { return x - y; }
        /// <summary>         /// 乘法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int Mulitiple(int x, int y)
        { return x * y; }
        /// <summary>
        /// 除法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int Divide(int x, int y)
        {
            if (y == )
            {
                Console.WriteLine("除法操作时,除数不能为,返回值暂设定为.");
                return ;
            } return x / y;
        }
        /// <summary>
        /// 取余数求余
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int Remain(int x, int y)
        {
            if (y == )
            {
                Console.WriteLine("取余操作时,除数不能为,返回值暂设定为.");
                return ;
            }
            return x % y;
        }
        /// <summary>
        /// 获取数组的最大数以及最大数所在的索引
        /// </summary>
        /// <param name="array">数组</param>
        /// <param name="maxIndex">输出最大值的所在的索引</param>
        /// <returns></returns>
        public int GetMaxNumber(int[] array, out int maxIndex)
        {
            if (array == null || array.Length == )
            {
                Console.WriteLine("数组不能为null,数组的长度也不能为,暂定返回值为-1");
                maxIndex = -; return -;
            }
            int max = array[]; maxIndex = ;
            for (int i = ; i < array.Length; i++)
            {
                if (max < array[i])
                {
                    maxIndex = i;
                    max = array[i];
                }
            } return max;
        }
        /// <summary>
        /// 获得不定项数组的长度
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public int GetVaryArrayLength(params int[] array)
        {
            if (array == null)
            {
                return ;
            }
            return array.Length;
        }
        /// <summary>
        /// 测试带ref的参数
        /// </summary>
        /// <param name="inParameter"></param>
        /// <param name="refParameter"></param>
        public void TestReference(int inParameter, ref int refParameter)
        {
            inParameter = ;
            refParameter = ;
            Console.WriteLine("参数默认为输入参数,如:inParameter,不会改变原来的值.\r\n带ref或者out的参数是引用参数,如:refParameter,可以改变原来的值.");
        }

        public bool TestString(string s1, string s2)
        {
            string ss = s1 + s2;
            return true;
        }
        /// <summary>
        /// 私有方法无法通过反射得到该方法的信息
        /// </summary>
        private void PrivateMethod()
        {
            Console.WriteLine("私有方法");
        }
    }

加载程序集的类，获得其中的方法

Assembly assembly = Assembly.Load("TestClassLibrary");
            Console.WriteLine("程序集信息:\n" + assembly.FullName);
            Console.WriteLine();
            Type[] ts = assembly.GetTypes();//获得程序集中定义的类型             
            for (int i = ; i < ts.Length; i++)
            {
                string typeFullName = ts[i].FullName;
                Console.WriteLine("类型{0}:[{1}]的所有公共方法:", i + , typeFullName);
                MethodInfo[] mis = ts[i].GetMethods();//返回当前类型的所有公共方法 
                for (int j = ; j < mis.Length; j++)
                {
                    Console.WriteLine("方法名{0}:{1},返回值的类型:{2},是静态方法:{3}",
                        j + , mis[j].Name, mis[j].ReturnType, mis[j].IsStatic); ParameterInfo[] paras = mis[j].GetParameters();//获取指定的方法或构造函数的参数信息 
                    for (int k = ; k < paras.Length; k++)
                    {
                        //当我们知道方法的类型是引用类型时(带有"&"表示引用类型) 如:System.Int32&,此时参数带ref或out修饰 
                        //如果参数是输出参数(paras[k].IsOut==true),则参数的修饰是out，否则是ref 
                        Console.WriteLine("    参数{0}:{1} {2},签名位置:{3},是输出参数:{4}",
                            k + , paras[k].ParameterType, paras[k].Name, paras[k].Position, paras[k].IsOut);
                    }
                }
                Console.WriteLine();
            }

方法的调用

/// <summary> 
        /// 测试调用类库中的方法         
        /// </summary> 
        static void TestInvokeMethod()
        {
            Type ty = System.Reflection.Assembly.Load("TestClassLibrary").GetType(string.Format("{0}.{1}", "TestClassLibrary", "OperatorClass"));
            Console.WriteLine("调用TestClassLibrary.OperatorClass 类的公共静态方法public static int Add(int x, int y) 的例子");
            System.Reflection.MethodInfo mi = ty.GetMethod("Add");
            //调用静态方法Add时,Invoke的第一个参数为null 
            object returnValue = mi.Invoke(null, new object[] { ,  });
            Console.WriteLine("Add方法的返回值:{0}\r\n", returnValue);
            Console.WriteLine("调用TestClassLibrary.OperatorClass 类的公共方法public int GetMaxNumber(int[] array, out int maxIndex) 的例子");
            System.Reflection.MethodInfo mi1 = ty.GetMethod("GetMaxNumber");
            //调用实例化方法(非静态方法)需要创建类型的一个实例             
            object instanceObject = Activator.CreateInstance(ty);
            int maxIndex = -;
            object[] parametersInfo = new object[] { new int[] { , , , , ,  }, maxIndex };
            //调用实例化方法GetMaxNumber时,Invoke的第一个参数是一个实例化对象             
            object returnValue1 = mi1.Invoke(instanceObject, parametersInfo);
            maxIndex = Convert.ToInt32(parametersInfo[]);
            Console.WriteLine("GetMaxNumber方法的返回值(最大值):{0},最大值的索引:{1}", returnValue1, maxIndex);

            System.Reflection.MethodInfo mi2 = ty.GetMethod("TestString");
            object[] str = new object[] { "abc", "" };
            object returnvalue2 = mi2.Invoke(instanceObject, str);
        }

练习代码