Reflection class to extract each and every detail of any class in .Net Framework. The MemberInfo class available in System.Reflection namespace is an abstract class. It discovers the attributes of a member and provides access to the member metadata. We need to assign the details we need to query about a type viz. Constructors/Methods/Interface s/Fields/Property etc. to the MemberInfo class local variable. For this, We can make use of the methods GetFields/GetMethods/GetInterf aces etc. In this code example, the user will be prompted to select the class about which he would like to view details. The details of the class selected (available Methods/Interfaces/Fields) will be listed out in the corresponding listboxes.

Reflection provides objects (of type Type) 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 and invoke its methods or access its fields and properties. If you are using attributes in your code, Reflection enables you to access them. For more information, see Attributes.

Here's a simple example of Reflection using the static method GetType - inherited by all types from the Object base class - to obtain the type of a variable:

For more information , please do visit source site:

http://msdn.microsoft .com/en-us/library/ms173183(VS .80).aspx

Answered by .... ..... , an ibibo Master, at 5:32 AM on July 12, 2008

Reflection class to extract each and every detail of any class in .Net Framework. The MemberInfo class available in System.Reflection namespace is an abstract class. It discovers the attributes of a member and provides access to the member metadata. We need to assign the details we need to query about a type viz. Constructors/Methods/Interface s/Fields/Property etc. to the MemberInfo class local variable. For this, We can make use of the methods GetFields/GetMethods/GetInterf aces etc. In this code example, the user will be prompted to select the class about which he would like to view details. The details of the class selected (available Methods/Interfaces/Fields) will be listed out in the corresponding listboxes.

Reflection provides objects (of type Type) 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 and invoke its methods or access its fields and properties. If you are using attributes in your code, Reflection enables you to access them. For more information, see Attributes.

Here's a simple example of Reflection using the static method GetType - inherited by all types from the Object base class - to obtain the type of a variable:

For more information , please do visit source site:

http://msdn.microsoft .com/en-us/library/ms173183(VS .80).aspx

Answered by Raksha , an ibibo Master, at 9:34 AM on July 11, 2008

System.Reflection namespace contains all the Reflection related classes. These classes are used to get information from any of the class under .NET framework. The Type class is the root of all reflection operations. Type is an abstract base class that acts as means to access metadata though the reflection classes. Using Type object, any information related to methods, implementation details and manipulating information can be obtained. The types include the constructors, methods, fields, properties, and events of a class, along with this the module and the assembly in which these information are present can be accessed and manipulated easily.

As mentioned earlier, we can use reflection to dynamically create an instance of any type, bind the type to an existing object, or get the type from an existing object. Once this is done appropriate method can be invoked, access the fields and properties. This can be done by specifying the Type of object or by specifying both assembly and Type of the object that needs to be created. By this the new object created acts like any other object and associated methods, fields and properties can be easily accessed. With reflection we can also find out about various methods associated with newly created object and how to use these object. To find out the attributes and methods associated with an object we can use the abstract class MemberInfo, this class is available under the namespace System.Reflection.

Answered by Yash , an ibibo Master, at 8:20 PM on July 08, 2008

Reflection class to extract each and every detail of any class in .Net Framework. The MemberInfo class available in System.Reflection namespace is an abstract class. It discovers the attributes of a member and provides access to the member metadata. We need to assign the details we need to query about a type viz. Constructors/Methods/Interface s/Fields/Property etc. to the MemberInfo class local variable. For this, We can make use of the methods GetFields/GetMethods/GetInterf aces etc. In this code example, the user will be prompted to select the class about which he would like to view details. The details of the class selected (available Methods/Interfaces/Fields) will be listed out in the corresponding listboxes.

Reflection provides objects (of type Type) 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 and invoke its methods or access its fields and properties. If you are using attributes in your code, Reflection enables you to access them. For more information, see Attributes.

Here's a simple example of Reflection using the static method GetType - inherited by all types from the Object base class - to obtain the type of a variable:

For more information , please do visit source site:

http://msdn.microsoft .com/en-us/library/ms173183(VS .80).aspx

