.net中關(guān)于反射的詳細(xì)介紹

更新時(shí)間：2013年04月15日 15:23:18 作者：

本篇文章小編將為大家介紹，.net中關(guān)于反射的詳細(xì)介紹，有需要的朋友可以參考一下

概述反射

• 通過(guò)反射可以提供類型信息，從而使得我們開(kāi)發(fā)人員在運(yùn)行時(shí)能夠利用這些信息構(gòu)造和使用對(duì)象。
• 反射機(jī)制允許程序在執(zhí)行過(guò)程中動(dòng)態(tài)地添加各種功能。

運(yùn)行時(shí)類型標(biāo)識(shí)

•運(yùn)行時(shí)類型標(biāo)識(shí)(RTTI),可以在程序執(zhí)行期間判定對(duì)象類型。例如使用它能夠確切地知道基類引用指向了什么類型對(duì)象。
•運(yùn)行時(shí)類型標(biāo)識(shí)，能預(yù)先測(cè)試某個(gè)強(qiáng)制類型轉(zhuǎn)換操作，能否成功，從而避免無(wú)效的強(qiáng)制類型轉(zhuǎn)換異常。
•在c#中有三個(gè)支持RTTI的關(guān)鍵字：is 、 as 、typeof。下面依次介紹他們

is運(yùn)算符：

通過(guò)is運(yùn)算符，能夠判斷對(duì)象類型是否為特頂類型，如果兩種類型是相同類型，或者兩者之間存在引用，裝箱拆箱轉(zhuǎn)換，則表明兩種類型是兼容的。

復(fù)制代碼代碼如下:

View Code

class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = new B();
            if (a is A)
            {
                Console.WriteLine("a is an A");   //這個(gè)打印，因?yàn)閍是 A 類型的對(duì)象
            }
            if (b is A)
            {
                //這個(gè)打印，因?yàn)閎是B類型的對(duì)象，而B(niǎo)類型派生于A類型，由于b對(duì)象可以轉(zhuǎn)換為A類型，因此b對(duì)象與A類型是兼容的，但是反過(guò)來(lái)就不成立，例如下面不打印
                Console.WriteLine("b is an A because it is derived from");
            }
            if (a is B)
            {
                //這個(gè)不打印
                Console.WriteLine("This won't display , because a not derived from B");
            }
            if (a is object)
            {
                //這個(gè)打印
                Console.WriteLine("a is an object");
            }
            Console.ReadKey();
        }
    }
    class A { }
    class B : A { }

as運(yùn)算符：

在運(yùn)行期間執(zhí)行類型轉(zhuǎn)換，并且能夠使得類型轉(zhuǎn)換失敗不拋異常，而返回一個(gè)null值，其實(shí)as也可以看作一個(gè)is運(yùn)算符的簡(jiǎn)化備選方式（看例子）。

復(fù)制代碼代碼如下:

View Code

class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = new B();
            if (a is B)
            {
                b = (B)a;   //由于a變量不是B類型，因此這里將a變量轉(zhuǎn)換為B類型是無(wú)效的。
            }
            else
            {
                b = null;
            }

            if (b ==null)
            {
                //這個(gè)打印
                Console.WriteLine("The cast in b=(B)a is not allowed");
            }

//上面使用as運(yùn)算符，能夠把兩部合二為一。

            b = a as B;   //as類型先檢查強(qiáng)制類型轉(zhuǎn)換的有效性，如果有效，則執(zhí)行強(qiáng)類型轉(zhuǎn)換過(guò)程。這些都在這一句完成。
            if (b == null)
            {
                //這個(gè)打印
                Console.WriteLine("The cast in b=(B)a is not allowed");
            }
            Console.ReadKey();
        }
    }
    class A { }
    class B : A { }

typeof運(yùn)算符：

as ,is 能夠測(cè)試兩種類型的兼容性。但大多數(shù)情況下，還需要獲得某個(gè)類型的具體信息。這就用到了typeof,它可以返回與具體類型相關(guān)的System.Type對(duì)象，通過(guò)System.Type對(duì)象可以去頂此類型的特征。一旦獲得給定類型的Type對(duì)象，就可以通過(guò)使用該對(duì)象定義的各種屬性，字段，方法來(lái)獲取類型的具體信息。Type類包含了很多成員，在接下來(lái)的反射中再詳細(xì)討論。下面簡(jiǎn)單的演示Type對(duì)象，調(diào)用它的三個(gè)屬性。

