Reflections

Introduction to .NET Reflection Introduction Reflection is ability to find information about types contained in an assembly at run time. Prior to .NET languages like C++ provided such ability in a limited sense. .NET provides a whole new set of APIs to introspect assemblies and objects. All the APIs related to reflection are located under System.Reflection namespace. .NET reflection is a powerful mechanism which not only allows you to inspect type information but also allows you to invoke methods on those types at runtime. Certain reflection APIs also allow creating of assembly in memory dynamically and use it in your code. In this article we will examine the basic and most commonly used features of reflection. Reflection APIs can be used to develop applications like class browsers, add-ons for development IDEs and inelegant editors.

.NET assemblies Assemblies are the building blocks of any .NET application. All functionality of .NET application is exposed via assemblies. Assemblies form a unit of deployment and versioning. Assemblies contain modules which in turn contain various types (classes, structures, enumerations etc.).

Getting started The first thing you should do while using reflection classes is to include System.Reflection namespace. using System.Reflection;

Loading an assembly Before obtaining any information about types contained in an assembly we must first load the assembly. Assembly myassembly = Assembly.LoadFrom("employee.dll"); This statement loads an assembly called employee.dll. You can substitute your own path here. Assembly class has a static method called LoadFrom that loads the specified assembly in memory. The method returns an instance of assembly class itself.

obtaining details about types from the assembly The next step is to obtain a list of various types contained in the assembly. Types mytypes[] = myassembly.GetTypes(); Type mytype=myassembly.GetType("Company.Employee");

There are two methods to get type information . The method GetTypes returns an assay of System.Type objects. The method GetType returns a type object having details of specified object. Note that in our example Company is the namespace. In case your assembly do not contain any namespace you will simply write the type name.

Obtaining type details The Type class has following properties that gives details about the type under consideration :          

Name : Gives name of the type FullName : Give fully qualified name of the type Namespace : Gives namespace name IsClass IsInterface IsAbstract IsCOMObject : Indicates if the type is a COM object IsEnum IsSealed IsPublic

All the property names are self-explanatory and need no separate explanation.

obtaining details about methods, properties and fields Each type may have fields (member variables), properties and methods. The details about each of these types are obtained by following methods of the Type object.    

GetMembers() : Gives array of MemberInfo objects GetFields() : Gives array of FieldInfo objects GetProperties() : Gives array of PropertyInfo objects GetMethods() : Gives array of MethodInfo objects

Note that you can also get information about specific method, property or field using GetMethod("mymethod"), GetProperty("myprop") or GetField("myfield") methods. MethodInfo[] mymethods= mytype.GetMethods(); MethodInfo mymethod = mytype.GetMethod("GetSalary"); Following paragraphs list commonly used properties and methods of above objects. The property and method names are self explanatory. You can refer MSDN for more details. Properties and methods of MethodInfo Object    

Name IsPrivate IsPublic IsStatic

   

IsConstructor ReturnType GetParameters() Invoke()

Properties and methods of PropertyInfo Object      

Name CanRead CanWrite PropertyType GetValue() SetValue()

Properties and methods of FieldInfo Object       

Name FieldType IsPublic IsPrivate IsStatic GetValue() SetValue()

Invoking a method on a type We have seen how to get information about various types from an assembly. Reflection also allows us to create instances of these types and invoke methods on them. Following code fragment shows just that. Assembly a=Assembly.LoadFrom("employee.dll"); Type t=a.GetType("Company.Employee"); MethodInfo getsalary=t.GetMethod("DisplayMsg"); object obj=Activator.CreateInstance(t); object[] p=new object[1]; p[0]="Hello bipin"; getsalary.Invoke(obj,p); Assembly a=Assembly.LoadFrom("employee.dll"); Type t=a.GetType("Company.Employee"); MethodInfo getsalary=t.GetMethod("GetSalary"); object obj=Activator.CreateInstance(t); object[] p=new object[1]; p[0]="bipin"; object retval=getsalary.Invoke(obj,BindingFlags.DefaultBinding, null,p,null); Console.WriteLine(retval); Here, we first obtained type of employee class. We then created an instance of it using Activator.CreateInstance() method. There are two forms of Invoke() method :

 

If your method is not returning any value then you may use following form Invoke ( obj , obj[]) If your method is returning some value and you want to trap it use following form : obj = Invoke ( obj , bindingflag, binder , parameters, cultureflag )

For both the forms you pass instance of object on which the method will be called and array of objects that contains method parameters. The second method shown here is with most commonly used values for BindingFlags, Binder and Culture. Reflection allows a powerful mechanism to introspect your types. The reflection APIs can be found in System.Reflection namespace. The APIs allow you to inspect types as well as create types on the fly and invoke methods on them. This article is about the use of reflection package in Csharp. Through Reflection we can get Information about the class. It is very useful in designing COM ..we don't have to remember the method name and all other related information regarding class ,we can get it through reflection package. About Program: This program contain one class Reflect and other one is TCPReflection. Through TCPReflection we are getting information about Reflect class in TCPReflection. In TCPReflection we are getting information member information,Field information and method information of Reflect class. I am giving you this program as simple as possible to understand you can do this with available classes of Csharp also like TCPClient etc. Compile : csc TCPReflection.cs execute : TCPReflection Source Code: using System.Reflection; using System; class Reflect { public int i=20; public char ch='a'; public float f1=10; public void GetFloat() { Console.WriteLine(f1); } public void GetInt() { Console.WriteLine(i); } public void GetChar() { Console.WriteLine(ch); }

} class TCPReflection { public void GetInfo() { Reflect sender = new Reflect(); Type t = sender.GetType(); MemberInfo [] members = t.GetMembers(); MethodInfo [] method = t.GetMethods(); FieldInfo [] f1=t.GetFields(); Console.WriteLine("Name of Object "+t.FullName); Console.WriteLine("no of memeber:"+members.Length); Console.WriteLine("no of fileds:"+f1.Length); Console.WriteLine("Member of class Reflect is as follows:" ); foreach(MemberInfo m in members) { Console.WriteLine(m.Name); } Console.WriteLine("Methods of class Reflect is as follows:" ); foreach(MethodInfo m in method) { Console.WriteLine(m.Name); } Console.WriteLine("Fields of class Reflect is as follows:" ); foreach(FieldInfo f in f1) { Console.WriteLine(f.Name); } } public static void Main() { TCPReflection p1 = new TCPReflection(); p1.GetInfo(); } } Click here to download the source code included on this CD…