Answered by Ashish Yadav , an ibibo Wizard, at 6:50 PM on June 18, 2008

System.Reflection namespace contains all the Reflection related classes. These classes are used to get information from any of the class under .NET framework. The Type class is the root of all reflection operations. Type is an abstract base class that acts as means to access metadata though the reflection classes. Using Type object, any information related to methods, implementation details and manipulating information can be obtained. The types include the constructors, methods, fields, properties, and events of a class, along with this the module and the assembly in which these information are present can be accessed and manipulated easily.

As mentioned earlier, we can use reflection to dynamically create an instance of any type, bind the type to an existing object, or get the type from an existing object. Once this is done appropriate method can be invoked, access the fields and properties. This can be done by specifying the Type of object or by specifying both assembly and Type of the object that needs to be created. By this the new object created acts like any other object and associated methods, fields and properties can be easily accessed. With reflection we can also find out about various methods associated with newly created object and how to use these object. To find out the attributes and methods associated with an object we can use the abstract class MemberInfo, this class is available under the namespace System.Reflection.

Answered by Madhurima , an ibibo Master, at 3:04 PM on June 18, 2008

Hi VAISHNAVI, Reflection class to extract each and every detail of any class in .Net Framework. The MemberInfo class available in System.Reflection namespace is an abstract class. It discovers the attributes of a member and provides access to the member metadata. We need to assign the details we need to query about a type viz. Constructors/Methods/Interface s/Fields/Property etc. to the MemberInfo class local variable. For this, We can make use of the methods GetFields/GetMethods/GetInterf aces etc. In this code example, the user will be prompted to select the class about which he would like to view details. The details of the class selected (available Methods/Interfaces/Fields) will be listed out in the corresponding listboxes.

Reflection provides objects (of type Type) 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 and invoke its methods or access its fields and properties. If you are using attributes in your code, Reflection enables you to access them. For more information, see Attributes.

Here's a simple example of Reflection using the static method GetType - inherited by all types from the Object base class - to obtain the type of a variable:

For more information , please do visit source site:

http://msdn.microsoft .com/en-us/library/ms173183(VS .80).aspx

Answered by Romi , an ibibo Master, at 5:56 PM on June 16, 2008

well, Reflection is the process by which a C# program can read its own metadata. A program is said to reflect on itself, extracting metadata from its assembly and using that metadata either to inform the user or to modify its own behavior. It's the ability to find out information about objects at run-time. In Reflection we can find out the object’s class, details of an object’s methods, and even create one dynamically at runtime.

Reflection is generally used for any of four tasks:

- Viewing metadata

- Performing type discovery

- Late binding to methods and properties

- Creating types at runtime (Reflection Emit)

Generally Reflection can be used to manipulate other objects on the .NET platform. For the attributes in the metadata to be useful, you need a way to access them--ideally during runtime. The classes in the Reflection namespace, along with the System.Type and System.TypedReference classes, provide support for examining and interacting with the metadata.

Answered by Saurabh , an ibibo Master, at 8:34 AM on June 16, 2008

hi there

System.Reflection namespace contains all the Reflection related classes. These classes are used to get information from any of the class under .NET framework. The Type class is the root of all reflection operations. Type is an abstract base class that acts as means to access metadata though the reflection classes. Using Type object, any information related to methods, implementation details and manipulating information can be obtained. The types include the constructors, methods, fields, properties, and events of a class, along with this the module and the assembly in which these information are present can be accessed and manipulated easily.

As mentioned earlier, we can use reflection to dynamically create an instance of any type, bind the type to an existing object, or get the type from an existing object. Once this is done appropriate method can be invoked, access the fields and properties. This can be done by specifying the Type of object or by specifying both assembly and Type of the object that needs to be created. By this the new object created acts like any other object and associated methods, fields and properties can be easily accessed. With reflection we can also find out about various methods associated with newly created object and how to use these object. To find out the attributes and methods associated with an object we can use the abstract class MemberInfo, this class is available under the namespace System.Reflection.

Answered by Reeta K , an ibibo Master, at 10:22 PM on June 15, 2008

