Type: System.Reflection.Emit.EnumBuilder

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
)

Inherited
See base class member description: System.Type.GetConstructor

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
)

Inherited
See base class member description: System.Type.GetConstructor

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

Overridden Method: GetConstructorImpl(
   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:


            protected override 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 conduct a case-sensitive search for public methods.

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

-or-

Zero, to conduct a case-sensitive search for public methods.

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.

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

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround to retrieve the constructor of a finished type, you can retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetConstructors()

Inherited
See base class member description: System.Type.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: Returns an array of ConstructorInfo objects representing the public and non-public constructors defined for this class, as specified.

C# Syntax:


            public override ConstructorInfo[] GetConstructors(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This must be a bit flag from BindingFlags: InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of ConstructorInfo objects representing the specified constructors defined for this class. If no constructors are defined, an empty array is returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the constructor of a finished type, you can retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetCustomAttributes(
bool inherit
)

Summary: Returns all the custom attributes defined for this constructor.

C# Syntax:


            public override object[] GetCustomAttributes(
   bool inherit
);

Parameters:

inherit

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

Return Value:: Returns an array of objects representing all the custom attributes of the constructor represented by this ConstructorBuilder instance.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: ICustomAttributeProvider.GetCustomAttributes

Remarks

As a workaround, to retrieve the custom attributes of a finished type, retrieve the type using Type.GetType and call MemberInfo.GetCustomAttributes on the returned Type.

Return to top

Overloaded Method: GetCustomAttributes(
Type attributeType,
bool inherit
)

Summary: Returns the custom attributes identified by the given type.

C# Syntax:


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

Parameters:

attributeType

The Type object to which the custom attributes are applied.

inherit

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

Return Value:: Returns an array of objects representing the attributes of this constructor that are of TypeattributeType.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: ICustomAttributeProvider.GetCustomAttributes

Remarks

As a workaround, to retrieve the custom attributes of a finished type, retrieve the type using Type.GetType and call MemberInfo.GetCustomAttributes on the returned Type.

Return to top

Method: GetDefaultMembers()

Inherited
See base class member description: System.Type.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

Overridden Method: GetElementType()

Summary: Calling this method always throws NotSupportedException.

C# Syntax:


            public override Type GetElementType();

Return Value:: This method is not supported. No value is returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported.

Return to top

Overloaded Method: GetEvent(
string name
)

Inherited
See base class member description: System.Type.GetEvent

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: Returns the event with the specified name.

C# Syntax:


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

Parameters:

name

The name of the event to get.

bindingAttr

This invocation attribute. This must be a bit flag from BindingFlags: InvokeMethod, NonPublic, and so on.

Return Value:: Returns an EventInfo object representing the event declared or inherited by this type with the specified name. If there are no matches, then an empty array is returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the event of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetEvents()

Summary: Returns the events for the public events declared or inherited by this type.

C# Syntax:


            public override EventInfo[] GetEvents();

Return Value:: Returns an array of EventInfo objects representing the public events declared or inherited by this type. An empty array is returned if there are no public events.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the events of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetEvents(
BindingFlags bindingAttr
)

Summary: Returns the public and non-public events that are declared by this type.

C# Syntax:


            public override EventInfo[] GetEvents(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This must be a bit flag from BindingFlags, such as InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of EventInfo objects representing the public and non-public events declared or inherited by this type. An empty array is returned if there are no events, as specified.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the events of a finished type, retrieve Retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type to retrieve the events.

Return to top

Overloaded Method: GetField(
string name
)

Inherited
See base class member description: System.Type.GetField

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: Returns the field specified by the given name.

C# Syntax:


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

Parameters:

name

The name of the field to get.

bindingAttr

This must be a bit flag from BindingFlags: InvokeMethod, NonPublic, and so on.

Return Value:: Returns the FieldInfo object representing the field declared or inherited by this type with the specified name and public or non-public modifier. If there are no matches, then null is returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: IReflect.GetField

Remarks

As a workaround, to retrieve the field of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetFields()

Inherited
See base class member description: System.Type.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: Returns the public and non-public fields that are declared by this type.

C# Syntax:


            public override FieldInfo[] GetFields(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This must be a bit flag from BindingFlags, such as InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of FieldInfo objects representing the public and non-public fields declared or inherited by this type. An empty array is returned if there are no fields, as specified.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: IReflect.GetFields

Remarks

As a workaround, to retrieve the field of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Method: GetHashCode()

Inherited
See base class member description: System.Type.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
)

Inherited
See base class member description: System.Type.GetInterface

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: Returns the interface implemented (directly or indirectly) by this class with the fully-qualified name matching the given interface name.

C# Syntax:


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

Parameters:

name

The name of the interface.

ignoreCase

If true, the search is case-insensitive. If false, the search is case-sensitive.

Return Value:: Returns a Type object representing the implemented interface. Returns null if no interface matching name is found.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the interface of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overridden Method: GetInterfaceMap(
Type interfaceType
)

Summary: Returns an interface mapping for the interface requested.

C# Syntax:


            public override InterfaceMapping GetInterfaceMap(
   Type interfaceType
);

Parameters:

interfaceType

The type of the interface for which the interface mapping is to be retrieved.

Return Value:: The requested interface mapping.

Exceptions

Exception Type	Condition
ArgumentException	The type does not implement the interface.

Remarks

As a workaround, to retrieve the interface mapping types of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overridden Method: GetInterfaces()

Summary: Returns an array of all the interfaces implemented on this a class and its base classes.

C# Syntax:


            public override Type[] GetInterfaces();

Return Value:: Returns an array of Type objects representing the implemented interfaces. If none are defined, an empty array is returned.

Return to top

Overloaded Method: GetMember(
string name
)

Inherited
See base class member description: System.Type.GetMember

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
)

Inherited
See base class member description: System.Type.GetMember

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: Returns all the public and non-public members declared or inherited by this type, as specified.

C# Syntax:


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

Parameters:

name

The name of the member.

type

The type of member that is to be returned.

bindingAttr

This must be a bit flag from BindingFlags: InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of MemberInfo objects representing the public and non-public members defined on this type if nonPublic is used; otherwise, only the public members are returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the member of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetMembers()

Inherited
See base class member description: System.Type.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: Returns all the public and non-public members declared or inherited by this type, as specified.

C# Syntax:


            public override MemberInfo[] GetMembers(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This must be a bit flag from BindingFlags: InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of MemberInfo objects representing the public and non-public members declared or inherited by this type. An empty array is returned if there are no matching members.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: IReflect.GetMembers

Remarks

As a workaround, to retrieve the members of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetMethod(
string name
)

Inherited
See base class member description: System.Type.GetMethod

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
)

Inherited
See base class member description: System.Type.GetMethod

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
)

Inherited
See base class member description: System.Type.GetMethod

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
)

