Re Lect Ion

8/9/2019 Re Lect Ion

1/11

Reflection in .NET 1

RELECTION IN .NET

Description

Refelction is the mechanism of discovering class information solely at run

time.Wondering where it would be useful? Imagine,you are in visual studio IDE(Integrated devolopment environment) and as you type "object." you would see all the

methods,properties and events associated with that object.An other example would be an

Object browser.The code attached here,loads all assemblies and displays each class,itscontructors, methods, properties and events in tree view.The form also hase a command

botton (labeled More Reflection) in whose click event I create an object of MyClass1

class based on the name of the class and invoke its methods during run time.Here is anexplanation of the code with information on various classes and methods used.

I have called the name space MyReflection.Then I have declared MyClass1 andMyClass2 which are used in the click event of More reflection Button.I will talk about

these classes when I come to the click event of this button.Next,I have called my form asTestReflection and is inherited from System.Winforms.Form.Most of the assemblies are

found in D:\\WINNT\\Microsoft.NET\\Framework\\v1.0.2204\\.If this is not the path inyour computer change it to appropriate path on your computer.I have stored all the paths

of the assemblies in an array called arAssemblyPath.I have used System.Winforms.dll

and System.dll and commented the rest, to speed up loading and unloading ofapplication.I have declared an array of Types ,arOfTypes to store all the s from an

assembly.I have a for loop that loads each assembly and gets its types.To do this I had to

use Assembly class in System.Reflection name space.Let us talk a little bit about this

class before we move on.

System.Reflection.Assembly:

It defines an assembly which is a reusable,versionable and self describing building blockof a Common Language Run time application.I will discuss here only the functions that I

have used in my code.

objAssembly=System.Reflection.Assembly.LoadFrom(str);

LoadFrom function takes the path of the assembly to load and loads it and returns that

Assembly.

After loading the assembly we want to get all the types in that assembly.This class provides a function GetTypes() (It returns an array of System.Type objects in that

assembly) which will do that for us and that line for the code is.

arOfTypes=objAssembly.GetTypes();


2/11


Now having touched System.Type class,Let us talk about it.

System.Type:

This class represents type declarations.(class types, interface types, array types, valuetypes and enumeration types.)

It is the root of all Reflection operations.It is the primary means by which we accessmetadata and it acts as a Gateway to Reflection API.It provides methods for obtaining

information about a Type declaration, such as the constructors, properties, methods and

Events.

Extracting Constructor Information:

ConstructorInfo[] ctrInfo=t.GetConstructors();

//It is an object of type System.Type. This method returns an array of objects of typeConstructorInfo. This calss is part of System.Reflection Name space.

Extracting Properties Information:

PropertyInfo[] pInfo = t.GetProperties() ;//It is an object of type System.Type. This method returns an array of objects of typePropertyInfo. This calss is part of System.Reflection Name space.

Extracting Method Information:

MethodInfo[] mInfo=t.GetMethods();

Extracting Event Information:

EventInfo[] eInfo=t.GetEvents();

Once I get all this info,I am presenting it in a tree view control.This should fairly give a

good idea of getting information about a Type.

Once you know all the information about a class,What do you want to do?Probably you

want to creat an instance of that class and execute one of its methods.I have created two

classes MyClass1 and MyClass2 as part of this name space and in the click event of Morereflection button I have created an instance of each of these classes and invoked its

methods.I have put message boxes so that we would know that they are getting

executed.Let us look at this code.

Type t= Type.GetType("MyReflection.MyClass1");

I have passed the name of the class to static method GetType of Type class which would


3/11


return me a type Object of type MyClass1.Once you get Type object,as mentioned before

you could do lot of things with it.Let us look at Activator class and see what we can do

with this class and Type class.

System.Activator:

This class contains methods to create types of objects locally or remotely or obtain

references to existing objects.I have used CreateInstance() of this class to create an

instance of MyClass1.This method needs a Type object as argument to creat an instance

of that type.It returns an object.Next I have used GetType() on object and then usedInvokeMember() on the Type object to invoke method M1 of MyClass1.Here is that

piece of code.

obj1=Activator.CreateInstance(t);

obj1.GetType().InvokeMember("M1",BindingFlags.Default

|BindingFlags.InvokeMethod,null,obj1,newobject[]{});

Many languages and runtime environments provide some type of runtime typeinformation: the ability to get detailed information about classes, fields, methods,

properties, and other code elements at runtime. With C++ and Delphi programs you have

to specifically enable that support. The Java runtime environment has it built in, and typelibraries provide the information for Component Object Model (COM) objects. Runtime

type information is available in .NET programs, too. The information is stored as

metadata in the compiled assembly and is accessible through classes defined in the

System.Reflection namespace.

Using .NET Reflection, you can discover pretty much everything about an assembly andthe classes, interfaces, and value types that it contains. You can use the resulting