well, The Type class is the root of all reflection operations and the Object that represents a type inside the system. Type is an abstract base class that allows multiple implementations.
This class is the primary means by which we can access metadata, and it acts as a gateway to the Reflection API. It provides methods for obtaining information about a type declaration, such as the constructors, methods, fields, properties, and events of a class, as well as the module and the assembly in which the class is deployed.

Following C# code will demonstrate the reflection capabilities.

namespace reflect
{
using System ;
using System.Reflection ;

publicclass ClassA
{

publicstaticint Main ( string[] kami )
{
Type t = typeof( test ) ;
Console.WriteLine ( "Type of class: " + t ) ;
Console.WriteLine ( "Namespace: " + t.Namespace ) ;
ConstructorInfo[] ci = t.GetConstructors( );
Console.WriteLine( "Constructors are:" ) ;

foreach( ConstructorInfo i in ci )
{
Console.WriteLine( i ) ;
}

PropertyInfo[] pi = t.GetProperties( );
Console.WriteLine( "Properties are:" ) ;

foreach( PropertyInfo i in pi )
{
Console.WriteLine( i ) ;
}
MethodInfo[] mi = t.GetMethods( ) ;
Console.WriteLine( "Methods are:" ) ;

foreach( MethodInfo i in mi )
{
Console.WriteLine( "Name: " + i.Name ) ;
ParameterInfo[] pif = i.GetParameters () ;
foreach ( ParameterInfo p in pif )
{
Console.WriteLine("Type: " + p.ParameterType + " parameter name: " + p.Name ) ;
}
}
return 0 ;
}
}


publicclass test
{
int i ;
int prop;

publicint Prop
{
get
{
return prop ;
}
set
{
prop = value ;
}
}

public test()
{
}

public test ( int x )
{
i = x ;
}

publicint funcA ( int x )
{
Console.WriteLine ( x ) ;
return 2 * x ;
}
}
}

Answered by satyaiitk , an ibibo Master, at 6:04 PM on June 14, 2008

Reflection in C#

This article is aimed to explain reflection in .NET Framework.

Reflection is one of the features of .Net framework and has greater importance during the development of large applications. In brief it is a powerful way of collecting and manipulate information present in application's assemblies and its metadata. Metadata contain all the Type information used by the application. The ability to obtain information at runtime also makes it even more advantageous. When reflection is used along with system.type, it allows the developer to get the valuable information about all the types and about the assemblies. We can even create the instances and then invoke various types that are used across the application.

What is Reflection?

Reflection is the ability to find out information about objects, the application details (assemblies), its metadata at run-time.

This allows application to collect information about itself and also manipulate on itself. It can be used effectively to find all the types in an assembly and/or dynamically invoke methods in an assembly. This includes information about the type, properties, methods and events of an object and to invoke the methods of object Invoke method can be used too. With reflection we can dynamically create an instance of a type, bind the type to an existing object, or get the type from an existing object and invoke its methods or access its fields and properties. If Attributes (C#) are used in application, then with help of reflection we can access these attributes. It can be even used to emit Intermediate Language code dynamically so that the generated code can be executed directly.
How to use Reflection in our applications?

System.Reflection namespace contains all the Reflection related classes. These classes are used to get information from any of the class under .NET framework. The Type class is the root of all reflection operations. Type is an abstract base class that acts as means to access metadata though the reflection classes. Using Type object, any information related to methods, implementation details and manipulating information can be obtained. The types include the constructors, methods, fields, properties, and events of a class, along with this the module and the assembly in which these information are present can be accessed and manipulated easily.

As mentioned earlier, we can use reflection to dynamically create an instance of any type, bind the type to an existing object, or get the type from an existing object. Once this is done appropriate method can be invoked, access the fields and properties. This can be done by specifying the Type of object or by specifying both assembly and Type of the object that needs to be created. By this the new object created acts like any other object and associated methods, fields and properties can be easily accessed. With reflection we can also find out about various methods associated with newly created object and how to use these object. To find out the attributes and methods associated with an object we can use the abstract class MemberInfo, this class is available under the namespace System.Reflection.

Answered by Mohd Farooq , an ibibo Master, at 4:37 PM on June 14, 2008