Type: System.Reflection.TypeDelegator

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: Gets the constructor that implemented the TypeDelegator.

C# Syntax:


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

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

binder

An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects using reflection. If binder is null, the default binder is used.

callConvention

The calling conventions.

types

An array of type Type containing a list of the parameter number, order, and types. Types cannot be null; use an appropriate GetMethod method or an empty array to search for a method without parameters.

modifiers

An array of type ParameterModifier having the same length as the types array, whose elements represent the attributes associated with the parameters of the method to get.

Return Value:: A ConstructorInfo object for the method that matches the specified criteria, or null if a match cannot be found.

Remarks

The callConvention parameter indicates the calling convention for the entry point. If no calling convention is specified, a default CallingConventions value of Standard is used.

See also:
CallingConventions | BindingFlags | Binder

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 constructors defined for the current class.

C# Syntax:


            public override ConstructorInfo[] GetConstructors(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of type ConstructorInfo containing the specified constructors defined for this class. If no constructors are defined, an empty array is returned. Depending on the value of a specified parameter, only public constructors or both public and non-public constructors will be returned.

Remarks

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

Return to top

Overloaded Method: GetCustomAttributes(
bool inherit
)

Summary: Returns all the custom attributes defined for this type, specifying whether to search the type's inheritance chain.

C# Syntax:


            public override object[] GetCustomAttributes(
   bool inherit
);

Parameters:

inherit

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

Return Value:: An array of objects containing all the custom attributes defined for this type.

Exceptions

Exception Type	Condition
ReflectionTypeLoadException	The custom attribute type cannot be loaded.

Implements:: ICustomAttributeProvider.GetCustomAttributes

Return to top

Overloaded Method: GetCustomAttributes(
Type attributeType,
bool inherit
)

Summary: Returns an array of custom attributes identified by type.

C# Syntax:


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

Parameters:

attributeType

An array of custom attributes identified by type.

inherit

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

Return Value:: An array of objects containing the custom attributes defined in this type that match the attributeType parameter, specifying whether to search the type's inheritance chain, or null if no custom attributes are defined on this type.

Exceptions

Exception Type	Condition
ArgumentException	attributeType is null.
ReflectionTypeLoadException	The custom attribute type cannot be loaded.

Implements:: ICustomAttributeProvider.GetCustomAttributes

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: Returns the Type of the object encompassed or referred to by the current array, pointer or ByRef.

C# Syntax:


            public override Type GetElementType();

Return Value:: The Type of the object encompassed or referred to by the current array, pointer or ByRef, or null if the current Type is not an array, a pointer or a ByRef.

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 specified event.

C# Syntax:


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

Parameters:

name

The name of the event to get.

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An EventInfo object representing the event declared or inherited by this type with the specified name. Returns null if no such event is found.

Remarks

If bindingAttr is BindingFlags.IgnoreCase, the case on name is ignored.

Return to top

Overloaded Method: GetEvents()

Summary: Returns an array of EventInfo objects representing all the public events declared or inherited by the current TypeDelegator.

C# Syntax:


            public override EventInfo[] GetEvents();

Return Value:: Returns an array of type EventInfo containing all the events declared or inherited by the current type. If there are no events, an empty array is returned.

Return to top

Overloaded Method: GetEvents(
BindingFlags bindingAttr
)

Summary: Returns the events specified in bindingAttr that are declared or inherited by the current TypeDelegator.

C# Syntax:


            public override EventInfo[] GetEvents(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of type EventInfo containing the events specified in bindingAttr. If there are no events, an empty array is returned.

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 FieldInfo object representing the field with the specified name.

C# Syntax:


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

Parameters:

name

The name of the field to find.

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: A FieldInfo object representing the field declared or inherited by this TypeDelegator with the specified name. Returns null if no such field is found.

Implements:: IReflect.GetField

Remarks

Use a bindingAttr of BindingFlags.NonPublic to return all public and nonpublic fields. Use BindingFlags.IgnoreCase to ignore the case of the fields, as the search is case-sensitive by default.

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 an array of FieldInfo objects representing the data fields defined for the current class.

C# Syntax:


            public override FieldInfo[] GetFields(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of type FieldInfo containing the fields declared or inherited by the current TypeDelegator. An empty array is returned if there are no matched fields.

Implements:: IReflect.GetFields

Remarks

Use a bindingAttr of BindingFlags.NonPublic to return all public and nonpublic fields.

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 specified interface implemented by the current class.

C# Syntax:


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

Parameters:

name

The fully qualified name of the interface implemented by the current class.

ignoreCase

true if the case is to be ignored; otherwise, false.

Return Value:: A Type object representing the interface implemented (directly or indirectly) by the current class with the fully qualified name matching the specified name. If no interface that matches name is found, null is returned.

Return to top

Overridden Method: GetInterfaceMap(
Type interfaceType
)

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

C# Syntax:


            public override InterfaceMapping GetInterfaceMap(
   Type interfaceType
);

Parameters:

interfaceType

The Type of the interface to retrieve a mapping of.

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

Remarks

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

See also:
InterfaceMapping

Return to top

Overridden Method: GetInterfaces()

Summary: Returns all the interfaces implemented on the current class and its base classes.

C# Syntax:


            public override Type[] GetInterfaces();

Return Value:: An array of type Type containing all the interfaces implemented on the current class and its base classes. 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 members (properties, methods, constructors, fields, events, and nested types) specified by the given name, type, and bindingAttr.

C# Syntax:


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

Parameters:

name

The name of the member to get.

type

The type of members to get.

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of type MemberInfo containing all the members of the current class and its base class meeting the specified criteria.

Remarks

If bindingAttr is BindingFlags.NonPublic, all the members will be considered. If there are no matches, an empty array is returned.

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 members specified by bindingAttr.

C# Syntax:


            public override MemberInfo[] GetMembers(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of type MemberInfo containing all the members of the current class and its base classes that meet the bindingAttr filter.

Implements:: IReflect.GetMembers

Remarks

If bindingAttr is BindingFlags.NonPublic, all the members will be considered. If there are no matches, an empty array is returned.

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 method name.

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

binder

An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects using reflection. If binder is null, the default binder is used.

callConvention

The calling conventions.

types

modifiers

An array of type ParameterModifier having the same length as the types array, whose elements represent the attributes associated with the parameters of the method to get.

Return Value:: A MethodInfoInfo object for the implementation method that matches the specified criteria, or null if a match cannot be found.

Remarks

The callConvention parameter indicates the calling convention for the entry point. If no CallingConventions is specified, a default CallingConventions value of Standard is used.

See also:
CallingConventions | BindingFlags | Binder

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 an array of MethodInfo objects representing specified methods of the current TypeDelegator.

C# Syntax:


            public override MethodInfo[] GetMethods(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of MethodInfo objects representing the methods defined on this TypeDelegator.

Implements:: IReflect.GetMethods

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 a nested type specified by name and in bindingAttr that are declared or inherited by the current TypeDelegator.

C# Syntax:


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

Parameters:

name

The nested type's name.

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: A Type object representing the nested 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 nested types specified in bindingAttr that are declared or inherited by the current TypeDelegator.

C# Syntax:


            public override Type[] GetNestedTypes(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of type Type containing the nested types.

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 an array of PropertyInfo objects representing properties defined on this TypeDelegator.

C# Syntax:


            public override PropertyInfo[] GetProperties(
   BindingFlags bindingAttr
);

Parameters:

bindingAttr

A bitmask that affects the way in which the search is conducted. The value is a combination of zero or more bit flags from BindingFlags.

Return Value:: An array of PropertyInfo objects representing properties defined on this TypeDelegator.

Implements:: IReflect.GetProperties

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.