information to instantiate types, call methods, access properties, and even peek at private

members. Reflection is powerful, useful, and potentially dangerous.

The common language runtime loader manages application domains. This management

includes loading each assembly into the appropriate application domain and controlling

the memory layout of the type hierarchy within each assembly.

Assemblies contain modules, modules contain types, and types contain members.

Reflection provides objects that encapsulate assemblies, modules, and types. You can use

reflection to dynamically create an instance of a type, bind the type to an existing object,

or get the type from an existing object. You can then invoke the type's methods or access

its fields and properties. Typical uses of reflection include the following:

Use Assembly to define and load assemblies, load modules that are listed in theassembly manifest, and locate a type from this assembly and create an instance of it.


4/11


Use Module to discover information such as the assembly that contains themodule and the classes in the module. You can also get all global methods or other

specific, nonglobal methods defined on the module.

Use ConstructorInfo to discover information such as the name, parameters, accessmodifiers (such as public orprivate), and implementation details (such as abstract

orvirtual) of a constructor. Use the GetConstructors orGetConstructormethod of a

Type to invoke a specific constructor.

Use MethodInfo to discover information such as the name, return type,parameters, access modifiers (such as public orprivate), and implementation details

(such as abstract orvirtual) of a method. Use the GetMethods orGetMethod

method of a Type to invoke a specific method.

Use FieldInfo to discover information such as the name, access modifiers (such as

public orprivate) and implementation details (such as static) of a field, and to get

or set field values.

Use EventInfo to discover information such as the name, event-handler data type,custom attributes, declaring type, and reflected type of an event, and to add or

remove event handlers.

Use PropertyInfo to discover information such as the name, data type, declaringtype, reflected type, and read-only or writable status of a property, and to get or set

property values.

Use ParameterInfo to discover information such as a parameter's name, data type,whether a parameter is an input or output parameter, and the position of the

parameter in a method signature.

The classes of the System.Reflection.Emit namespace provide a specialized form of

reflection that enables you to build types at run time.

Reflection can also be used to create applications called type browsers, which enable

users to select types and then view the information about those types.

There are other uses for reflection. Compilers for languages such as JScript use reflection

to construct symbol tables. The classes in the System.Runtime.Serialization namespace

use reflection to access data and to determine which fields to persist. The classes in the

System.Runtime.Remoting namespace use reflection indirectly through serialization.


5/11


The System.Type class is central to reflection. The common language runtime creates the

Type for a loaded type when reflection requests it. You can use a Type object's methods,

fields, properties, and nested classes to find out everything about that type.

Use Assembly.GetType orAssembly.GetTypes to obtain Type objects from assemblies

that have not been loaded, passing in the name of the type or types you want. Use

Type.GetType to get the Type objects from an assembly that is already loaded. Use

Module.GetType and Module.GetTypes to obtain module Type objects.

The following example shows the syntax necessary to get the Assembly object and

module for an assembly.

