Type: System.Type

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type to get a constructor that takes no parameters.

-or-

Return Value:: A ConstructorInfo object representing the public instance constructor whose parameters match the types in the parameter type array, if found; otherwise, null.

Exceptions

Exception Type

Condition

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

Remarks

Type.GetConstructor looks for public instance constructors and cannot be used to obtain a class initializer. Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, Type.GetConstructors, and Type.TypeInitializer.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example


using System;
using System.Reflection;
using System.Security;

public class MyClass1
{
   public MyClass1(){}
   public MyClass1(int i){}

   public static void Main()
   {
      try
      {
         Type myType = typeof(MyClass1);
         Type[] types = new Type[1];
         types[0] = typeof(int);
         // Get the constructor that takes an integer as a parameter.
         ConstructorInfo constructorInfoObj = myType.GetConstructor(types);
         if (constructorInfoObj != null)
         {
            Console.WriteLine("The constructor of the class MyClass1 that takes an " + 
               "integer as a parameter is: "); 
            Console.WriteLine(constructorInfoObj.ToString());
         }
         else
         {
            Console.WriteLine("The constructor of the class MyClass1 that takes an integer " +
               "as a parameter is not available."); 
         }
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception caught.");
         Console.WriteLine("Source: " + e.Source);
         Console.WriteLine("Message: " + e.Message);
      }
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetConstructor(
   BindingFlags bindingAttr,
   Binder binder,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints.

C# Syntax:


            public ConstructorInfo GetConstructor(
   BindingFlags bindingAttr,
   Binder binder,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

types

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

-or-

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

-or-

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the parameter type array. The default binder does not process this parameter.

Return Value:: A ConstructorInfo object representing the constructor that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

The types array and the modifiers array have the same length. A parameter specified in the types array can have the following attributes, which are specified in the modifiers array: pdIn, pdOut, pdLcid, pdRetval, pdOptional, and pdHasDefault, which represent [In], [Out], [lcid], [retval], [optional], and a value specifying whether the parameter has a default value. A parameter's associated attributes are stored in the metadata and enhance interoperability.

If an exact match does not exist, the binder will attempt to coerce the parameter types specified in the types array in order to select a match. If the binder is unable to select a match, then null is returned.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

The following BindingFlags filter flags can be used to define which constructors to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public constructors in the search.
Specify BindingFlags.NonPublic to include non-public constructors (that is, private and protected constructors) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

See BindingFlags for more information.

Type.GetConstructor cannot be used to obtain a class initializer. Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, Type.GetConstructors, and Type.TypeInitializer.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

using System;
using System.Reflection;
using System.Security;


public class MyClass1
{
   public MyClass1(int i){}

   public static void Main()
   {
      try
      {
         Type myType = typeof(MyClass1);
         Type[] types = new Type[1];
         types[0] = typeof(int);
         // Get the constructor that is public and takes an integer parameter.
         ConstructorInfo constructorInfoObj = myType.GetConstructor(
            BindingFlags.Instance | BindingFlags.Public, null, types, null);
         if (constructorInfoObj != null )
         {
            Console.WriteLine("The constructor of the MyClass1 class that is public " +
               "and takes an integer as a parameter is:");
            Console.WriteLine(constructorInfoObj.ToString());
         }
         else
         {
            Console.WriteLine("The constructor of the MyClass1 class that is public " +
               "and takes an integer as a parameter is not available.");
         }
      }
      catch(ArgumentNullException e)
      {
         Console.WriteLine("ArgumentNullException: " + e.Message);
      }
      catch(ArgumentException e)
      {
         Console.WriteLine("ArgumentException: " + e.Message);
      }
      catch(SecurityException e)
      {
         Console.WriteLine("SecurityException: " + e.Message);
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception: " + e.Message);
      }
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetConstructor(
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

C# Syntax:


            public ConstructorInfo GetConstructor(
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

callConvention

The CallingConventions object that specifies the set of rules to use regarding the order and layout of arguments, how the return value is passed, what registers are used for arguments, and the stack is cleaned up.

types

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A ConstructorInfo object representing the constructor that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

Although the default binder does not process ParameterModifier (the modifiers parameter), you can use the abstract Binder class to write a custom binder that does process modifiers.ParameterModifier is only used when calling through COM interop, and only parameters that are passed by reference are handled.

The following BindingFlags filter flags can be used to define which constructors to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public constructors in the search.
Specify BindingFlags.NonPublic to include non-public constructors (that is, private and protected constructors) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

using System;
using System.Reflection;
using System.Security;


public class MyClass1
{
   public MyClass1(int i){}

   public static void Main()
   {
      try
      {
         Type  myType = typeof(MyClass1);
         Type[] types = new Type[1];
         types[0] = typeof(int);
         // Get the constructor that is public, instance method and takes an integer parameter.
         ConstructorInfo constructorInfoObj = myType.GetConstructor(
            BindingFlags.Instance | BindingFlags.Public, null,
            CallingConventions.HasThis, types, null);
         if(constructorInfoObj != null)
         {
            Console.WriteLine("The constructor of the class MyClass1 that is a public " +
               "instance method and takes an integer as a parameter is: ");
            Console.WriteLine(constructorInfoObj.ToString());
         }
         else
         {
            Console.WriteLine("The Constructor of the class 'MyClass1' that is a public instance " +
               "method and takes an integer as a parameter is not available.");
         }
      }
      catch(ArgumentNullException e)
      {
         Console.WriteLine("ArgumentNullException: " + e.Message);
      }
      catch(ArgumentException e)
      {
         Console.WriteLine("ArgumentException: " + e.Message);
      }
      catch(SecurityException e)
      {
         Console.WriteLine("SecurityException: " + e.Message);
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception: " + e.Message);
      }
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Method: GetConstructorImpl(
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: When overridden in a derived class, searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

C# Syntax:


            protected abstract ConstructorInfo GetConstructorImpl(
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

callConvention

types

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A ConstructorInfo object representing the constructor that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

The following BindingFlags filter flags can be used to define which constructors to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public constructors in the search.
Specify BindingFlags.NonPublic to include non-public constructors (that is, private and protected constructors) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

See BindingFlags for more information.

This method implements Type.GetConstructor.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Type.GetConstructor and Type.GetConstructorImpl cannot be used to obtain a class initializer. Class initializers are available only through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetConstructors()

Summary: Returns all the public constructors defined for the current Type.

C# Syntax:


            public ConstructorInfo[] GetConstructors();

Return Value:

An array of ConstructorInfo objects representing all the public constructors defined for the current Type, including the type initializer if it is defined.

-or-

An empty array of type ConstructorInfo, if no public constructors are defined for the current Type.

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

This method calls GetConstructors. It will not find static constructors unless you explicitly pass BindingFlags.Static, as shown in the examples.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

Example

This example shows the output of GetConstructors() from a class that has two instance constructors and one static constructor.

 using System;
 using System.Reflection;
 
 public class t {
     public t() {}
     static t() {}
     public t(int i) {}
 
     public static void Main() {
         ConstructorInfo[] p = typeof(t).GetConstructors();
         Console.WriteLine(p.Length);
 
         for (int i=0;i<p.Length;i++) {
             Console.WriteLine(p[i].IsStatic);
         }
     }
 }

The output of this code is:

False

Because GetConstructors () only calls the Public and Instance BindingFlags, the static constructor is neither counted by the for expression nor evaluated by IsStatic.

Use GetConstructors (BindingFlags) and pass it BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Instance to find static constructors, as follows:

 using System;
 using System.Reflection;
  
 public class t {
     public t() {}
     static t() {}
     public t(int i) {}
 
     public static void Main() {
         ConstructorInfo[] p = typeof(t).GetConstructors(
            BindingFlags.Public | BindingFlags.Static |
            BindingFlags.NonPublic | BindingFlags.Instance);
         Console.WriteLine(p.Length);
 
         for (int i=0;i<p.Length;i++) {
             Console.WriteLine(p[i].IsStatic);
         }
     }
 }

Now the output is:

False

True

False

See also:
ConstructorInfo | Type.GetConstructor

Return to top

Overloaded Method: GetConstructors(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the constructors defined for the current Type, using the specified BindingFlags.

C# Syntax:


            public abstract ConstructorInfo[] GetConstructors(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:

An array of ConstructorInfo objects representing all constructors defined for the current Type that match the specified binding constraints, including the type initializer if it is defined.

-or-

An empty array of type ConstructorInfo, if no constructors are defined for the current Type, or if none of the defined constructors match the binding constraints.

Remarks

bindingAttr can be used to specify whether to return only public constructors or both public and non-public constructors.

The following BindingFlags filter flags can be used to define which constructors to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public constructors in the search.
Specify BindingFlags.NonPublic to include non-public constructors (that is, private and protected constructors) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

Example

This example shows the output of GetConstructors() from a class that has two instance constructors and one static constructor.

 using System;
 using System.Reflection;
 
 public class t {
     public t() {}
     static t() {}
     public t(int i) {}
 
     public static void Main() {
         ConstructorInfo[] p = typeof(t).GetConstructors();
         Console.WriteLine(p.Length);
 
         for (int i=0;i<p.Length;i++) {
             Console.WriteLine(p[i].IsStatic);
         }
     }
 }

The output of this code is:

False

Because GetConstructors() only calls the Public and Instance BindingFlags, the static constructor is neither counted by the for expression nor evaluated by IsStatic.

Use GetConstructors (BindingFlags) and pass it BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Instance to find static constructors, as follows:

 using System;
 using System.Reflection;
  
 public class t {
     public t() {}
     static t() {}
     public t(int i) {}
 
     public static void Main() {
         ConstructorInfo[] p = typeof(t).GetConstructors(
            BindingFlags.Public | BindingFlags.Static |
            BindingFlags.NonPublic | BindingFlags.Instance);
         Console.WriteLine(p.Length);
 
         for (int i=0;i<p.Length;i++) {
             Console.WriteLine(p[i].IsStatic);
         }
     }
 }

Now the output is:

False

True

False

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

See also:
ConstructorInfo | BindingFlags | Type.DefaultBinder | ReflectionPermission | Type.GetConstructor

Return to top

Overloaded Method: GetCustomAttributes(
bool inherit
)

Inherited
See base class member description: System.Reflection.MemberInfo.GetCustomAttributes

Summary: When overridden in a derived class, returns an array of all of the custom attributes.

C# Syntax:


            public abstract object[] GetCustomAttributes(
   bool inherit
);

Parameters:

inherit

Specifies whether to search this member's inheritance chain to find the attributes.

Return Value:: An array of all the custom attributes, or an array with zero elements if no attributes are defined.

Implements:: ICustomAttributeProvider.GetCustomAttributes

Example


using System;
using System.Reflection;

// Define a custom attribute with one named parameter.
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
   private string myName;
   public MyAttribute(string name)
   {
      myName = name;
   }
   public string Name
   {
      get
      {
         return myName;
      }
   }
}

// Define a class which has the custom attribute associated with one of its members.
public class MyClass1
{
   [MyAttribute("This is an example attribute")]
   public void MyMethod(int i)
   {
      return;
   }
}

public class MemberInfo_GetCustomAttributes
{
   public static void Main()
   {
      try
      {
         // Get the type of the class 'MyClass1'.
         Type myType = typeof(MyClass1);
         // Get the members associated with the class 'MyClass1'.
         MemberInfo[] myMembers = myType.GetMembers();

         // Display the attributes for each of the members of the class 'MyClass1'.
         for(int i = 0; i < myMembers.Length; i++)
         {
            Object[] myAttributes = myMembers[i].GetCustomAttributes(false);
            if(myAttributes.Length > 0)
            {
               Console.WriteLine("\nThe attributes for the member {0} are : \n", myMembers[i]);
               for(int j = 0; j < myAttributes.Length; j++)
                  Console.WriteLine("The type of the attribute is : {0}", myAttributes[j]);
            }
         }
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception Caught! "+e.Message);
      }
   }
}

See also:
Object | CustomAttributeBuilder

Return to top

Overloaded Method: GetCustomAttributes(
Type attributeType,
bool inherit
)

Inherited
See base class member description: System.Reflection.MemberInfo.GetCustomAttributes

Summary: When overridden in a derived class, returns an array of custom attributes identified by Type.

C# Syntax:


            public abstract object[] GetCustomAttributes(
   Type attributeType,
   bool inherit
);

Parameters:

attributeType

The type of attribute to search for. Only attributes that are assignable to this type are returned.

inherit

Specifies whether to search this member's inheritance chain to find the attributes.

Return Value:: An array of custom attributes defined on this reflected member, or an array with zero (0) elements if no attributes are defined.

Exceptions

Exception Type	Condition
TypeLoadException	If the custom attribute type can not be loaded.

Implements:: ICustomAttributeProvider.GetCustomAttributes

Return to top

Method: GetDefaultMembers()

Summary: Searches for the members defined for the current Type whose DefaultMemberAttribute is set.

C# Syntax:


            public virtual MemberInfo[] GetDefaultMembers();

Return Value:

An array of MemberInfo objects representing all default members of the current Type.

-or-

An empty array of type MemberInfo, if the current Type does not have default members.

Remarks

This method can be overridden by a derived class.

Members include properties, methods, fields, events, and so on.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example


using System;
using System.Reflection;
using System.IO;

[DefaultMemberAttribute("Age")]   
public class MyClass
{
   public void Name(String s) {}
      public int Age
      {
      get
         {
	 return 20;
	 }
      }
   public static void Main()
   {
      try
      {
         Type  myType = typeof(MyClass);
         MemberInfo[] memberInfoArray = myType.GetDefaultMembers();
         if (memberInfoArray.Length > 0)
         {
            Console.WriteLine("The default members of the class MyClass are:\n"); 
               foreach(MemberInfo memberInfoObj in memberInfoArray)
               {
                  Console.WriteLine("The default member name is: " + memberInfoObj.ToString());
               }
         }
         else
         {
         Console.WriteLine("No default members are available."); 
         }
      }
      catch(InvalidOperationException e)
      {
         Console.WriteLine("InvalidOperationException: " + e.Message);
      }
      catch(IOException e)
      {
         Console.WriteLine("IOException: " + e.Message);
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception: " + e.Message);
      }
   }
}

See also:
MemberInfo | DefaultMemberAttribute | Type.GetMember | Type.GetMembers | Type.FindMembers

Return to top

Method: GetElementType()

Summary: When overridden in a derived class, returns the Type of the object encompassed or referred to by the current array, pointer or reference type.

C# Syntax:


            public abstract Type GetElementType();

Return Value:

The Type of the object encompassed or referred to by the current array, pointer or reference type.

-or-

null if the current Type is not an array or a pointer, or is not passed by reference.

Remarks

For example, Type.GetType("Int32[]").GetElementType returns Int32.

Example

The following example demonstrates using the GetElementType method.

using System;
class TestGetElementType 
{
   public static void Main() 
   {
   int[] array = {1,2,3};
   Type t = array.GetType();
   Type t2 = t.GetElementType();
   Console.WriteLine("{0} element type is {1}",array, t2.ToString());
   TestGetElementType newMe = new TestGetElementType();
   t = newMe.GetType();
   t2 = t.GetElementType();
   Console.WriteLine("{0} element type is {1}", newMe, t2==null? "null" : t2.ToString());
   }
}

This code produces the following output:

              				System.Int32[] element type is System.Int32
              				TestGetElementType element type is null

See also:
Type.HasElementType

Return to top

Overloaded Method: GetEvent(
string name
)

Summary: Returns the EventInfo object representing the specified event.

C# Syntax:


            public EventInfo GetEvent(
   string name
);

Parameters:

name

The String containing the name of an event which is declared or inherited by the current Type.

Return Value:: The EventInfo object representing the specified event which is declared or inherited by the current Type, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

			Type myType = typeof(System.Windows.Forms.Button);
         EventInfo myEvent = myType.GetEvent("Click");
         if(myEvent != null)
         {
            Console.WriteLine("Looking for Click event in Button class.");
            Console.WriteLine(myEvent.ToString());
         }
         else
            Console.WriteLine("The Click event is not available with Button class");

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

See also:
EventInfo | String | Type.DefaultBinder | Type.GetEvents

Return to top

Overloaded Method: GetEvent(
string name,
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, returns the EventInfo object representing the specified event, using the specified binding constraints.

C# Syntax:


            public abstract EventInfo GetEvent(
   string name,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of an event which is declared or inherited by the current Type.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: The EventInfo object representing the specified event which is declared or inherited by the current Type, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Remarks

The following BindingFlags filter flags can be used to define which events to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public events in the search.
Specify BindingFlags.NonPublic to include non-public events (that is, private and protected events) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the events declared on the Type, not events that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

         // Creates a bitmask comprising  BindingFlags.
         BindingFlags myBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
         Type myTypeBindingFlags = typeof(System.Windows.Forms.Button);
         EventInfo myEventBindingFlags = myTypeBindingFlags.GetEvent("Click", myBindingFlags);
         if(myEventBindingFlags != null)
         {
            Console.WriteLine("Looking for Click event in Button class with specified BindingFlags.");
            Console.WriteLine(myEventBindingFlags.ToString());
         }
         else
            Console.WriteLine("The Click event is not available with Button class");

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetEvents()

Summary: Returns all the public events that are declared or inherited by the current Type.

C# Syntax:


            public virtual EventInfo[] GetEvents();

Return Value:

An array of EventInfo objects representing all the public events which are declared or inherited by the current Type.

-or-

An empty array of type EventInfo, if the current Type does not have public events.

Remarks

This method can be overridden by a derived class.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

         Type myType = typeof(System.Windows.Forms.Button);
         EventInfo[] myEvents = myType.GetEvents();
         Console.WriteLine("The events on Button class are : ");
         for (int index = 0; index < myEvents.Length; index++)
         {
            Console.WriteLine(myEvents[index].ToString());
         }

See also:
EventInfo | Type.GetEvent

Return to top

Overloaded Method: GetEvents(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for events that are declared or inherited by the current Type, using the specified binding constraints.

C# Syntax:


            public abstract EventInfo[] GetEvents(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: An array of EventInfo objects representing all events which are declared or inherited by the current Type that match the specified binding constraints.
-or-
An empty array of type EventInfo, if the current Type does not have events, or if none of the events match the binding constraints.

Remarks

The following BindingFlags filter flags can be used to define which events to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public events in the search.
Specify BindingFlags.NonPublic to include non-public events (that is, private and protected events) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.DeclaredOnly to search only the events declared on the Type, not events that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

         // Creates a bitmask comprising  BindingFlags.
         BindingFlags myBindingFlags = BindingFlags.Instance | BindingFlags.Public;  
         Type myTypeEvent = typeof(System.Windows.Forms.Button);
         EventInfo[] myEventsBindingFlags = myTypeEvent.GetEvents(myBindingFlags);
         Console.WriteLine("\nThe events on Button class with specified BindingFlags are : ");
         for (int index = 0; index < myEventsBindingFlags.Length; index++)
         {
            Console.WriteLine(myEventsBindingFlags[index].ToString());
         }

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

See also:
EventInfo | BindingFlags | Type.DefaultBinder | ReflectionPermission | Type.GetEvent

Return to top

Overloaded Method: GetField(
string name
)

Summary: Searches for the field with the specified name.

C# Syntax:


            public FieldInfo GetField(
   string name
);

Parameters:

name

The String containing the name of the data field to get.

Return Value:: A FieldInfo object representing the field with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

public class MyFieldClassA
{
	public string field = "A Field";
	public string Field
	{
		get
		{
			return field;
		}
		set
		{
			if(field!=value)
			{
				field=value;
         }
		}
	}
}
public class MyFieldClassB
{
	public string field = "B Field";
	public string Field 
	{
		get
		{
			return field;
		}
		set
		{
			if(field!=value)
			{
				field=value;
			}
		}
	}
}

public class MyFieldInfoClass
{
	public static void Main()
	{
		try
		{
			MyFieldClassB myFieldObjectB = new MyFieldClassB();
			MyFieldClassA myFieldObjectA = new MyFieldClassA();

			Type myTypeA = Type.GetType("MyFieldClassA");
			FieldInfo myFieldInfo = myTypeA.GetField("field");
		
			Type myTypeB = Type.GetType("MyFieldClassB");
			FieldInfo myFieldInfo1 = myTypeB.GetField("field", BindingFlags.Public | BindingFlags.Instance);

			Console.WriteLine("The value of the field is : {0} ", myFieldInfo.GetValue(myFieldObjectA));
			Console.WriteLine("The value of the field is : {0} ", myFieldInfo1.GetValue(myFieldObjectB));
		}
		catch(SecurityException e)
		{
			Console.WriteLine("Exception Raised !");
			Console.WriteLine("Message :"+e.Message);
		}
		catch(ArgumentNullException e)
		{
			Console.WriteLine("Exception Raised !");
			Console.WriteLine("Message :"+e.Message);
		}
		catch(Exception e)
		{
			Console.WriteLine("Exception Raised !");
			Console.WriteLine("Message :"+e.Message);
		}
	}
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

See also:
FieldInfo | String | Type.DefaultBinder | ReflectionPermission | Type.GetFields

Return to top

Overloaded Method: GetField(
string name,
BindingFlags bindingAttr
)

Summary: Searches for the specified field, using the specified binding constraints.

C# Syntax:


            public abstract FieldInfo GetField(
   string name,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of the data field to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: A FieldInfo object representing the field that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Implements:: IReflect.GetField

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

The following BindingFlags filter flags can be used to define which fields to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public fields in the search.
Specify BindingFlags.NonPublic to include non-public fields (that is, private and protected fields) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the fields declared on the Type, not fields that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

public class MyFieldClassA
{
	public string field = "A Field";
	public string Field
	{
		get
		{
			return field;
		}
		set
		{
			if(field!=value)
			{
				field=value;
         }
		}
	}
}
public class MyFieldClassB
{
	public string field = "B Field";
	public string Field 
	{
		get
		{
			return field;
		}
		set
		{
			if(field!=value)
			{
				field=value;
			}
		}
	}
}

public class MyFieldInfoClass
{
	public static void Main()
	{
		try
		{
			MyFieldClassB myFieldObjectB = new MyFieldClassB();
			MyFieldClassA myFieldObjectA = new MyFieldClassA();

			Type myTypeA = Type.GetType("MyFieldClassA");
			FieldInfo myFieldInfo = myTypeA.GetField("field");
		
			Type myTypeB = Type.GetType("MyFieldClassB");
			FieldInfo myFieldInfo1 = myTypeB.GetField("field", BindingFlags.Public | BindingFlags.Instance);

			Console.WriteLine("The value of the field is : {0} ", myFieldInfo.GetValue(myFieldObjectA));
			Console.WriteLine("The value of the field is : {0} ", myFieldInfo1.GetValue(myFieldObjectB));
		}
		catch(SecurityException e)
		{
			Console.WriteLine("Exception Raised !");
			Console.WriteLine("Message :"+e.Message);
		}
		catch(ArgumentNullException e)
		{
			Console.WriteLine("Exception Raised !");
			Console.WriteLine("Message :"+e.Message);
		}
		catch(Exception e)
		{
			Console.WriteLine("Exception Raised !");
			Console.WriteLine("Message :"+e.Message);
		}
	}
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetFields()

Summary: Returns all the public fields of the current Type.

C# Syntax:


            public FieldInfo[] GetFields();

Return Value:

An array of FieldInfo objects representing all the public fields defined for the current Type.

-or-

An empty array of type FieldInfo, if no public fields are defined for the current Type.

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

			Console.WriteLine("HashCode of the System.Windows.Forms.Button type is  : {0}",
            typeof(System.Windows.Forms.Button).GetHashCode());

See also:
FieldInfo | Type.GetField

Return to top

Overloaded Method: GetFields(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the fields defined for the current Type, using the specified binding constraints.

C# Syntax:


            public abstract FieldInfo[] GetFields(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:

An array of FieldInfo objects representing all fields defined for the current Type that match the specified binding constraints.

-or-

An empty array of type FieldInfo, if no fields are defined for the current Type, or if none of the defined fields match the binding constraints.

Implements:: IReflect.GetFields

Remarks

The following BindingFlags filter flags can be used to define which fields to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public fields in the search.
Specify BindingFlags.NonPublic to include non-public fields (that is, private and protected fields) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.DeclaredOnly to search only the fields declared on the Type, not fields that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

			Console.WriteLine("HashCode of the System.Windows.Forms.Button type is  : {0}",
            typeof(System.Windows.Forms.Button).GetHashCode());

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

See also:
FieldInfo | BindingFlags | Type.DefaultBinder | ReflectionPermission | Type.GetField

Return to top

Overridden Method: GetHashCode()

Summary: Returns the hash code for this instance.

C# Syntax:


            public override int GetHashCode();

Return Value:: An Int32 containing the hash code for this instance.

Remarks

This method overrides Object.GetHashCode.

Example

			Console.WriteLine("HashCode of the System.Windows.Forms.Button type is  : {0}",
            typeof(System.Windows.Forms.Button).GetHashCode());

Return to top

Overloaded Method: GetInterface(
string name
)

Summary: Searches for the interface with the specified name.

C# Syntax:


            public Type GetInterface(
   string name
);

Parameters:

name

The String containing the name of the interface to get.

Return Value:: A Type object representing the interface with the specified name, implemented or inherited by the current Type, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.
TargetInvocationException	A static initializer is invoked and throws an exception.

Remarks

The search for name is case-sensitive.

Example

    public static void Main()
    {
        Hashtable hashtableObj = new Hashtable();
        Type objType = hashtableObj.GetType();
        MemberInfo[] arrayMemberInfo;
        MethodInfo[] arrayMethodInfo;
        try
        {   
            // Get the methods implemented in 'IDeserializationCallback' interface.
            arrayMethodInfo =objType.GetInterface("IDeserializationCallback").GetMethods();
            Console.WriteLine ("\nMethods of 'IDeserializationCallback' Interface :");
            for(int index=0;index < arrayMethodInfo.Length ;index++)
                Console.WriteLine (arrayMethodInfo[index].ToString() ); 

            // Get FullName for interface by using Ignore case search.
            Console.WriteLine ("\nMethods of 'IEnumerable' Interface");
            arrayMethodInfo = objType.GetInterface("ienumerable",true).GetMethods();
            for(int index=0;index < arrayMethodInfo.Length ;index++)
               Console.WriteLine (arrayMethodInfo[index].ToString()); 
           
            //Get the Interface methods for 'IDictionary' interface
            InterfaceMapping interfaceMappingObj;
            interfaceMappingObj = objType.GetInterfaceMap(typeof(IDictionary));
            arrayMemberInfo = interfaceMappingObj.InterfaceMethods;
            Console.WriteLine ("\nHashtable class Implements the following IDictionary Interface methods :");
            for(int index=0; index < arrayMemberInfo.Length; index++)
                Console.WriteLine (arrayMemberInfo[index].ToString() ); 
        }
        catch (Exception e)
        {
            Console.WriteLine ("Exception : " + e.ToString());            
        }                 
    }

See also:
String | Type.GetInterfaces | Type.FindInterfaces

Return to top

Overloaded Method: GetInterface(
string name,
bool ignoreCase
)

Summary: When overridden in a derived class, searches for the specified interface, specifying whether to do a case-sensitive search.

C# Syntax:


            public abstract Type GetInterface(
   string name,
   bool ignoreCase
);

Parameters:

name

The String containing the name of the interface to get.

ignoreCase

true to perform a case-insensitive search for name.

-or-

false to perform a case-sensitive search for name.

true to perform a case-insensitive search for name.

-or-

false to perform a case-sensitive search for name.

Return Value:: A Type object representing the interface with the specified name, implemented or inherited by the current Type, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.
TargetInvocationException	A static initializer is invoked and throws an exception.

Remarks

Arrays or COM types are not searched for unless they have been previously loaded into the table of available classes.

Example

    public static void Main()
    {
        Hashtable hashtableObj = new Hashtable();
        Type objType = hashtableObj.GetType();
        MemberInfo[] arrayMemberInfo;
        MethodInfo[] arrayMethodInfo;
        try
        {   
            // Get the methods implemented in 'IDeserializationCallback' interface.
            arrayMethodInfo =objType.GetInterface("IDeserializationCallback").GetMethods();
            Console.WriteLine ("\nMethods of 'IDeserializationCallback' Interface :");
            for(int index=0;index < arrayMethodInfo.Length ;index++)
                Console.WriteLine (arrayMethodInfo[index].ToString() ); 

            // Get FullName for interface by using Ignore case search.
            Console.WriteLine ("\nMethods of 'IEnumerable' Interface");
            arrayMethodInfo = objType.GetInterface("ienumerable",true).GetMethods();
            for(int index=0;index < arrayMethodInfo.Length ;index++)
               Console.WriteLine (arrayMethodInfo[index].ToString()); 
           
            //Get the Interface methods for 'IDictionary' interface
            InterfaceMapping interfaceMappingObj;
            interfaceMappingObj = objType.GetInterfaceMap(typeof(IDictionary));
            arrayMemberInfo = interfaceMappingObj.InterfaceMethods;
            Console.WriteLine ("\nHashtable class Implements the following IDictionary Interface methods :");
            for(int index=0; index < arrayMemberInfo.Length; index++)
                Console.WriteLine (arrayMemberInfo[index].ToString() ); 
        }
        catch (Exception e)
        {
            Console.WriteLine ("Exception : " + e.ToString());            
        }                 
    }

See also:
String | Type.GetInterfaces | Type.FindInterfaces

Return to top

Method: GetInterfaceMap(
Type interfaceType
)

Summary: Returns an interface mapping for the specified interface type.

C# Syntax:


            public virtual InterfaceMapping GetInterfaceMap(
   Type interfaceType
);

Parameters:

interfaceType

The Type of the interface of which to retrieve a mapping.

Return Value:: An InterfaceMapping object representing the interface mapping for interfaceType.

Exceptions

Exception Type	Condition
ArgumentException	The interfaceType parameter does not refer to an interface.
ArgumentNullException	interfaceType is null.

Remarks

The interface map denotes how an interface is mapped into the actual methods on a class that implements that interface.

See also:
InterfaceMapping

Return to top

Method: GetInterfaces()

Summary: When overridden in a derived class, gets all the interfaces implemented or inherited by the current Type.

C# Syntax:


            public abstract Type[] GetInterfaces();

Return Value:

An array of Type objects representing all the interfaces implemented or inherited by the current Type.

-or-

An empty array of type Type, if no interfaces are implemented or inherited by the current Type.

Exceptions

Exception Type	Condition
TargetInvocationException	A static initializer is invoked and throws an exception.

Remarks

	public class MyTemplate : Control, INamingContainer 
    {
        private String _message = null;
        public String Message 
		  {
				get 
				{
					return _message;
				}
				set 
				{
					_message = value;
				}
			}	
	}
	public class MyInterfacesSample
	{
		public static void Main()
		{
			try
			{
				Type[] myObjectArray= typeof(MyTemplate).GetInterfaces();
				Console.WriteLine("The Interfaces inherited by the MyTemplate class are :\n");
				for (int index = 0; index < myObjectArray.Length; index++)
				{	
					Console.WriteLine(myObjectArray[index]);
				}
			}
			catch (Exception e)
			{
				Console.WriteLine("Exception Raised !");
				Console.WriteLine("Message : " + e.Message);
			}
		}
	}

See also:
Type.GetInterface | Type.FindInterfaces

Return to top

Overloaded Method: GetMember(
string name
)

Summary: Searches for the members with the specified name.

C# Syntax:


            public MemberInfo[] GetMember(
   string name
);

Parameters:

name

The String containing the name of the public members to get.

Return Value:: An array of MemberInfo objects representing the public members with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

Members include properties, methods, fields, events, and so on.

This method searches the current classes and its base classes. Only public methods can be found using this method. If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

	public void GetMemberInfo()
	{
		String myString = "GetMember_String";

		Type myType = myString.GetType();
		// Get the members for myString starting with 'C',using searchCriteria 'C*'.
		MemberInfo[] myMembers = myType.GetMember("C*");
      if(myMembers.Length > 0)
      {
         Console.WriteLine("\nThe Member(s) starting with 'C' for type {0} :", myType);
         for(int index=0; index < myMembers.Length; index++)
            Console.WriteLine("Member {0} : {1}", index + 1, myMembers[index].ToString());
      }
      else
            Console.WriteLine("No Members match the Search Criteria.");    
	}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMember(
string name,
BindingFlags bindingAttr
)

Summary: Searches for the specified members, using the specified binding constraints.

C# Syntax:


            public virtual MemberInfo[] GetMember(
   string name,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of the members to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: An array of MemberInfo objects representing the public members with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Implements:: IReflect.GetMember

Remarks

This method can be overridden by a derived class.

Members include properties, methods, fields, events, and so on.

This method searches the current classes and its base classes. If the requested member is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

The following BindingFlags filter flags can be used to define which members to include in the search:

Instance to include instance members in the search.
Static to include static members in the search.
Public to include public members in the search.
NonPublic to include non-public members (that is, private and protected members) in the search.

The following BindingFlags modifier flags can be used to change how the search works:

IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
DeclaredOnly to search only the members declared on the Type, not members that were simply inherited.

See BindingFlags for more information.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

Example

	public void GetPublicStaticMemberInfo()
	{
		String myString = "GetMember_String_BindingFlag";

		Type myType = myString.GetType();
      // Get the Public Static members for the class myString starting with 'C'.
		MemberInfo[] myMembers = myType.GetMember("C*",
                                 BindingFlags.Public |BindingFlags.Static);

      if(myMembers.Length > 0)
      {
         Console.WriteLine("\nThe Public Static Member(s)  starting with 'C' for type {0} :",myType);
         for(int index=0; index < myMembers.Length; index++)
            Console.WriteLine("Member {0} : {1}", index + 1, myMembers[index].ToString());
      }
      else
         Console.WriteLine("No Members match the Search Criteria.");    
	}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMember(
   string name,
   MemberTypes type,
   BindingFlags bindingAttr
)

Summary: Searches for the specified members of the specified member type, using the specified binding constraints.

C# Syntax:


            public virtual MemberInfo[] GetMember(
   string name,
   MemberTypes type,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of the members to get.

type

The Type.MemberType to search for.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: An array of MemberInfo objects representing the public members with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.
NotSupportedException	A derived class must provide an implementation.

Remarks

Members include properties, methods, fields, events, and so on.

This method searches the current classes and its base classes. If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

The following BindingFlags filter flags can be used to define which members to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public members in the search.
Specify BindingFlags.NonPublic to include non-public members (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the members declared on the Type, not members that were simply inherited.

See BindingFlags for more information.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

Example

	public void GetPublicInstanceMethodMemberInfo()
	{
		String myString = "GetMember_String_MemberType_BindingFlag";

		Type myType = myString.GetType();
      // Get the Public Instance methods for myString starting with 'C'.
		MemberInfo[] myMembers = myType.GetMember("C*", MemberTypes.Method, 
							  BindingFlags.Public | BindingFlags.Instance);
      if(myMembers.Length > 0)
      {
         Console.WriteLine("\nThe Public Instance Method(s) starting with 'C' for type {0}:", myType);
         for(int index=0; index < myMembers.Length; index++)
            Console.WriteLine("Member {0} : {1}", index + 1, myMembers[index].ToString());
      }
      else
         Console.WriteLine("No Members match the Search Criteria.");    
	}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMembers()

Summary: Returns all the public members of the current Type.

C# Syntax:


            public MemberInfo[] GetMembers();

Return Value:

An array of MemberInfo objects representing all the public members of the current Type.

-or-

An empty array of type MemberInfo, if the current Type does not have public members.

Remarks

Members include properties, methods, fields, events, and so on.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

class MyClass
{
   public int myInt = 0;
   public string myString = null;

   public MyClass()
   {
   }
   public void Myfunction()
   {
   }
}

class Type_GetMembers
{
   public static void Main()
   {
      try
      {
         MyClass myObject = new MyClass();
         MemberInfo[] myMemberInfo; 

         // Get the type of 'MyClass'.
         Type myType = myObject.GetType(); 
        
         // Get the information related to all public member's of 'MyClass'. 
         myMemberInfo = myType.GetMembers();
    
         Console.WriteLine( "\nThe members of class '{0}' are :\n", myType); 
         for (int i =0 ; i < myMemberInfo.Length ; i++)
         {
            // Display name and type of the concerned member.
            Console.WriteLine( "'{0}' is a {1}", myMemberInfo[i].Name, myMemberInfo[i].MemberType);
         }
      }
      catch(SecurityException e)
      {
         Console.WriteLine("Exception : " + e.Message ); 
      }
   }
}

See also:
MemberInfo | Type.GetMember | Type.GetDefaultMembers | Type.FindMembers

Return to top

Overloaded Method: GetMembers(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the members defined for the current Type, using the specified binding constraints.

C# Syntax:


            public abstract MemberInfo[] GetMembers(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:

An array of MemberInfo objects representing all members defined for the current Type that match the specified binding constraints.

-or-

An empty array of type MemberInfo, if no members are defined for the current Type, or if none of the defined members match the binding constraints.

Implements:: IReflect.GetMembers

Remarks

Members include properties, methods, fields, events, and so on.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

The following BindingFlags filter flags can be used to define which members to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public members in the search.
Specify BindingFlags.NonPublic to include non-public members (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.DeclaredOnly to search only the members declared on the Type, not members that were simply inherited.

Calling this method with only the Public flag or only the NonPublic flag will return the specified members and does not require any other flags.

See BindingFlags for more information.

Class initializers are available through Type.GetMember, Type.GetMembers, Type.FindMembers, and Type.GetConstructors.

Example


class MyClass
{
   public int myInt = 0;
   public string myString = null;

   public MyClass()
   {
   }
   public void Myfunction()
   {
   }
}

class Type_GetMembers_BindingFlags
{
   public static void Main()
   {
      try
      {
         MyClass MyObject = new MyClass();
         MemberInfo [] myMemberInfo; 

         // Get the type of the class 'MyClass'.
         Type myType = MyObject.GetType(); 
        
         // Get the public instance members of the class 'MyClass'. 
         myMemberInfo = myType.GetMembers(BindingFlags.Public|BindingFlags.Instance);
    
         Console.WriteLine( "\nThe public instance members of class '{0}' are : \n", myType); 
         for (int i =0 ; i < myMemberInfo.Length ; i++)
         {
            // Display name and type of the member of 'MyClass'.
            Console.WriteLine( "'{0}' is a {1}", myMemberInfo[i].Name, myMemberInfo[i].MemberType);
         }

      }
      catch (SecurityException e)
      {
         Console.WriteLine("SecurityException : " + e.Message ); 
      }      
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethod(
string name
)

Summary: Searches for the public method with the specified name.

C# Syntax:


            public MethodInfo GetMethod(
   string name
);

Parameters:

name

The String containing the name of the public method to get.

Return Value:: A MethodInfo object representing the public method with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
AmbiguousMatchException	More than one method is found with the specified name.
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

class MyClass
{
   public int myInt = 0;
   public string myString = null;

   public MyClass()
   {
   }
   public void Myfunction(int i)
   {
   } 
}
class Type_GetMethod
{
   public static void Main()
   {
      try
      {         
         MyClass MyObject = new MyClass();
         MethodInfo myMethodInfo; 

         // Get the type of the class 'MyClass'.
         Type myType = MyObject.GetType(); 
        
         // Get the method information for a method named 'MyFunction'. 
         myMethodInfo = myType.GetMethod("Myfunction");
         
         // Get the parameters for the method 'Myfunction'.
         ParameterInfo[] myParameters = myMethodInfo.GetParameters();
    
         Console.WriteLine( "\nThe parameters of the method 'Myfunction' of class 'MyClass' are :\n"); 
         
         // Display the position and type of the parameters.
         for(int i = 0; i < myParameters.Length; i++)
            Console.WriteLine("The parameter {0} is of type {1}", 
               myParameters[i].Position + 1, myParameters[i].ParameterType);
      }
      catch (SecurityException e)
      {
         Console.WriteLine("SecurityException : " + e.Message ); 
      }
      catch (Exception e)
      {
         Console.WriteLine("Exception : " + e.Message ); 
      }      
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethod(
string name,
BindingFlags bindingAttr
)

Summary: Searches for the specified method, using the specified binding constraints.

C# Syntax:


            public MethodInfo GetMethod(
   string name,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of the method to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: A MethodInfo object representing the method that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type	Condition
AmbiguousMatchException	More than one method is found with the specified name and matching the specified binding constraints.
ArgumentNullException	name is null.

Implements:: IReflect.GetMethod

Remarks

The following BindingFlags filter flags can be used to define which methods to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public methods in the search.
Specify BindingFlags.NonPublic to include non-public methods (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static methods up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

class MyClass
{
   public void MyMethod()
   {    
   }
}

public class Type_GetMethod
{
   public static void Main()
   {
      try
      {
         // Get the type of 'MyClass'.
         Type myType = typeof(MyClass);
         
         // Get the method information of the type 'MyClass'.
         MethodInfo myMethodInfo = myType.GetMethod("MyMethod",
            BindingFlags.Public|BindingFlags.Instance );
         
         // Displays the member info to the console.
         Console.WriteLine("\nThe signature of 'MyMethod' is : {0}", myMethodInfo.ToString());
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception : {0}", e.Message);
      }
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethod(
string name,
Type[] types
)

Summary: Searches for the specified public method whose parameters match the specified argument types.

C# Syntax:


            public MethodInfo GetMethod(
   string name,
   Type[] types
);

Parameters:

name

The String containing the name of the public method to get.

types

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

Return Value:: A MethodInfo object representing the public method whose parameters match the specified argument types, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one method is found with the specified name and specified parameters.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

            // Get a 'Type' object corresponding to 'MyClass1' class.
            Type myClassType = typeof(MyClass1);
            // Create a Type array.
            Type[] typeArray =new Type[1];
            typeArray.SetValue(typeof(int),0);
            // Find the method matching the specified argument types.
            MethodInfo myMethodInfo = 
                        myClassType.GetMethod("MyMethod",typeArray);
            Console.WriteLine("The Name of the Method :"+myMethodInfo);

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethod(
   string name,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for the specified public method whose parameters match the specified argument types and modifiers.

C# Syntax:


            public MethodInfo GetMethod(
   string name,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the public method to get.

types

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A MethodInfo object representing the public method that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one method is found with the specified name and specified parameters.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethod(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints.

C# Syntax:


            public MethodInfo GetMethod(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the method to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

types

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A MethodInfo object representing the method that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one method is found with the specified name and matching the specified binding constraints.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Implements:: IReflect.GetMethod

Remarks

The following BindingFlags filter flags can be used to define which methods to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public methods in the search.
Specify BindingFlags.NonPublic to include non-public methods (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static methods up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

public class MyClass
{
   public int i = 10;
   public string k = "My Field";
   public int MyMethod(int i)
   {
      this.i = i;
      return i;
   }
   public string MyMethod(string k)
   {
      this.k = k;
      return k;
   }
}
public class Type_GetMethod
{
   public static void Main()
   {
      try
      {
         // Get the type of the class 'MyClass'.
         Type myType = typeof(MyClass);

         // Get the attributes of the method and the metadata of the method 'MyMethod'.
         MethodInfo myMethodInfo = myType.GetMethod("MyMethod", 
            BindingFlags.Public | BindingFlags.Instance, null, 
            new Type[] {typeof(int)}, null);
         
         Console.WriteLine("\n Declaring type of the method '{0}' is : \n '{1}'", myMethodInfo,
            myMethodInfo.DeclaringType);
         
         // Get the attributes of the method and the metadata of the method 'MyMethod'.
         MethodInfo myMethodInfo1 = myType.GetMethod("MyMethod", 
            BindingFlags.Public | BindingFlags.Instance, null, 
            new Type[] {typeof(string)}, null);
         
         Console.WriteLine("\n Declaring type of the method '{0}' is : \n '{1}'", myMethodInfo1,
            myMethodInfo1.DeclaringType);
         
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception : {0}", e.Message);
      }
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethod(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

C# Syntax:


            public MethodInfo GetMethod(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the method to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

callConvention

types

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A MethodInfo object representing the method that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one method is found with the specified name and matching the specified binding constraints.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

The following table shows what members of a base class are returned by the GetXXX methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

The following BindingFlags filter flags can be used to define which methods to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public methods in the search.
Specify BindingFlags.NonPublic to include non-public methods (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static methods up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example


public class MyClass
{
   public int i = 10;
   public int j = 2;
   
   public int MyFunc(int i , int j)
   {
      int k;
      k = i * 10 - j;
      return k;
   }
}
public class Type_GetMethod
{
   public static void Main()
   {
      try
      {
         // Get the type of the class 'MyClass'.
         Type myType = typeof(MyClass);

         // Get the method information of 'MyFunc(int , int )'.
         MemberInfo myMemberInfo = myType.GetMethod("MyFunc", BindingFlags.Public |
                                                         BindingFlags.Instance, 
                                                         null, 
                                                         CallingConventions.Any,  
                                                         new Type[] {typeof(int),typeof(int)}, 
                                                         null);
         
         Console.WriteLine("\nDisplaying method 'MyFunc' : \n");
         
         // Print the method information to the console.
         Console.WriteLine("{0}", myMemberInfo);
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception : {0}", e.Message);
      }
   }
}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Method: GetMethodImpl(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: When overridden in a derived class, searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

C# Syntax:


            protected abstract MethodInfo GetMethodImpl(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   CallingConventions callConvention,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the method to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

callConvention

types

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

-or-

null. If types is null, arguments are not matched.

An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

-or-

null. If types is null, arguments are not matched.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A MethodInfo object representing the method that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one method is found with the specified name and matching the specified binding constraints.

name is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

If types is null, arguments are not matched.

The following BindingFlags filter flags can be used to define which methods to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public methods in the search.
Specify BindingFlags.NonPublic to include non-public methods (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static methods up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

Return to top

Overloaded Method: GetMethods()

Summary: Returns all the public methods of the current Type.

C# Syntax:


            public MethodInfo[] GetMethods();

Return Value:

An array of MethodInfo objects representing all the public methods defined for the current Type.

-or-

An empty array of type MethodInfo, if no public methods are defined for the current Type.

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

See also:
MethodInfo | Type.GetMethod

Return to top

Overloaded Method: GetMethods(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the methods defined for the current Type, using the specified binding constraints.

C# Syntax:


            public abstract MethodInfo[] GetMethods(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:

An array of MethodInfo objects representing all methods defined for the current Type that match the specified binding constraints.

-or-

An empty array of type MethodInfo, if no methods are defined for the current Type, or if none of the defined methods match the binding constraints.

Implements:: IReflect.GetMethods

Remarks

The following BindingFlags filter flags can be used to define which methods to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public methods in the search.
Specify BindingFlags.NonPublic to include non-public methods (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static methods up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Note You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

			public static void Main() 
			{

				Type myType =(typeof(MyTypeClass));
				// Get the methods with the Access-Specifier as public.
				MethodInfo[] myArrayMethodInfo = myType.GetMethods(BindingFlags.Public|BindingFlags.Instance|BindingFlags.DeclaredOnly);
				Console.WriteLine("\nThe Number of Public Methods are :"+myArrayMethodInfo.Length);
				Console.WriteLine("The Names of the Public Methods are :");
				// Display all the methods.
				DisplayMethodInfo(myArrayMethodInfo);
				// Get the methods information of all 'NonPublic'.
				MethodInfo[] myArrayMethodInfo1 = myType.GetMethods(BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.DeclaredOnly);
				Console.WriteLine("\nThe Number of Protected Methods are :"+myArrayMethodInfo1.Length);
				Console.WriteLine("The Names of the Protected methods are :");
				// Display all the methods information.
				DisplayMethodInfo(myArrayMethodInfo1);		
			}
			public static void DisplayMethodInfo(MethodInfo[] myArrayMethodInfo)
			{
				// Display  the information of all the Methods.
				for(int i=0;i<myArrayMethodInfo.Length;i++)
				{
					MethodInfo myMethodInfo = (MethodInfo)myArrayMethodInfo[i];
					Console.WriteLine("\nName of the Method is :"+myMethodInfo.Name);
				}
			}

.NET Framework Security:

ReflectionPermission for reflecting non-public objects. Associated enumeration: ReflectionPermissionFlag.TypeInformation

See also:
MethodInfo | BindingFlags | Type.DefaultBinder | ReflectionPermission | Type.GetMethod

Return to top

Overloaded Method: GetNestedType(
string name
)

Summary: Searches for the nested type with the specified name.

C# Syntax:


            public Type GetNestedType(
   string name
);

Parameters:

name

The String containing the name of the nested type to get.

Return Value:: A Type object representing the nested type with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

See also:
String | Type.DefaultBinder | Type.GetNestedTypes

Return to top

Overloaded Method: GetNestedType(
string name,
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the specified nested type, using the specified binding constraints.

C# Syntax:


            public abstract Type GetNestedType(
   string name,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of the nested type to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: A Type object representing the nested type that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type	Condition
ArgumentNullException	name is null.

Remarks

The following BindingFlags filter flags can be used to define which nested types to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public nested types in the search.
Specify BindingFlags.NonPublic to include non-public nested types (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static nested types up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the nested types declared on the Type, not nested types that were simply inherited.

See BindingFlags for more information.

.NET Framework Security:

ReflectionPermission for reflecting methods that are not public. Associated enumerations: ReflectionPermissionFlag.MemberAccess, ReflectionPermissionFlag.TypeInformation

See also:
String | BindingFlags | Type.DefaultBinder | Type.GetNestedTypes

Return to top

Overloaded Method: GetNestedTypes()

Summary: Returns all the types nested within the current Type.

C# Syntax:


            public Type[] GetNestedTypes();

Return Value:: An array of Type objects representing all the types nested within the current Type.
-or-
An empty array of type Type, if no types are nested within the current Type.

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

                  // Get Type Object corresponding to MyClass.
                  Type myType=typeof(MyClass);
                  // Get array of nested type objects which are in 'MyClass'.                 
                  Type[] nestType=myType.GetNestedTypes();
                  Console.WriteLine("Number of nested types are {0}",nestType.Length);
                  foreach(Type t in nestType)
                     Console.WriteLine("Nested type is {0}",t.ToString());

See also:
Type.GetNestedType

Return to top

Overloaded Method: GetNestedTypes(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the types nested within the current Type, using the specified binding constraints.

C# Syntax:


            public abstract Type[] GetNestedTypes(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:

An array of Type objects representing all the types nested within the current Type that match the specified binding constraints.

-or-

An empty array of type Type, if no types are nested within the current Type, or if none of the nested types match the binding constraints.

Remarks

The following BindingFlags filter flags can be used to define which nested types to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public nested types in the search.
Specify BindingFlags.NonPublic to include non-public nested types (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static nested types up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.DeclaredOnly to search only the nested types declared on the Type, not nested types that were simply inherited.

Calling this method with only the Public flag or only the NonPublic flag will return the specified nested types and does not require any other flags.

See BindingFlags for more information.

Example

			public static void Main() 
			{

				Type myType =(typeof(MyTypeClass));
				// Get the Nested classes with the Access-Specifier as public.
				Type[] myTypeArray = myType.GetNestedTypes(BindingFlags.Public|BindingFlags.Instance);
				Console.WriteLine("\nThe Public Classes are :"+myTypeArray.Length);
				Console.WriteLine("\nThe Names of the Public Classes are :");
				// Display all the Nested classes.
				DisplayTypeInfo(myTypeArray);
				// Get the Nested classes information of all 'NonPublic'.
				Type[] myTypeArray1 = myType.GetNestedTypes(BindingFlags.NonPublic|BindingFlags.Instance);
				Console.WriteLine("\nThe Number of Protected Classes are :"+myTypeArray1.Length);
				Console.WriteLine("\nThe Names of the Protected Classes are :");
				// Display  the information of all the Nested classes.
				DisplayTypeInfo(myTypeArray1);		
			}
			public static void DisplayTypeInfo(Type[] myArrayType)
			{
				// Display  the information of all the Nested classes.
				for(int i=0;i<myArrayType.Length;i++)
				{
					Type myType = (Type)myArrayType[i];
					Console.WriteLine("\nName of the Nested class is :"+myType.ToString());
				}
			}

.NET Framework Security:

ReflectionPermission for reflecting methods that are not public. Associated enumerations: ReflectionPermissionFlag.MemberAccess, ReflectionPermissionFlag.TypeInformation

See also:
BindingFlags | Type.DefaultBinder | Type.GetNestedType

Return to top

Overloaded Method: GetProperties()

Summary: Returns all the public properties of the current Type.

C# Syntax:


            public PropertyInfo[] GetProperties();

Return Value:

An array of PropertyInfo objects representing all public properties of the current Type.

-or-

An empty array of type PropertyInfo, if the current Type does not have public properties.

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

Example

				PropertyInfo[] myPropertyInfo;
				// Get the properties of 'Type' class object.
				myPropertyInfo = Type.GetType("System.Type").GetProperties();
				Console.WriteLine("Properties of System.Type are:");
            for (int i = 0; i < myPropertyInfo.Length; i++)
				{
					Console.WriteLine(myPropertyInfo[i].ToString());
				}

See also:
PropertyInfo | Type.GetProperty

Return to top

Overloaded Method: GetProperties(
BindingFlags bindingAttr
)

Summary: When overridden in a derived class, searches for the properties of the current Type, using the specified binding constraints.

C# Syntax:


            public abstract PropertyInfo[] GetProperties(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:

An array of PropertyInfo objects representing all properties of the current Type that match the specified binding constraints.

-or-

An empty array of type PropertyInfo, if the current Type does not have properties, or if none of the properties match the binding constraints.

Implements:: IReflect.GetProperties

Remarks

A property is considered public to reflection if it has at least one accessor that is public. That is, you can call type.GetProperty("propertyname", BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static) to get it.

Otherwise, the property is private and you must use type.GetProperty("propertyname", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static) to get it.

The following BindingFlags filter flags can be used to define which nested types to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public properties in the search.
Specify BindingFlags.NonPublic to include non-public properties (that is, private and protected members) in the search.
Specify BindingFlags.FlattenHierarchy to include static properties up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.DeclaredOnly to search only the properties declared on the Type, not properties that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

				public static void Main() 
				{
					Type myType =(typeof(MyTypeClass));
					// Get the properties having  the Access-Specifier as public.
					PropertyInfo[] myPropertyInfo = myType.GetProperties(BindingFlags.Public|BindingFlags.Instance);
					Console.WriteLine("\nThe Number of Public Properties are :"+myPropertyInfo.Length);
					Console.WriteLine("\nThe Names of the Public properties are :");
					// Display all the properties.
					DisplayPropertyInfo(myPropertyInfo);
					// Get the properties information of all 'NonPublic'.
					PropertyInfo[] myPropertyInfo1 = myType.GetProperties(BindingFlags.NonPublic|BindingFlags.Instance);
					Console.WriteLine("\nThe Number of Protected Properties are :"+myPropertyInfo1.Length);
					Console.WriteLine("\nThe Names of the Protected properties are :");
					// Display all the properties information.
					DisplayPropertyInfo(myPropertyInfo1);		
				}

				public static void DisplayPropertyInfo(PropertyInfo[] myPropertyInfo)
				{
					// Display  the information of all the properties .
					for(int i=0;i<myPropertyInfo.Length;i++)
					{
						PropertyInfo myPropInfo = (PropertyInfo)myPropertyInfo[i];
						Console.WriteLine("\nName of the property is :"+myPropInfo.Name);
						Console.WriteLine("Type of the property is :"+myPropInfo.PropertyType);
					}
				}

See also:
PropertyInfo | BindingFlags | Type.DefaultBinder | Type.GetProperty

Return to top

Overloaded Method: GetProperty(
string name
)

Summary: Searches for the public property with the specified name.

C# Syntax:


            public PropertyInfo GetProperty(
   string name
);

Parameters:

name

The String containing the name of the public property to get.

Return Value:: A PropertyInfo object representing the public property with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
AmbiguousMatchException	More than one property is found with the specified name.
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Different languages use different syntax to specify default or parameterized properties.

            // Get Type Object corresponding to MyClass.
            Type myType=typeof(MyClass);       
            // Get PropertyInfo object by passing property name.
            PropertyInfo myPropInfo = myType.GetProperty("MyProperty");
            // Display Name propety to console.
            Console.WriteLine("The Property {0} exists",myPropInfo.Name);
            }

Internally, this property is referred to by the name "Item" in the metadata. Therefore, any attempt to get PropertyInfo using reflection must specify this internal name in order for the PropertyInfo to be returned correctly.

Return to top

Overloaded Method: GetProperty(
string name,
BindingFlags bindingAttr
)

Summary: Searches for the specified property, using the specified binding constraints.

C# Syntax:


            public PropertyInfo GetProperty(
   string name,
   BindingFlags bindingAttr
);

Parameters:

name

The String containing the name of the property to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

Return Value:: A PropertyInfo object representing the property that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type	Condition
AmbiguousMatchException	More than one property is found with the specified name and matching the specified binding constraints.
ArgumentNullException	name is null.

Implements:: IReflect.GetProperty

Remarks

The following BindingFlags filter flags can be used to define which properties to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public properties in the search.
Specify BindingFlags.NonPublic to include non-public properties (that is, private and protected properties ) in the search.
Specify BindingFlags.FlattenHierarchy to include static properties up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the properties declared on the Type, not properties that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Different languages use different syntax to specify default or parameterized properties.

            // Get Type Object corresponding to MyClass.
            Type myType=typeof(MyClass);       
            // Get PropertyInfo object by passing property name and specifying BindingFlags.
            PropertyInfo myPropInfo = myType.GetProperty("MyProperty",
                                                   BindingFlags.Public|
                                                   BindingFlags.Instance);
            // Display Name propety to console.
            Console.WriteLine("{0} is a Property of 'MyClass'.",myPropInfo.Name);
            }

Return to top

Overloaded Method: GetProperty(
string name,
Type returnType
)

Summary: Searches for the public property with the specified name and return type.

C# Syntax:


            public PropertyInfo GetProperty(
   string name,
   Type returnType
);

Parameters:

name

The String containing the name of the public property to get.

returnType

The return type of the property.

Return Value:: A PropertyInfo object representing the public property with the specified name, if found; otherwise, null.

Exceptions

Exception Type	Condition
AmbiguousMatchException	More than one property is found with the specified name.
ArgumentNullException	name is null.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Different languages use different syntax to specify default or parameterized properties.

			Type myType = typeof(MyClass1);
		
			// Get the 'PropertyInfo' object representing 'MyProperty1' property. 
			PropertyInfo myStringProperties1 = myType.GetProperty("MyProperty1",
				typeof(string));
			Console.WriteLine("The Name of the first Property of MyClass1 :"+myStringProperties1.Name);
			Console.WriteLine("The Type of first Property of MyClass1 :"+myStringProperties1.PropertyType);

			// Get a 'Type' array  corresponding to the indexed  property.
			Type[] myTypeArr = new Type[2];
			myTypeArr.SetValue(typeof(int),0);            
			myTypeArr.SetValue(typeof(int),1);

			// Get the 'PropertyInfo' object representing 'MyProperty2' property. 
			PropertyInfo myStringProperties2 =myType.GetProperty("Item",typeof(int),myTypeArr);
			Console.WriteLine("{0} property exists in MyClass1.",myStringProperties2.ToString());
			Console.WriteLine("The Name of the second Property of MyClass1 :"+myStringProperties2.Name);
			Console.WriteLine("The Type of second Property of MyClass1 :"+myStringProperties2.PropertyType);

Return to top

Overloaded Method: GetProperty(
string name,
Type[] types
)

Summary: Searches for the specified public property whose parameters match the specified argument types.

C# Syntax:


            public PropertyInfo GetProperty(
   string name,
   Type[] types
);

Parameters:

name

The String containing the name of the public property to get.

types

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

Return Value:: A PropertyInfo object representing the public property whose parameters match the specified argument types, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one property is found with the specified name and matching the specified argument types.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Different languages use different syntax to specify default or parameterized properties.

				// Get Type Object.
				Type myType=typeof(MyClass1);       
				Type[] myTypeArr = new Type[2];
				// Initialize Type array.
				myTypeArr.SetValue(typeof(int),0);            
				myTypeArr.SetValue(typeof(int),1);
				// Get PropertyInfo object for indexed property 'Item' which has two integer parameters. 
				PropertyInfo myPropInfo = myType.GetProperty("Item",myTypeArr);
				// Dispaly propety to console.
				Console.WriteLine("{0} property exists in MyClass1.",myPropInfo.ToString());

Return to top

Overloaded Method: GetProperty(
   string name,
   Type returnType,
   Type[] types
)

Summary: Searches for the specified public property whose parameters match the specified argument types.

C# Syntax:


            public PropertyInfo GetProperty(
   string name,
   Type returnType,
   Type[] types
);

Parameters:

name

The String containing the name of the public property to get.

returnType

The return type of the property.

types

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

Return Value:: A PropertyInfo object representing the public property whose parameters match the specified argument types, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one property is found with the specified name and matching the specified argument types.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Return to top

Overloaded Method: GetProperty(
   string name,
   Type returnType,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for the specified public property whose parameters match the specified argument types and modifiers.

C# Syntax:


            public PropertyInfo GetProperty(
   string name,
   Type returnType,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the public property to get.

returnType

The return type of the property.

types

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A PropertyInfo object representing the public property that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one property is found with the specified name and matching the specified argument types and modifiers.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

The search for name is case-sensitive.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Different languages use different syntax to specify default or parameterized properties.

// MyPropAA - ReadOnly
protected short m_prvPropAA = -1;
public short m_PropAA = -2;
public short this [Boolean nonPublic]
{
    //get accessor for property {short MyPropAA}
    get {
        return ((nonPublic) ? m_prvPropAA: m_PropAA);
    }
}

Return to top

Overloaded Method: GetProperty(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   Type returnType,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: Searches for the specified property whose parameters match the specified argument types and modifiers, using the specified binding constraints.

C# Syntax:


            public PropertyInfo GetProperty(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   Type returnType,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the property to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

returnType

The return type of the property.

types

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A PropertyInfo object representing the property that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one property is found with the specified name and matching the specified binding constraints.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.

types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Implements:: IReflect.GetProperty

Remarks

The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Member Type	Static	Non-Static
Constructor	No	No
Field	No	Yes. A field is always hide-by-name-and-signature.
Event	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.
Method	No	Yes. A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Nested Type	No	No
Property	Not applicable	The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflection treats properties as hide-by-name-and-signature. See note 2 below.

Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. This is a binary comparison.
For reflection, properties and events are hide-by-name-and-signature. If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.
Custom attributes are not part of the common type system.

The following BindingFlags filter flags can be used to define which properties to include in the search:

You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
Specify BindingFlags.Public to include public properties in the search.
Specify BindingFlags.NonPublic to include non-public properties (that is, private and protected properties ) in the search.
Specify BindingFlags.FlattenHierarchy to include static properties up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

BindingFlags.IgnoreCase to ignore the case of name. If name has 128 or more standard ASCII characters, a case-sensitive search is performed, regardless of the IgnoreCase flag.
BindingFlags.DeclaredOnly to search only the properties declared on the Type, not properties that were simply inherited.

See BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns null.

Example

Different languages use different syntax to specify default or parameterized properties.

Return to top

Method: GetPropertyImpl(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   Type returnType,
   Type[] types,
   ParameterModifier[] modifiers
)

Summary: When overridden in a derived class, searches for the specified property whose parameters match the specified argument types and modifiers, using the specified binding constraints.

C# Syntax:


            protected abstract PropertyInfo GetPropertyImpl(
   string name,
   BindingFlags bindingAttr,
   Binder binder,
   Type returnType,
   Type[] types,
   ParameterModifier[] modifiers
);

Parameters:

name

The String containing the name of the property to get.

bindingAttr

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return null.

binder

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded member, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded member, coercion of argument types, and invocation of a member through reflection.

-or-

null, to use the Type.DefaultBinder.

returnType

The return type of the property.

types

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

An array of Type objects representing the number, order, and type of the parameters for the indexed property to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a property that is not indexed.

modifiers

An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value:: A PropertyInfo object representing the property that matches the specified requirements, if found; otherwise, null.

Exceptions

Exception Type

Condition

More than one property is found with the specified name and matching the specified binding constraints.

name is null.

-or-

types is null.

-or-

One of the elements in types is null.