System.Type.InvokeMember Method

When overridden in a derived class, invokes the specified member, using the specified binding constraints and matching the specified argument list, modifiers and culture.


public abstract object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)


The string containing the name of the constructor, method, property, or field member to invoke.
A bitmask comprised of one or more System.Reflection.BindingFlags that specify how the search is conducted. The access can be one of the BindingFlags such as Public, NonPublic, Private, InvokeMethod, GetField, and so on. The type of lookup need not be specified. If the type of lookup is omitted, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static are used.
An 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.
The object on which to invoke the specified member.
An array containing the arguments to pass to the member to invoke.
An array of System.Reflection.ParameterModifier objects representing the attributes associated with the corresponding element in the args array. A parameter's associated attributes are stored in the member's signature.
The System.Globalization.CultureInfo object representing the globalization locale to use, which may be necessary for locale-specific conversions, such as converting a numeric String to a Double.
An array containing the names of the parameters to which the values in the args array are passed.


An object representing the return value of the invoked member.


ArgumentNullException name is null.

args has more than one dimension.


invokeAttr is not a valid System.Reflection.BindingFlags value.


The member to be invoked is a constructor and System.Reflection.BindingFlags.CreateInstance is not specified in invokeAttr.


The member to be invoked is a method that is not a type initializer or instance constructor, and System.Reflection.BindingFlags.InvokeMethod is not specified in invokeAttr.


The member to be accessed is a field, and neither System.Reflection.BindingFlags.GetField nor System.Reflection.BindingFlags.SetField is specified in invokeAttr.


The member to be accessed is a property, and neither System.Reflection.BindingFlags.GetProperty nor System.Reflection.BindingFlags.SetProperty is specified in invokeAttr.


invokeAttr contains System.Reflection.BindingFlags.CreateInstance and at least one of System.Reflection.BindingFlags.InvokeMethod, System.Reflection.BindingFlags.GetField, System.Reflection.BindingFlags.SetField, System.Reflection.BindingFlags.GetProperty, or System.Reflection.BindingFlags.SetProperty.


invokeAttr contains both System.Reflection.BindingFlags.GetField and System.Reflection.BindingFlags.SetField.


invokeAttr contains both System.Reflection.BindingFlags.GetProperty and System.Reflection.BindingFlags.SetProperty.


invokeAttr contains System.Reflection.BindingFlags.InvokeMethod and at least one of System.Reflection.BindingFlags.SetField or System.Reflection.BindingFlags.SetProperty.


invokeAttr contains System.Reflection.BindingFlags.SetField and args has more than one element.


namedParameters.Length > args.Length .


At least one element in namedParameters is null.


At least one element in args is not assignment-compatible with the corresponding parameter in namedParameters.

MissingFieldExceptionA field or property matching the specified criteria was not found.

A method matching the specified criteria cannot be found.


The current instance object represents a type that contains open type parameters (that is,





MethodAccessExceptionThe requested member is non-public and the caller does not have the required permission.
System.Reflection.TargetExceptionThe member matching the specified criteria cannot be invoked on target.
System.Reflection.TargetInvocationExceptionThe member matching the specified criteria threw an exception.
System.Reflection.AmbiguousMatchExceptionMore than one member matches the specified criteria.


InvokeMember calls a constructor member or a method member, gets or sets a property member, gets or sets a data field member, or gets or sets an element of an array member.


You cannot use Type.InvokeMember(string, System.Reflection.BindingFlags, System.Reflection.Binder, object, Object[]) to invoke a generic method.

When you invoke an IDispatch member you can specify the DispID instead of the member name, using the string format "[DispID=##]". For example, if the DispID of MyComMethod is 3, you can specify the string "[DispID=3]" instead of "MyComMethod". Invoking a member by DispID is faster than looking up the member by name. In complex aggregation scenarios, the DispID is sometimes the only way to invoke the desired member.

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

Each parameter in the namedParameters array gets the value in the corresponding element in the args array. If the length of args is greater than the length of namedParameters, the remaining argument values are passed in order.

The namedParameters array can be used to change the order of arguments in an input array. For example, given the method M(string a, int b) (M(ByVal a As String, ByVal b As Integer) in Visual Basic) and the input array { 42, "x" }, the input array can be passed unchanged to args if the array { "b", "a" } is supplied for namedParameters.

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

  • Specify BindingFlags.Public to include public members in the search.

  • Specify BindingFlags.NonPublic to include non-public members (that is, private, internal, and protected members) in the search.

  • Specify BindingFlags.FlattenHierarchy to include static members up the hierarchy.

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

  • BindingFlags.IgnoreCase to ignore the case of name.

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

The following System.Reflection.BindingFlags invocation flags can be used to denote what action to take with the member:

  • CreateInstance to invoke a constructor. name is ignored. Not valid with other invocation flags.

  • InvokeMethod to invoke a method, but not a constructor or a type initializer. Not valid with SetField or SetProperty. If InvokeMethod is specified by itself, BindingFlags.Public, BindingFlags.Instance, and BindingFlags.Static are automatically included.

  • GetField to get the value of a field. Not valid with SetField.

  • SetField to set the value of a field. Not valid with GetField.

  • GetProperty to get a property. Not valid with SetProperty.

  • SetProperty to set a property. Not valid with GetProperty.

See System.Reflection.BindingFlags for more information.

A method will be invoked if both of the following conditions are true:

  • The number of parameters in the method declaration equals the number of arguments in the args array (unless default arguments are defined on the member and BindingFlags.OptionalParamBinding is specified).

  • The type of each argument can be converted by the binder to the type of the parameter.

The binder will find all of the matching methods. These methods are found based upon the type of binding requested (System.Reflection.BindingFlags values InvokeMethod, GetProperty, and so on). The set of methods is filtered by the name, number of arguments, and a set of search modifiers defined in the binder.

After the method is selected, it is invoked. Accessibility is checked at that point. The search may control which set of methods are searched based upon the accessibility attribute associated with the method. The System.Reflection.Binder.BindToMethod(System.Reflection.BindingFlags, System.Reflection.MethodBase[], Object[]@, System.Reflection.ParameterModifier[], System.Globalization.CultureInfo, String[], Object@) method of the System.Reflection.Binder class is responsible for selecting the method to be invoked. The default binder selects the most specific match.

InvokeMember can be used to invoke methods with parameters that have default values. To bind to these methods, Reflection requires System.Reflection.BindingFlags.OptionalParamBinding to be specified. For a parameter that has a default value, you can either supply a different value, or supply System.Reflection.Missing.Value to use the default value.

For example, consider a method such as MyMethod(int x, float y = 2.0). To invoke this method with only the first argument as MyMethod(4), pass one of the above binding flags and pass two arguments, namely, 4 for the first argument and Missing.Value for the second argument. Unless you use Missing.Value, you may not omit optional parameters with the Invoke method. If you must do so, use InvokeMember instead.

Access restrictions are ignored for fully trusted code; that is, private constructors, methods, fields, and properties can be accessed and invoked through System.Reflection whenever the code is fully trusted.

You can use Type.InvokeMember to set a field to a particular value by specifying System.Reflection.BindingFlags.SetField. For example, if you want to set a public instance field named F on class C, and F is a String, you can use code such as:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {"strings new value"}, null, null, null);