復(fù)制代碼代碼如下:

View Code

static void Main(string[] args)
{
Type t=typeof(StringBuilder);

Console.WriteLine(t.FullName); //FullName屬性返回類型的全稱

            if (t.IsClass)
            {
                Console.WriteLine("is a class"); //打印
            }
            if (t.IsSealed) //是否為密封類
            {
                Console.WriteLine("is Sealed"); //打印
            }
            Console.ReadKey();

}

反射的核心類：System.Type類

• 許多支持反射的類都位于System.Reflection命名空間中，他們是.net Reflection API的一部分，所以在使用的反射的程序中一般都要使用 System.Reflection的命名空間。
•System. Type類包裝了類型，因此是整個(gè)反射子系統(tǒng)的核心，這個(gè)類中包含了很多屬性和方法，使用這些屬性和方法可以在運(yùn)行時(shí)得到類型的信息。
•Type類派生于System.Reflection.MemberInfo抽象類

MemberInfo類中的只讀屬性
屬性	描述
Type DeclaringType	獲取聲明該成員的類或接口的類型
MemberTypes MemberType	獲取成員的類型，這個(gè)值用于指示該成員是字段、方法、屬性、事件、或構(gòu)造函數(shù)
Int MetadataToken	獲取與特定元數(shù)據(jù)相關(guān)的值
Module Module	獲取一個(gè)代表反射類型所在模塊（可執(zhí)行文件）的Module對(duì)象
String Name	成員的名稱
Type ReflectedType	反射的對(duì)象類型

請(qǐng)注意

•MemberType屬性的返回類型為MemberTypes，這是一個(gè)枚舉，它定義了用于表示不同成員的類型值。這些值包括：MemberTypes.Constructor, MemberTypes.Method, MemberTypes.Field, MemberTypes.Event, MemberTypes.Property。因此可以通過(guò)檢查MemberType屬性來(lái)確定成員的類型，例如，在MemberType屬性的值為MemberTypes.Method時(shí)，該成員為方法
•MemberInfo類還包含兩個(gè)與特性相關(guān)的抽象方法：

1.GetCustomAttributes() ：獲得與主調(diào)對(duì)象關(guān)聯(lián)的自定義特性列表。
2.IsDefined(): 確定是否為主調(diào)對(duì)象定義了相應(yīng)的特性。
3.GetCustomAttributesData():返回有關(guān)自定義特性的信息（特性稍后便會(huì)提到）
當(dāng)然除了MemberInfo類定義的方法和屬性外，Type類自己也添加了許多屬性和方法：如下表（只列出一些常用的，太多了，自己可以轉(zhuǎn)定義Type類看下）

Type類定義的方法
方法	功能
ConstructorInfo[] GetConstructors()	獲取指定類型的構(gòu)造函數(shù)列表
EventInfo[] GetEvents();	獲取指定類型的時(shí)間列
FieldInfo[] GetFields();	獲取指定類型的字段列
Type[] GetGenericArguments();	獲取與已構(gòu)造的泛型類型綁定的類型參數(shù)列表，如果指定類型的泛型類型定義，則獲得類型形參。對(duì)于正早構(gòu)造的類型，該列表就可能同時(shí)包含類型實(shí)參和類型形參
MemberInfo[] GetMembers();	獲取指定類型的成員列表
MethodInfo[] GetMethods();	獲取指定類型的方法列表
PropertyInfo[] GetProperties();	獲取指定類型的屬性列表

下面列出Type類定義的常用的只讀屬性

Type類定義的屬性
屬性	功能
Assembly Assembly	獲取指定類型的程序集
TypeAttributes Attributes	獲取制定類型的特性
Type BaseType	獲取指定類型的直接基類型
String FullName	獲取指定類型的全名
bool IsAbstract	如果指定類型是抽象類型，返回true
bool IsClass	如果指定類型是類，返回true
string Namespace	獲取指定類型的命名空間

使用反射

上面的列術(shù)都是為了，這里的使用。

通過(guò)使用Type類定義的方法和屬性，我們能夠在運(yùn)行時(shí)獲得類型的各種具體信息。這是一個(gè)非常強(qiáng)大的功能。我們一旦得到類型信息，就可以調(diào)用其構(gòu)造函數(shù)，方法，和屬性?？梢?jiàn)，反射是允許使用編譯時(shí)不可用的代碼的。