Inherited
See base class member description: System.Type.GetMethod

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
)

Inherited
See base class member description: System.Type.GetMethod

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
)

Inherited
See base class member description: System.Type.GetMethod

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

Overridden Method: GetMethodImpl(
   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:


            protected override 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 conduct a case-sensitive search for public methods.

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

-or-

Zero, to conduct a case-sensitive search for public methods.

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.

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

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the method, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetMethods()

Inherited
See base class member description: System.Type.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: Returns all the public and non-public methods declared or inherited by this type, as specified.

C# Syntax:


            public override MethodInfo[] GetMethods(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This must be a bit flag from BindingFlags, such as InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of MethodInfo objects representing the public and non-public methods defined on this type if nonPublic is used; otherwise, only the public methods are returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: IReflect.GetMethods

Remarks

As a workaround, to retrieve the methods of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetNestedType(
string name
)

Inherited
See base class member description: System.Type.GetNestedType

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: Returns the public and non-public nested types that are declared by this type.

C# Syntax:


            public override 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 conduct a case-sensitive search for public methods.

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

-or-

Zero, to conduct a case-sensitive search for public methods.

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

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the nested type of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetNestedTypes()

Inherited
See base class member description: System.Type.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: Returns the public and non-public nested types that are declared or inherited by this type.

C# Syntax:


            public override Type[] GetNestedTypes(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This must be a bit flag from BindingFlags, such as InvokeMethod, NonPublic, and so on.

Return Value:: An array of Type objects representing all the types nested within the current Type that match the specified binding constraints.
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.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Remarks

As a workaround, to retrieve the nested types of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetProperties()

Inherited
See base class member description: System.Type.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: Returns all the public and non-public properties declared or inherited by this type, as specified.

C# Syntax:


            public override PropertyInfo[] GetProperties(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

This invocation attribute. This must be a bit flag from BindingFlags: InvokeMethod, NonPublic, and so on.

Return Value:: Returns an array of PropertyInfo objects representing the public and non-public properties defined on this type if nonPublic is used; otherwise, only the public properties are returned.

Exceptions

Exception Type	Condition
NotSupportedException	This method is not currently supported in types that are not complete.

Implements:: IReflect.GetProperties

Remarks

As a workaround, to retrieve the properties of a finished type, retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

Return to top

Overloaded Method: GetProperty(
string name
)

Inherited
See base class member description: System.Type.GetProperty

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
)

Inherited
See base class member description: System.Type.GetProperty

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
)

Inherited
See base class member description: System.Type.GetProperty

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
)

Inherited
See base class member description: System.Type.GetProperty

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
)

Inherited
See base class member description: System.Type.GetProperty

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
)

Inherited
See base class member description: System.Type.GetProperty

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
)

Inherited
See base class member description: System.Type.GetProperty

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.