If F is a String[], you can use code such as:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {new String[]{"a","z","c","d"}}, null, null, null);

which will initialize the field F to this new array. You can also use Type.InvokeMember to set a position in an array by supplying the index of the value and then the next value by using code such as the following:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {1, "b"}, null, null, null);

This will change string "z" in the array that F holds to string "b".


Starting with the net_v20sp1_long, this method can be used to access non-public members if the caller has been granted System.Security.Permissions.ReflectionPermission with the System.Security.Permissions.ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public members is restricted to the caller’s grant set, or a subset thereof. (See Security Considerations for Reflection.)

To use this functionality, your application should target the net_v35_long or later.


System.Security.Permissions.ReflectionPermissionRequires permission to retrieve information on non-public members of types in loaded assemblies. See System.Security.Permissions.ReflectionPermissionFlag.TypeInformation.


The following example demonstrates the use of Type.InvokeMember(string, System.Reflection.BindingFlags, System.Reflection.Binder, object, Object[], System.Reflection.ParameterModifier[], System.Globalization.CultureInfo, String[]) to construct a string, obtain its string.Length property, invoke string.Insert(int, string) on it, and then set its value using the string.Empty field.

C# Example

using System;
using System.Reflection;

class InvokeMemberExample
   static void Main(string[] args)
      // Create the parameter arrays that will
      // be passed to InvokeMember.
      char[] cAry = 
      new char[] {'A',' ','s','t','r','i','n','g'};
      object[] oAry = new object[] {cAry, 0, cAry.Length};

      Type t = typeof(string);

      // Invoke the constructor of a string.
      string str =
         (string)t.InvokeMember(null, BindingFlags.Instance |
         BindingFlags.Public | BindingFlags.CreateInstance, null,
         null, oAry, null, null, null);
      Console.WriteLine("The string is \"{0}\".", str);

      // Access a property of the string.
      int i =
         (int) t.InvokeMember("Length", BindingFlags.Instance |
         BindingFlags.Public | BindingFlags.GetProperty, null, 
         str, null, null, null, null);
      Console.WriteLine("The length of the string is {0}.", i);

      // Invoke a method on the string.
      string newStr = "new ";
      object[] oAry2 = new Object[] {2, newStr};
      str = (string) t.InvokeMember("Insert", BindingFlags.Instance |
         BindingFlags.Public | BindingFlags.InvokeMethod, null, str, 
         oAry2, null, null, null);
      Console.WriteLine("The modified string is \"{0}\".", str);

      // Access a field of the string.
      str = (string) t.InvokeMember("Empty", BindingFlags.Static | 
         BindingFlags.Public | BindingFlags.GetField, null, str, 
      Console.WriteLine("The empty string is \"{0}\".", str);

The output is

The string is "A string".
The length of the string is 8.
The modified string is "A new string"
The empty string is "".


Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Assembly Versions: 1.0.5000.0,,