由于Reflection API非常多，這里不可能完整的介紹他們（這里如果完整的介紹，據(jù)說(shuō)要一本書(shū)，厚書(shū)）。但是,Reflection API是按照一定邏輯設(shè)計(jì)的。因此，只要知道部分接口的使用方法，就可以舉一反三的使用剩余的接口。

這里我列出四種關(guān)鍵的反射技術(shù)：

1.獲取方法的信息
2.調(diào)用方法
3.構(gòu)造對(duì)象
4.從程序集中加載類型

獲取方法的相關(guān)信息

一旦有了Type對(duì)象就可以使用GetMethodInfo()方法獲取此類型支持的方法列表。該方法返回一個(gè)MethodInfo 對(duì)象數(shù)組，MethodInfo對(duì)象描述了主調(diào)類型所支持的方法，他位于System.Reflection命名空間中

MethodInfo類派生于MethodBase抽象類，而MethodBase類繼承了MemberInfo類。因此我們能夠使用這三個(gè)類定義的屬性和方法。例如，使用Name屬性得到方法名稱。這里有兩個(gè)重要的成員：

1. ReturnType屬性：為T(mén)ype類型的對(duì)象，能夠提供方法的返回類型信息
2. GetParameters()方法：返回參數(shù)列表，參數(shù)信息以數(shù)組形式保存在PatameterInfo對(duì)象中。PatameterInfo類定義了大量描述參數(shù)信息的屬性和方法。這里也列出兩個(gè)常用的屬性：Name（包含參數(shù)名稱信息的字符串），ParameterType（參數(shù)類型的信息）。
下面代碼，我將使用反射獲得類中所支持的方法，還有方法的信息。

復(fù)制代碼代碼如下:

View Code

    class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        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)
        {
            x = a;
            y = b;
        }
        public void Set(double a, double b)
        {
            x = (int)a;
            y = (int)b;
        }
        public void Show()
        {
            Console.WriteLine("x:{0},y:{1}",x,y);
        }
    }
    class ReflectDemo
    {
        static void Main(string[] args)
        {
            Type t=typeof(MyClass);   //獲取描述MyClass類型的Type對(duì)象
            Console.WriteLine("Analyzing methods in "+t.Name); //t.Name="MyClass"

            MethodInfo[] mi = t.GetMethods(); //MethodInfo對(duì)象在System.Reflection命名空間下。
            foreach (MethodInfo m in mi) //遍歷mi對(duì)象數(shù)組
            {
                Console.Write(m.ReturnType.Name); //返回方法的返回類型
                Console.Write(" " + m.Name + "("); //返回方法的名稱

                ParameterInfo[] pi = m.GetParameters(); //獲取方法參數(shù)列表并保存在ParameterInfo對(duì)象數(shù)組中
                for (int i = 0; i < pi.Length; i++)
                {
                    Console.Write(pi[i].ParameterType.Name); //方法的參數(shù)類型名稱
                    Console.Write(" "+pi[i].Name); // 方法的參數(shù)名
                    if (i + 1 < pi.Length)
                    {
                        Console.Write(", ");
                    }
                }
                Console.Write(")");
                Console.WriteLine(); //換行
            }

            Console.ReadKey();
        }
    }

輸出結(jié)果為：Analyzing methods inMyClass MyClass(int i, int j) int sum() bool IsBetween(int i) void Set(int a, int b) void Set(double a, double b) void Show()

bool Equals(object obj) int GetHashCode() Type GetType() string ToString()

注意：這里輸出的除了MyClass類定義的所有方法外，也會(huì)顯示object類定義的共有非靜態(tài)方法。這是因?yàn)閏#中的所有類型都繼承于object類。另外，這些信息實(shí)在程序運(yùn)行時(shí)動(dòng)態(tài)獲得的，并不需要預(yù)先知道MyClass類的定義

GetMethods()方法的另一種形式

這種形式可以制定各種標(biāo)記，已篩選想要獲取的方法。他的通用形式為：MethodInfo[] GetMethods(BindingFlags bindingAttr)

BindingFlags是一個(gè)枚舉，枚舉值有（很多只列出5個(gè)吧）：