[C#]

// Gets the mscorlib assembly in which the object is defined.

Assembly a = typeof(Object).Module.Assembly;

The following example demonstrates getting Type objects from a loaded assembly.

[C#]

// Loads an assembly using its file name.

Assembly a = Assembly.LoadFrom ("MyExe.exe");

// Gets the type names from the assembly.

Type [] types2 = a.GetTypes ();

foreach (Type t in types2)

{

Console.WriteLine (t.FullName);

}

Once you obtain a Type, there are many ways you can discover information about the

members of that type. For example, you can find out about all the type's members by

calling the Type.GetMembers method, which obtains an array ofMemberInfo objects

describing each of the members of the current type.

You can also use methods on the Type class to retrieve information about one or more

constructors, methods, events, fields, or properties that you specify by name. For

example, Type.GetConstructorencapsulates a specific constructor of the current class.

If you have a Type, you can use the Type.Module property to obtain an object that

encapsulates the module containing that type. Use the Module.Assembly property to


6/11


locate an object that encapsulates the assembly containing the module. You can obtain

the assembly that encapsulates the type directly by using the Type.Assembly property.

System.Type and ConstructorInfo

The following example shows how to list the constructors for a class, in this case, theString class.

[C#]

// This program lists all the public constructors

// of the System.String class.

using System;

using System.Reflection;

class ListMembers {

public static void Main(String[] args) {

Type t = typeof(System.String);

Console.WriteLine ("Listing all the public constructors of the {0} type", t);

// Constructors.

ConstructorInfo[] ci = t.GetConstructors(BindingFlags.Public |BindingFlags.Instance);

Console.WriteLine ("//Constructors");

PrintMembers (ci);

}

public static void PrintMembers(MemberInfo [] ms) {

foreach (MemberInfo m in ms) {

Console.WriteLine ("{0}{1}", " ", m);

}

Console.WriteLine();

}

}

MemberInfo, MethodInfo, FieldInfo, and PropertyInfo

Obtain information about the type's methods, properties, events, and fields using

MemberInfo, MethodInfo, FieldInfo, orPropertyInfo objects.


7/11


The following example uses MemberInfo to list the number of members in the

System.IO.File class and uses the System.Type.IsPublicproperty to determine the

visibility of the class.

[C#]

using System;

using System.IO;


class Mymemberinfo

{

public static void Main(string[] args)

{

Console.WriteLine ("\nReflection.MemberInfo");

// Gets the Type and MemberInfo.

Type MyType =Type.GetType("System.IO.File");

MemberInfo[] Mymemberinfoarray = MyType.GetMembers();

// Gets and displays the DeclaringType method.

Console.WriteLine("\nThere are {0} members in {1}.",

Mymemberinfoarray.Length, MyType.FullName);

Console.WriteLine("{0}.", MyType.FullName);if (MyType.IsPublic)

{

Console.WriteLine("{0} is public.", MyType.FullName);

}

}

}

The following example investigates the type of the specified member. It performs

reflection on a member of the MemberInfo class, and lists its type.

[C#]

// This code displays information about the GetValue method of FieldInfo.

using System;



8/11


class MyMethodInfo {

public static int Main() {

Console.WriteLine("Reflection.MethodInfo");

// Gets and displays the Type.

Type MyType = Type.GetType("System.Reflection.FieldInfo");

// Specifies the member for which you want type information.

MethodInfo Mymethodinfo = MyType.GetMethod("GetValue");

Console.WriteLine(MyType.FullName + "." + Mymethodinfo.Name);

// Gets and displays the MemberType property.

MemberTypes Mymembertypes = Mymethodinfo.MemberType;

if (MemberTypes.Constructor == Mymembertypes) {

Console.WriteLine("MemberType is of type All");

}

else if (MemberTypes.Custom == Mymembertypes) {

Console.WriteLine("MemberType is of type Custom");

}

else if (MemberTypes.Event == Mymembertypes) {

Console.WriteLine("MemberType is of type Event");

}

else if (MemberTypes.Field == Mymembertypes) {Console.WriteLine("MemberType is of type Field");

}

else if (MemberTypes.Method == Mymembertypes) {

Console.WriteLine("MemberType is of type Method");

}

else if (MemberTypes.Property == Mymembertypes) {

Console.WriteLine("MemberType is of type Property");

}

else if (MemberTypes.TypeInfo == Mymembertypes) {

Console.WriteLine("MemberType is of type TypeInfo");

}

return 0;

}


9/11


}

The following example uses all the Reflection *Info classes along with BindingFlags to

list all the members (constructors, fields, properties, events, and methods) of the specified

class, dividing the members into static and instance categories.

[C#]

// This program lists all the members of the

// System.IO.BufferedStream class.

using System;

using System.IO;


class ListMembers {

public static void Main(String[] args) {

// Specifies the class.

Type t = typeof (System.IO.BufferedStream);

Console.WriteLine ("Listing all the members (public and non public) of the {0}

type", t);

// Lists static fields first.

FieldInfo [] fi = t.GetFields (BindingFlags.Static |

BindingFlags.NonPublic | BindingFlags.Public);

Console.WriteLine ("// Static Fields");

PrintMembers (fi);

// Static properties.

PropertyInfo [] pi = t.GetProperties (BindingFlags.Static |


Console.WriteLine ("// Static Properties");PrintMembers (pi);

// Static events.

EventInfo [] ei = t.GetEvents (BindingFlags.Static |



10/11


Console.WriteLine ("// Static Events");

PrintMembers (ei);

// Static methods.

MethodInfo [] mi = t.GetMethods (BindingFlags.Static |


Console.WriteLine ("// Static Methods");

PrintMembers (mi);

// Constructors.

ConstructorInfo [] ci = t.GetConstructors (BindingFlags.Instance |


Console.WriteLine ("// Constructors");

PrintMembers (ci);

// Instance fields.

fi = t.GetFields (BindingFlags.Instance | BindingFlags.NonPublic |

BindingFlags.Public);

Console.WriteLine ("// Instance Fields");

PrintMembers (fi);

// Instance properites.

pi = t.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic |


Console.WriteLine ("// Instance Properties");

PrintMembers (pi);

// Instance events.

ei = t.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic |


Console.WriteLine ("// Instance Events");

PrintMembers (ei);


11/11


// Instance methods.

mi = t.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic

| BindingFlags.Public);

Console.WriteLine ("// Instance Methods");

PrintMembers (mi);

Console.WriteLine ("\r\nPress ENTER to exit.");

Console.Read();

}

public static void PrintMembers (MemberInfo [] ms) {

foreach (MemberInfo m in ms) {

Console.WriteLine ("{0}{1}", " ", m);

}

Console.WriteLine();

}

}

Re Lect Ion

Documents

Transcript of Re Lect Ion