C#C#基础知识回顾– 反射(3)

 

拿到Type对象的构造函数:

  后面同一首因为篇幅问题因篇幅太短被移除首页,反射这无异于块还生同样首“如何在程序集中选用反射”,

另没啊好写的了,前片篇首如若烘托,在其实运用被,重如果最后两篇。其实写了照,

自我为考虑重新将信托重新描绘下,现在沉思实在尽过单一与省略了。我相会把实际开发被委托的事例多写几独


以便以了解。即使登时几篇C#的基本功对君抱有助的话,请点击推荐。谢谢您的支撑……

  好了,不赘述了,在前方例子中,由于MyClass类型的目的是展示创制的,由此只要

据此反射技术来调用MyClass上之艺术无此外优势–以平日的不二法门调用对象上的方法会简单的差不多。然则,

万一目的是以运行时动态成立的,反射的效益就是亮出了。在这种状态下,需要首先取得一个结构函

数列表,然后再次调用列表中之有构造函数,创造一个该档的实例。通过这种机制,可以于运作时实例

化任意类型的目标要无需在宣称遭指定。

  为了得到有项目标构造函数,需要调用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);
                    }
                }

            }
        }
    }
}

运转结果也:

C# 1

 

  本例中,找到了一个点儿独参数的构造函数,那么以下的口舌实例化了一个拖欠品种的靶子:

 

object
reflectOb=ci[x].Invoke(consargs);

 

调用Invoke()方法后,reflectOb将引用一个MyClass类型的靶子。此后,程序用实施

 

reflectOb上之计。

 

专注:本例为了简单起见,假要了一个选取有限只参数的构造函数,并且六只参数还为int类型

 

。但当实际上的应用程序中,必须查看每一个参数的档次。

 

相关文章