1.DeclareOnly:僅獲取指定類定義的方法，而不獲取所繼承的方法；
2.Instance：獲取實(shí)例方法
3.NonPublic: 獲取非公有方法
4.Public：獲取共有方法
5.Static：獲取靜態(tài)方法
GetMethods(BindingFlags bindingAttr)這個(gè)方法，參數(shù)可以使用or把兩個(gè)或更多標(biāo)記連接在一起，實(shí)際上至少要有Instance（或Static）與Public（或NonPublic）標(biāo)記。否則將不會(huì)獲取任何方法。

復(fù)制代碼代碼如下:

View Code

class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        private 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)
        {
            x = a;
            y = b;
        }
        public void Set(double a, double b)
        {
            x = (int)a;
            y = (int)b;
        }
        public void Show()
        {
            Console.WriteLine("x:{0},y:{1}",x,y);
        }
    }
    class ReflectDemo
    {
        static void Main(string[] args)
        {
            Type t=typeof(MyClass);   //獲取描述MyClass類型的Type對(duì)象
            Console.WriteLine("Analyzing methods in "+t.Name); //t.Name="MyClass"

            MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly|BindingFlags.Instance|BindingFlags.Public); //不獲取繼承方法，為實(shí)例方法，為公開(kāi)的
            foreach (MethodInfo m in mi) //遍歷mi對(duì)象數(shù)組
            {
                Console.Write(m.ReturnType.Name); //返回方法的返回類型
                Console.Write(" " + m.Name + "("); //返回方法的名稱

            Console.ReadKey();
        }
    }

上面例子，可以看出只顯示了Myclass類顯示定義的公用方法。private int sum()也不顯示。

使用反射調(diào)用方法

上面我們通過(guò)反射獲取到了類中的所有信息，下面我們就再使用反射調(diào)用通過(guò)反射獲取到的方法。

要調(diào)用反射獲取到的方法，則需要在MethodInfo實(shí)例上調(diào)用Invoke() 方法。Invoke()的使用，在下面例子中演示，說(shuō)明。

下面例子是：先通過(guò)反射獲取到要調(diào)用的方法，然后使用Invoke()方法，調(diào)用獲取到的指定方法；

復(fù)制代碼代碼如下:

View Code

class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        private 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("Inside set(int,int).");
            x = a;
            y = b;
            Show();
        }
        public void Set(double a, double b)
        {
            Console.Write("Inside set(double,double).");
            x = (int)a;
            y = (int)b;
            Show();
        }
        public void Show()
        {
            Console.WriteLine("x:{0},y:{1}", x, y);
        }
    }

    class InvokeMethDemo
    {
        static void Main()
        {
           Type t=typeof(MyClass);
           MyClass reflectOb = new MyClass(10, 20);
           reflectOb.Show(); //輸出為： x:10, y:20
           MethodInfo[] mi = t.GetMethods();
           foreach (MethodInfo m in mi)
           {
               ParameterInfo[] pi = m.GetParameters();

               if (m.Name.Equals("Set", StringComparison.Ordinal) && pi[0].ParameterType == typeof(int))
               {
                   object[] args = new object[2];
                   args[0] = 9;
                   args[1] = 10;
                   //參數(shù)reflectOb,為一個(gè)對(duì)象引用，將調(diào)用他所指向的對(duì)象上的方法，如果為靜態(tài)方法這個(gè)參數(shù)必須設(shè)置為null
                   //參數(shù)args，為調(diào)用方法的參數(shù)數(shù)組，如果不需要參數(shù)為null
                   m.Invoke(reflectOb, args);   //調(diào)用MyClass類中的參數(shù)類型為int的Set方法，輸出為Inside set(int,int).x:9, y:10
               }
           }
           Console.ReadKey();
        }
    }

獲取Type對(duì)象的構(gòu)造函數(shù)

在這之前的闡述中，由于MyClass類型的對(duì)象是都是顯式創(chuàng)建的，因此使用反射技術(shù)調(diào)用MyClass類中的方法是沒(méi)有任何優(yōu)勢(shì)的，還不如以普通方式調(diào)用方便簡(jiǎn)單呢。但是，如果對(duì)象是在運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建的，反射功能的優(yōu)勢(shì)就會(huì)顯示出來(lái)。在這種情況下，要先獲取一個(gè)構(gòu)造函數(shù)列表，然后調(diào)用列表中的某個(gè)構(gòu)造函數(shù)，創(chuàng)建一個(gè)該類型的實(shí)例。通過(guò)這種機(jī)制，可以在運(yùn)行時(shí)實(shí)例化任意類型的對(duì)象，而不必在聲明語(yǔ)句中指定類型。

