欧美一区二区三区精品影视,欧美午夜伦y4480私人影院,欧美高清精品一区二区

主頁 > 知識庫 > .net中關于反射的詳細介紹

.net中關于反射的詳細介紹

概述反射

• 通過反射可以提供類型信息，從而使得我們開發人員在運行時能夠利用這些信息構造和使用對象。
• 反射機制允許程序在執行過程中動態地添加各種功能。

運行時類型標識

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

is運算符：

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

復制代碼代碼如下:

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");   //這個打印，因為a 是 A 類型的對象
            }
            if (b is A)
            {
                //這個打印，因為b是B類型的對象，而B類型派生于A類型，由于b對象可以轉換為A類型，因此b對象與A類型是兼容的，但是反過來就不成立，例如下面不打印
                Console.WriteLine("b is an A because it is derived from");
            }
            if (a is B)
            {
                //這個不打印
                Console.WriteLine("This won't display , because a not derived from B");
            }
            if (a is object)
            {
                //這個打印
                Console.WriteLine("a is an object");
            }
            Console.ReadKey();
        }
    }
    class A { }
    class B : A { }

as運算符：

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

復制代碼代碼如下:

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變量轉換為B類型是無效的。
            }
            else
            {
                b = null;
            }

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

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

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

typeof運算符：

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

復制代碼代碼如下:

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類包裝了類型，因此是整個反射子系統的核心，這個類中包含了很多屬性和方法，使用這些屬性和方法可以在運行時得到類型的信息。
•Type類派生于System.Reflection.MemberInfo抽象類

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

請注意

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

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

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

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

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

使用反射

上面的列術都是為了，這里的使用。

通過使用Type類定義的方法和屬性，我們能夠在運行時獲得類型的各種具體信息。這是一個非常強大的功能。我們一旦得到類型信息，就可以調用其構造函數，方法，和屬性。可見，反射是允許使用編譯時不可用的代碼的。

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

這里我列出四種關鍵的反射技術：

1.獲取方法的信息
2.調用方法
3.構造對象
4.從程序集中加載類型

獲取方法的相關信息

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

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

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

復制代碼代碼如下:

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對象
            Console.WriteLine("Analyzing methods in "+t.Name); //t.Name="MyClass"

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

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

            Console.ReadKey();
        }
    }

輸出結果為：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類定義的所有方法外，也會顯示object類定義的共有非靜態方法。這是因為c#中的所有類型都繼承于object類。另外，這些信息實在程序運行時動態獲得的，并不需要預先知道MyClass類的定義

GetMethods()方法的另一種形式

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

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

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

復制代碼代碼如下:

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對象
            Console.WriteLine("Analyzing methods in "+t.Name); //t.Name="MyClass"

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

            Console.ReadKey();
        }
    }

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

使用反射調用方法

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

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

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

復制代碼代碼如下:

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;
                   //參數reflectOb,為一個對象引用，將調用他所指向的對象上的方法，如果為靜態方法這個參數必須設置為null
                   //參數args，為調用方法的參數數組，如果不需要參數為null
                   m.Invoke(reflectOb, args);   //調用MyClass類中的參數類型為int的Set方法，輸出為Inside set(int,int).x:9, y:10
               }
           }
           Console.ReadKey();
        }
    }

獲取Type對象的構造函數

在這之前的闡述中，由于MyClass類型的對象是都是顯式創建的，因此使用反射技術調用MyClass類中的方法是沒有任何優勢的，還不如以普通方式調用方便簡單呢。但是，如果對象是在運行時動態創建的，反射功能的優勢就會顯示出來。在這種情況下，要先獲取一個構造函數列表，然后調用列表中的某個構造函數，創建一個該類型的實例。通過這種機制，可以在運行時實例化任意類型的對象，而不必在聲明語句中指定類型。

復制代碼代碼如下:

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(); //使用這個方法獲取構造函數列表

            int x;
            for (x = 0; x ci.Length; x++)
            {
                ParameterInfo[] pi = ci[x].GetParameters(); //獲取當前構造函數的參數列表
                if (pi.Length == 2) break;    //如果當前構造函數有2個參數，則跳出循環
            }

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

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

            //實例化后，調用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); //由于實例化類型對象的時候是用的兩個參數的構造函數，所以這里返回的結構為30
                    Console.WriteLine(" sum is " + val); //輸出 sum is 30
                }
            }

            Console.ReadKey();
        }
    }

從程序集獲得類型

在這之前的闡述中可以看出一個類型的所有信息都能夠通過反射得到，但是MyClass類型本身，我們卻沒有做出獲取。雖然前面的闡述實例，可以動態確定MyClass類的信息，但是他們都是基于以下事實：預先知道類型名，并且在typeof語句中使用它獲得Type對象。盡管這種方式可能在很多種情況下都很管用，但是要發揮反射的全部功能，我們還需要分析程序集的內容來動態確定程序的可用類型。

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

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

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

復制代碼代碼如下:

View Code

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

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

復制代碼代碼如下:

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();

}
}

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

您可能感興趣的文章: