关于C#基础知识回顾--反射(三)

但是，如果对象是在运行时动态创建的，反射的功能就显示出来了。在这种情况下，需要首先获取一个构造函数列表，然后再调用列表中的某个构造函数，创建一个该类型的实例。通过这种机制，可以在运行时实例化任意类型的对象而不必在声明中指定。

为了获得某个类型的构造函数，需要调用type对象上的getconstructors（）。常用形式为：
constructorinfo[] getconstructors（）
该方法返回一个描述构造函数的constructorinfo对象数组。constructorinfo中常用的
是getparamters（）方法，该方法返回给定构造函数的参数列表。
一旦找到了合适的构造函数，就调用constructorinfo定义的invoke（）方法来创建对象：
object invoke（object[] args）

需要传递给此方法的所有参数都在args中指定。如果不需要参数，args必须为null。另外，
args必须包含与参数个数相同的元素，并且实参的类型必须与形参的类型兼容。invoke（）方法返回
的是指向新构造对象的引用。
例子：
测试对象类

class myclass
{
    int x;
    int y;
    public myclass(int i)
    {
        console.writeline("一个参数的构造函数：");
        x = y = i;
    }
    public myclass(int i, int j)
    {
        console.writeline("两个参数构造函数：");
        x = i;
        y = j;
        show();
    }
    public int sum()
    {
        return x + y;
    }
    public bool isbetween(int i)
    {
        if (x < i && i < y)
            return true;
        else
            return false;
    }
    public void set(int a, int b)
    {
        console.write("函数：set(int a, int b)");
        x = a;
        y = b;
        show();
    }
    public void set(double a, double b)
    {
        console.write("函数：set(double a, double b)");
        x = (int)a;
        y = (int)b;
        show();
    }
    public void show()
    {
        console.writeline("x:{0},y:{1}", x, y);
    }
}

使用反射：

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.reflection;
namespace reflection
{
    class program
    {
        static void main(string[] args)
        {
            invokeconsdemo();
            console.readkey();
        }

        static void invokeconsdemo()
        {
            type t = typeof(myclass);
            int val;
            constructorinfo[] ci = t.getconstructors();
            console.writeline("类构造函数如下：");
            foreach (constructorinfo c in ci)
            {
                console.write("" + t.name + "(");
                parameterinfo[] pi = c.getparameters();
                for (int i = 0; i < pi.length; i++)
                {
                    console.write(pi[i].parametertype.name + " " + pi[i].name);
                    if (i + 1 < pi.length) console.write(", ");
                }
                console.writeline(") ");
            }
            console.writeline();
            int x;
            for (x = 0; x < ci.length; x++)
            {
                parameterinfo[] pi = ci[x].getparameters();
                if (pi.length == 2) break;
            }
            if (x == ci.length)
            {
                console.writeline("没有找到两个参数的构造函数"); return;
            }
            else
            {
                object[] consargs = new object[2];
                consargs[0] = 10;
                consargs[1] = 20;
                object reflectob = ci[x].invoke(consargs);
                console.writeline("用reflectob调用方法");
                console.writeline();
                methodinfo[] mi = t.getmethods();
                foreach (methodinfo m in mi)
                {
                    parameterinfo[] pi = m.getparameters();
                    if (m.name.compareto("set") == 0 && pi[0].parametertype == typeof(int))
                    {
                        object[] args = new object[2];
                        args[0] = 12;
                        args[1] = 7;
                        m.invoke(reflectob, args);
                    }
                    else if (m.name.compareto("set") == 0 && pi[0].parametertype == typeof(double))
                    {
                        object[] args = new object[2];
                        args[0] = 1.25;
                        args[1] = 7.5;
                        m.invoke(reflectob, args);
                    }
                    else if (m.name.compareto("sum") == 0)
                    {
                        val = (int)m.invoke(reflectob, null);
                        console.writeline("sum is {0}",val);
                    }
                    else if (m.name.compareto("isbetween") == 0)
                    {
                        object[] args = new object[1];
                        args[0] = 13;
                        if ((bool)m.invoke(reflectob, args))
                        {
                            console.writeline("13 is between x and y");
                        }
                    }
                    else if (m.name.compareto("show") == 0)
                    {
                        m.invoke(reflectob, null);
                    }
                }
            }
        }
    }
}

运行结果为：



本例中，找到了一个两个参数的构造函数，那么使用下面的语句实例化了一个该类型的对象：
object reflectob=ci[x].invoke(consargs);
调用invoke（）方法后，reflectob将引用一个myclass类型的对象。此后，程序将执行
reflectob上的方法。
注意：本例为了简单起见，假设了一个使用两个参数的构造函数，并且两个参数都为int类型。但在实际的应用程序中，必须检验每一个参数的类型。