復(fù)制代碼代碼如下:

View Code

class MyClass
    {
        int x;
        int y;
        public MyClass(int i)
        {
            x = y + i;
        }
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        public int sum()
        {
            return x + y;
        }
    }

    class InvokeConsDemo
    {
        static void Main()
        {
            Type t = typeof(MyClass);
            int val;
            ConstructorInfo[] ci = t.GetConstructors(); //使用這個(gè)方法獲取構(gòu)造函數(shù)列表

            int x;
            for (x = 0; x < ci.Length; x++)
            {
                ParameterInfo[] pi = ci[x].GetParameters(); //獲取當(dāng)前構(gòu)造函數(shù)的參數(shù)列表
                if (pi.Length == 2) break;    //如果當(dāng)前構(gòu)造函數(shù)有2個(gè)參數(shù)，則跳出循環(huán)
            }

            if (x == ci.Length)
            {
                return;
            }

            object[] consargs = new object[2];
            consargs[0] = 10;
            consargs[1] = 20;
            object reflectOb = ci[x].Invoke(consargs); //實(shí)例化一個(gè)這個(gè)構(gòu)造函數(shù)有兩個(gè)參數(shù)的類型對(duì)象,如果參數(shù)為空，則為null

            //實(shí)例化后，調(diào)用MyClass中的方法
            MethodInfo[] mi = t.GetMethods(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);
            foreach (MethodInfo m in mi)
            {
                if (m.Name.Equals("sum", StringComparison.Ordinal))
                {
                    val = (int)m.Invoke(reflectOb, null); //由于實(shí)例化類型對(duì)象的時(shí)候是用的兩個(gè)參數(shù)的構(gòu)造函數(shù)，所以這里返回的結(jié)構(gòu)為30
                    Console.WriteLine(" sum is " + val); //輸出 sum is 30
                }
            }

            Console.ReadKey();
        }
    }

從程序集獲得類型

在這之前的闡述中可以看出一個(gè)類型的所有信息都能夠通過(guò)反射得到，但是MyClass類型本身，我們卻沒(méi)有做出獲取。雖然前面的闡述實(shí)例，可以動(dòng)態(tài)確定MyClass類的信息，但是他們都是基于以下事實(shí)：預(yù)先知道類型名，并且在typeof語(yǔ)句中使用它獲得Type對(duì)象。盡管這種方式可能在很多種情況下都很管用，但是要發(fā)揮反射的全部功能，我們還需要分析程序集的內(nèi)容來(lái)動(dòng)態(tài)確定程序的可用類型。

借助Reflection API,可以加載程序集，獲取它的相關(guān)信息并創(chuàng)建其公共可用類型的實(shí)例。通過(guò)這種機(jī)制，程序能夠搜索其環(huán)境，利用潛在功能，而無(wú)需在編譯期間顯式的定義他們。這是一個(gè)非常有效，且令人興奮的概念。

為了說(shuō)明如何獲取程序集中的類型，我創(chuàng)建兩個(gè)文件。第一個(gè)文件定義一組類，第二個(gè)文件則反射各個(gè)類的信息。代碼效果如下。

1.這下面代碼是要編譯生成MyClass.exe文件的

復(fù)制代碼代碼如下:

View Code

    class Demo
    {
        static void Main()
        {
            Console.WriteLine("hello word !");
            Console.ReadKey();
        }
    }

2.這下面的代碼是獲取上面生成程序集的

復(fù)制代碼代碼如下:

View Code

class Class3
{
static void Main() {

            Assembly asm = Assembly.LoadFrom(@"C:\Users\lenovo\Documents\visual studio 2010\Projects\Reflection_test\ConsoleApplication1\bin\Debug\MyClass.exe"); //加載指定的程序集
            Type[] alltype = asm.GetTypes(); //獲取程序集中的所有類型列表
            foreach (Type temp in alltype)
            {
                Console.WriteLine(temp.Name); //打印出MyClass程序集中的所有類型名稱 MyClass , Demo
            }
            Console.ReadKey();

}
}

上面獲取到了，程序集中的類型，如果想操作程序集中類型中的方法，則跟前邊我們累述的方法是一個(gè)樣子的。

您可能感興趣的文章: