Share via


MethodBase.Invoke Method (Object, BindingFlags, Binder, array<Object[], CultureInfo)

Microsoft Silverlight will reach end of support after October 2021. Learn more.

When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

Namespace:  System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public MustOverride Function Invoke ( _
    obj As Object, _
    invokeAttr As BindingFlags, _
    binder As Binder, _
    parameters As Object(), _
    culture As CultureInfo _
) As Object
public abstract Object Invoke(
    Object obj,
    BindingFlags invokeAttr,
    Binder binder,
    Object[] parameters,
    CultureInfo culture
)

Parameters

  • obj
    Type: System.Object
    The object on which to invoke the method or constructor. If a method is static, this argument is ignored. If a constructor is static, this argument must be nulla null reference (Nothing in Visual Basic) or an instance of the class that defines the constructor.
  • invokeAttr
    Type: System.Reflection.BindingFlags
    A bitmask that is a combination of 0 or more bit flags from BindingFlags. If binder is nulla null reference (Nothing in Visual Basic), this parameter is assigned the value Default; thus, whatever you pass in is ignored.
  • binder
    Type: System.Reflection.Binder
    An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects via reflection. If binder is nulla null reference (Nothing in Visual Basic), the default binder is used.
  • parameters
    Type: array<System.Object[]
    An argument list for the invoked method or constructor. This is an array of objects with the same number, order, and type as the parameters of the method or constructor to be invoked. If there are no parameters, this should be nulla null reference (Nothing in Visual Basic).
    If the method or constructor represented by this instance takes a ByRef parameter, there is no special attribute required for that parameter in order to invoke the method or constructor using this function. Any object in this array that is not explicitly initialized with a value will contain the default value for that object type. For reference-type elements, this value is nulla null reference (Nothing in Visual Basic). For value-type elements, this value is 0, 0.0, or false, depending on the specific element type.
  • culture
    Type: System.Globalization.CultureInfo
    Culture information that governs the coercion of types. If this is nulla null reference (Nothing in Visual Basic), the CultureInfo for the current thread is used. (This is necessary, for example, to convert a String that represents 1000 to a Double value, because 1000 is represented differently by different cultures.)

Return Value

Type: System.Object
The return value of the invoked method, or nulla null reference (Nothing in Visual Basic) in the case of a constructor, or nulla null reference (Nothing in Visual Basic) if the method's return type is void.

Caution noteCaution:

Elements of the parameters array that represent parameters declared with the ref or out keywords may also be modified.

Exceptions

Exception Condition
TargetException

The obj parameter is nulla null reference (Nothing in Visual Basic) and the method is not static.

-or-

The method is not declared or inherited by the class of obj.

-or-

A static constructor is invoked, and obj is neither nulla null reference (Nothing in Visual Basic) nor an instance of the class that declared the constructor.

ArgumentException

The type of the parameters parameter does not match the signature of the method or constructor reflected by this instance.

TargetParameterCountException

The parameters array does not have the correct number of arguments.

TargetInvocationException

The invoked method or constructor throws an exception.

MethodAccessException

The method or constructor is not accessible.

InvalidOperationException

The type that declares the method is an open generic type. That is, the Type.ContainsGenericParameters property returns true for the declaring type.

Remarks

In Silverlight, only accessible methods can be invoked using reflection.

Invoke(Object, BindingFlags, Binder, array<Object[], CultureInfo) dynamically invokes the method reflected by this instance on obj, and passes along the specified parameters. If the method is static, the obj parameter is ignored. For non-static methods, obj should be an instance of a class that inherits or declares the method and must be the same type as this class. If the method has no parameters, the value of parameters should be nulla null reference (Nothing in Visual Basic). Otherwise, the number, type, and order of elements in parameters should be identical to the number, type, and order of parameters for the method reflected by this instance.

You may not omit optional parameters in calls to Invoke. To invoke a method omitting optional parameters, you should call InvokeMember instead.

NoteNote:

If this method overload is used to invoke an instance constructor, the object supplied for obj is reinitialized; that is, all instance initializers are executed. The return value is nulla null reference (Nothing in Visual Basic). If a class constructor is invoked, the class is reinitialized; that is, all class initializers are executed. The return value is nulla null reference (Nothing in Visual Basic).

For pass-by-value primitive parameters, normal widening (for example, Int16 to Int32) is performed. For pass-by-value reference parameters, normal reference widening (derived class to base class, and base class to interface type) is allowed. However, for pass-by-reference primitive parameters, the types must match exactly. For pass-by-reference reference parameters, the normal widening still applies.

For example, if the method reflected by this instance is declared as public boolean Compare(String a, String b), then parameters should be an array of Objects with length 2 such that parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").

If a parameter of the current method is a value type, and the corresponding argument in parameters is nulla null reference (Nothing in Visual Basic), the runtime passes a zero-initialized instance of the value type.

Reflection uses dynamic method lookup when invoking virtual methods. For example, suppose that class B inherits from class A and both implement a virtual method named M. Now suppose that you have a MethodInfo object that represents M on class A. If you use the Invoke method to invoke M on an object of type B, reflection will use the implementation given by class B. Even if the object of type B is cast to A, the implementation given by class B is used (see the code example in the next section).

On the other hand, if the method is non-virtual, reflection will use the implementation given by the type from which the MethodInfo was obtained, regardless of the type of the object passed as the target.

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

If the invoked method throws an exception, TargetInvocationException.GetException returns the exception. This implementation throws a NotSupportedException.

Examples

The following example demonstrates all members of the System.Reflection.Binder class using an overload of Type.InvokeMember. The private method CanConvertFrom finds compatible types for a given type. For another example of invoking members in a custom binding scenario, see Dynamically Loading and Using Types.

Imports System.Reflection
Imports System.Globalization
Imports System.Threading

Public Class MyBinder
   Inherits Binder
   Public Sub New()
      MyBase.new()
   End Sub 
   Private Class BinderState
      Public args() As Object
   End Class 

   Public Overrides Function BindToField(ByVal bindingAttr As BindingFlags, ByVal match() As FieldInfo, ByVal value As Object, ByVal culture As CultureInfo) As FieldInfo
      If match Is Nothing Then
         Throw New ArgumentNullException("match")
      End If
      ' Get a field for which the value parameter can be converted to the specified field type.
      Dim i As Integer
      For i = 0 To match.Length - 1
         If Not (ChangeType(value, match(i).FieldType, culture) Is Nothing) Then
            Return match(i)
         End If
      Next i
      Return Nothing
   End Function 

   Public Overrides Function BindToMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByRef args() As Object, ByVal modifiers() As ParameterModifier, ByVal culture As CultureInfo, ByVal names() As String, ByRef state As Object) As MethodBase
      ' Store the arguments to the method in a state object.
      Dim myBinderState As New BinderState()
      Dim arguments() As Object = New [Object](args.Length) {}
      args.CopyTo(arguments, 0)
      myBinderState.args = arguments
      state = myBinderState

      If match Is Nothing Then
         Throw New ArgumentNullException()
      End If
      ' Find a method that has the same parameters as those of args.
      Dim i As Integer
      For i = 0 To match.Length - 1
         ' Count the number of parameters that match.
         Dim count As Integer = 0
         Dim parameters As ParameterInfo() = match(i).GetParameters()
         ' Go on to the next method if the number of parameters do not match.
         If args.Length <> parameters.Length Then
            GoTo ContinueFori
         End If
         ' Match each of the parameters that the user expects the method to have.
         Dim j As Integer
         For j = 0 To args.Length - 1
            ' If names is not null, then reorder args.
            If Not (names Is Nothing) Then
               If names.Length <> args.Length Then
                  Throw New ArgumentException("names and args must have the same number of elements.")
               End If
               Dim k As Integer
               For k = 0 To names.Length - 1
                  If String.Compare(parameters(j).Name, names(k).ToString()) = 0 Then
                     args(j) = myBinderState.args(k)
                  End If
               Next k
            End If 
            ' Determine whether the types specified by the user can be converted to parameter type.
            If Not (ChangeType(args(j), parameters(j).ParameterType, culture) Is Nothing) Then
               count += 1
            Else
               Exit For
            End If
         Next j
         ' Determine whether the method has been found.
         If count = args.Length Then
            Return match(i)
         End If
ContinueFori:
      Next i
      Return Nothing
   End Function 

   Public Overrides Function ChangeType(ByVal value As Object, ByVal myChangeType As Type, ByVal culture As CultureInfo) As Object
      ' Determine whether the value parameter can be converted to a value of type myType.
      If CanConvertFrom(value.GetType(), myChangeType) Then
         ' Return the converted object.
         Return Convert.ChangeType(value, myChangeType, culture)
      Else
         ' Return null.
         Return Nothing
      End If
   End Function 'ChangeType

   Public Overrides Sub ReorderArgumentArray(ByRef args() As Object, ByVal state As Object)
      'Redimension the array to hold the state values.
      ReDim args(CType(state, BinderState).args.Length)
      ' Return the args that had been reordered by BindToMethod.
      CType(state, BinderState).args.CopyTo(args, 0)
   End Sub 

   Public Overrides Function SelectMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByVal types() As Type, ByVal modifiers() As ParameterModifier) As MethodBase
      If match Is Nothing Then
         Throw New ArgumentNullException("match")
      End If
      Dim i As Integer
      For i = 0 To match.Length - 1
         ' Count the number of parameters that match.
         Dim count As Integer = 0
         Dim parameters As ParameterInfo() = match(i).GetParameters()
         ' Go on to the next method if the number of parameters do not match.
         If types.Length <> parameters.Length Then
            GoTo ContinueFori
         End If
         ' Match each of the parameters that the user expects the method to have.
         Dim j As Integer
         For j = 0 To types.Length - 1
            ' Determine whether the types specified by the user can be converted to parameter type.
            If CanConvertFrom(types(j), parameters(j).ParameterType) Then
               count += 1
            Else
               Exit For
            End If
         Next j ' Determine whether the method has been found.
         If count = types.Length Then
            Return match(i)
         End If
ContinueFori:
      Next i
      Return Nothing
   End Function 

   Public Overrides Function SelectProperty(ByVal bindingAttr As BindingFlags, ByVal match() As PropertyInfo, ByVal returnType As Type, ByVal indexes() As Type, ByVal modifiers() As ParameterModifier) As PropertyInfo
      If match Is Nothing Then
         Throw New ArgumentNullException("match")
      End If
      Dim i As Integer
      For i = 0 To match.Length - 1
         ' Count the number of indexes that match.
         Dim count As Integer = 0
         Dim parameters As ParameterInfo() = match(i).GetIndexParameters()

         ' Go on to the next property if the number of indexes do not match.
         If indexes.Length <> parameters.Length Then
            GoTo ContinueFori
         End If
         ' Match each of the indexes that the user expects the property to have.
         Dim j As Integer
         For j = 0 To indexes.Length - 1
            ' Determine whether the types specified by the user can be converted to index type.
            If CanConvertFrom(indexes(j), parameters(j).ParameterType) Then
               count += 1
            Else
               Exit For
            End If
         Next j ' Determine whether the property has been found.
         If count = indexes.Length Then
            ' Determine whether the return type can be converted to the properties type.
            If CanConvertFrom(returnType, match(i).PropertyType) Then
               Return match(i)
            Else
               GoTo ContinueFori
            End If
         End If
ContinueFori:
      Next i
      Return Nothing
   End Function 

   ' Determine whether type1 can be converted to type2. Check only for primitive types.
   Private Function CanConvertFrom(ByVal type1 As Type, ByVal type2 As Type) As Boolean
      If type1.IsPrimitive And type2.IsPrimitive Then
         Dim typeCode1 As TypeCode = Type.GetTypeCode(type1)
         Dim typeCode2 As TypeCode = Type.GetTypeCode(type2)
         ' If both type1 and type2 have same type, return true.
         If typeCode1 = typeCode2 Then
            Return True
         End If ' Possible conversions from Char follow.
         If typeCode1 = TypeCode.Char Then
            Select Case typeCode2
               Case TypeCode.UInt16
                  Return True
               Case TypeCode.UInt32
                  Return True
               Case TypeCode.Int32
                  Return True
               Case TypeCode.UInt64
                  Return True
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from Byte follow.
         If typeCode1 = TypeCode.Byte Then
            Select Case typeCode2
               Case TypeCode.Char
                  Return True
               Case TypeCode.UInt16
                  Return True
               Case TypeCode.Int16
                  Return True
               Case TypeCode.UInt32
                  Return True
               Case TypeCode.Int32
                  Return True
               Case TypeCode.UInt64
                  Return True
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from SByte follow.
         If typeCode1 = TypeCode.SByte Then
            Select Case typeCode2
               Case TypeCode.Int16
                  Return True
               Case TypeCode.Int32
                  Return True
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from UInt16 follow.
         If typeCode1 = TypeCode.UInt16 Then
            Select Case typeCode2
               Case TypeCode.UInt32
                  Return True
               Case TypeCode.Int32
                  Return True
               Case TypeCode.UInt64
                  Return True
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from Int16 follow.
         If typeCode1 = TypeCode.Int16 Then
            Select Case typeCode2
               Case TypeCode.Int32
                  Return True
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from UInt32 follow.
         If typeCode1 = TypeCode.UInt32 Then
            Select Case typeCode2
               Case TypeCode.UInt64
                  Return True
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from Int32 follow.
         If typeCode1 = TypeCode.Int32 Then
            Select Case typeCode2
               Case TypeCode.Int64
                  Return True
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from UInt64 follow.
         If typeCode1 = TypeCode.UInt64 Then
            Select Case typeCode2
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from Int64 follow.
         If typeCode1 = TypeCode.Int64 Then
            Select Case typeCode2
               Case TypeCode.Single
                  Return True
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If ' Possible conversions from Single follow.
         If typeCode1 = TypeCode.Single Then
            Select Case typeCode2
               Case TypeCode.Double
                  Return True
               Case Else
                  Return False
            End Select
         End If
      End If
      Return False
   End Function 
End Class 


Public Class Example
   Public myFieldB As Short
   Public myFieldA As Integer
   Private Shared outputBlock As System.Windows.Controls.TextBlock

   Public Overloads Sub MyMethod(ByVal i As Long, ByVal k As Char)
      outputBlock.Text += String.Format("This is MyMethod(Long i, Char k).") & vbCrLf
   End Sub 

   Public Overloads Sub MyMethod(ByVal i As Long, ByVal j As Long)
      outputBlock.Text += String.Format("This is MyMethod(Long i, Long j).") & vbCrLf
   End Sub 

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      Example.outputBlock = outputBlock

      ' Get the type of Example.
      Dim myType As Type = GetType(Example)

      ' Get the instance of Example.
      Dim myInstance As Object = New Example()

      outputBlock.Text &= "Displaying the results of using the MyBinder binder." & vbCrLf

      ' Get the method information for MyMethod.
      Dim myMethod As MethodInfo = _
         myType.GetMethod("MyMethod", _
                          BindingFlags.Public Or BindingFlags.Instance, _
                          New MyBinder(), _
                          New Type() {GetType(Short), GetType(Short)}, _
                          Nothing)
      outputBlock.Text &= myMethod.ToString() & vbCrLf

      ' Invoke MyMethod using an instance of MyBinder.
      myType.InvokeMember("MyMethod", _
                          BindingFlags.InvokeMethod, _
                          New MyBinder(), _
                          myInstance, _
                          New Object() {CInt(32), CInt(32)})
   End Sub 
End Class 

' This code produces the following output:
'
'Displaying the results of using the MyBinder binder.
'Void MyMethod(Int64, Int64)
'This is MyMethod(Long i, Long j).
using System;
using System.Reflection;
using System.Globalization;

public class MyBinder : Binder
{
   public MyBinder()
      : base()
   {
   }

   private class BinderState
   {
      public object[] args;
   }

   public override FieldInfo BindToField(
       BindingFlags bindingAttr,
       FieldInfo[] match,
       object value,
       CultureInfo culture
       )
   {
      if (match == null)
         throw new ArgumentNullException("match");
      // Get a field for which the value parameter can be converted to the specified field type.
      for (int i = 0; i < match.Length; i++)
         if (ChangeType(value, match[i].FieldType, culture) != null)
            return match[i];
      return null;
   }

   public override MethodBase BindToMethod(
       BindingFlags bindingAttr,
       MethodBase[] match,
       ref object[] args,
       ParameterModifier[] modifiers,
       CultureInfo culture,
       string[] names,
       out object state
       )
   {
      // Store the arguments to the method in a state object.
      BinderState myBinderState = new BinderState();
      object[] arguments = new Object[args.Length];
      args.CopyTo(arguments, 0);
      myBinderState.args = arguments;
      state = myBinderState;
      if (match == null)
         throw new ArgumentNullException();
      // Find a method that has the same parameters as those of the args parameter.
      for (int i = 0; i < match.Length; i++)
      {
         // Count the number of parameters that match.
         int count = 0;
         ParameterInfo[] parameters = match[i].GetParameters();
         // Go on to the next method if the number of parameters do not match.
         if (args.Length != parameters.Length)
            continue;
         // Match each of the parameters that the user expects the method to have.
         for (int j = 0; j < args.Length; j++)
         {
            // If the names parameter is not null, then reorder args.
            if (names != null)
            {
               if (names.Length != args.Length)
                  throw new ArgumentException("names and args must have the same number of elements.");
               for (int k = 0; k < names.Length; k++)
                  if (String.Compare(parameters[j].Name, names[k].ToString()) == 0)
                     args[j] = myBinderState.args[k];
            }
            // Determine whether the types specified by the user can be converted to the parameter type.
            if (ChangeType(args[j], parameters[j].ParameterType, culture) != null)
               count += 1;
            else
               break;
         }
         // Determine whether the method has been found.
         if (count == args.Length)
            return match[i];
      }
      return null;
   }

   public override object ChangeType(
       object value,
       Type myChangeType,
       CultureInfo culture
       )
   {
      // Determine whether the value parameter can be converted to a value of type myType.
      if (CanConvertFrom(value.GetType(), myChangeType))
         // Return the converted object.
         return Convert.ChangeType(value, myChangeType, culture);
      else
         // Return null.
         return null;
   }

   public override void ReorderArgumentArray(
       ref object[] args,
       object state
       )
   {
      // Return the args that had been reordered by BindToMethod.
      ((BinderState)state).args.CopyTo(args, 0);
   }

   public override MethodBase SelectMethod(
       BindingFlags bindingAttr,
       MethodBase[] match,
       Type[] types,
       ParameterModifier[] modifiers
       )
   {
      if (match == null)
         throw new ArgumentNullException("match");
      for (int i = 0; i < match.Length; i++)
      {
         // Count the number of parameters that match.
         int count = 0;
         ParameterInfo[] parameters = match[i].GetParameters();
         // Go on to the next method if the number of parameters do not match.
         if (types.Length != parameters.Length)
            continue;
         // Match each of the parameters that the user expects the method to have.
         for (int j = 0; j < types.Length; j++)
            // Determine whether the types specified by the user can be converted to parameter type.
            if (CanConvertFrom(types[j], parameters[j].ParameterType))
               count += 1;
            else
               break;
         // Determine whether the method has been found.
         if (count == types.Length)
            return match[i];
      }
      return null;
   }

   public override PropertyInfo SelectProperty(
       BindingFlags bindingAttr,
       PropertyInfo[] match,
       Type returnType,
       Type[] indexes,
       ParameterModifier[] modifiers
       )
   {
      if (match == null)
         throw new ArgumentNullException("match");
      for (int i = 0; i < match.Length; i++)
      {
         // Count the number of indexes that match.
         int count = 0;
         ParameterInfo[] parameters = match[i].GetIndexParameters();
         // Go on to the next property if the number of indexes do not match.
         if (indexes.Length != parameters.Length)
            continue;
         // Match each of the indexes that the user expects the property to have.
         for (int j = 0; j < indexes.Length; j++)
            // Determine whether the types specified by the user can be converted to index type.
            if (CanConvertFrom(indexes[j], parameters[j].ParameterType))
               count += 1;
            else
               break;
         // Determine whether the property has been found.
         if (count == indexes.Length)
            // Determine whether the return type can be converted to the properties type.
            if (CanConvertFrom(returnType, match[i].PropertyType))
               return match[i];
            else
               continue;
      }
      return null;
   }

   // Determines whether type1 can be converted to type2. Check only for primitive types.
   private bool CanConvertFrom(Type type1, Type type2)
   {
      if (type1.IsPrimitive && type2.IsPrimitive)
      {
         TypeCode typeCode1 = Type.GetTypeCode(type1);
         TypeCode typeCode2 = Type.GetTypeCode(type2);
         // If both type1 and type2 have the same type, return true.
         if (typeCode1 == typeCode2)
            return true;
         // Possible conversions from Char follow.
         if (typeCode1 == TypeCode.Char)
            switch (typeCode2)
            {
               case TypeCode.UInt16: return true;
               case TypeCode.UInt32: return true;
               case TypeCode.Int32: return true;
               case TypeCode.UInt64: return true;
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from Byte follow.
         if (typeCode1 == TypeCode.Byte)
            switch (typeCode2)
            {
               case TypeCode.Char: return true;
               case TypeCode.UInt16: return true;
               case TypeCode.Int16: return true;
               case TypeCode.UInt32: return true;
               case TypeCode.Int32: return true;
               case TypeCode.UInt64: return true;
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from SByte follow.
         if (typeCode1 == TypeCode.SByte)
            switch (typeCode2)
            {
               case TypeCode.Int16: return true;
               case TypeCode.Int32: return true;
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from UInt16 follow.
         if (typeCode1 == TypeCode.UInt16)
            switch (typeCode2)
            {
               case TypeCode.UInt32: return true;
               case TypeCode.Int32: return true;
               case TypeCode.UInt64: return true;
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from Int16 follow.
         if (typeCode1 == TypeCode.Int16)
            switch (typeCode2)
            {
               case TypeCode.Int32: return true;
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from UInt32 follow.
         if (typeCode1 == TypeCode.UInt32)
            switch (typeCode2)
            {
               case TypeCode.UInt64: return true;
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from Int32 follow.
         if (typeCode1 == TypeCode.Int32)
            switch (typeCode2)
            {
               case TypeCode.Int64: return true;
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from UInt64 follow.
         if (typeCode1 == TypeCode.UInt64)
            switch (typeCode2)
            {
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from Int64 follow.
         if (typeCode1 == TypeCode.Int64)
            switch (typeCode2)
            {
               case TypeCode.Single: return true;
               case TypeCode.Double: return true;
               default: return false;
            }
         // Possible conversions from Single follow.
         if (typeCode1 == TypeCode.Single)
            switch (typeCode2)
            {
               case TypeCode.Double: return true;
               default: return false;
            }
      }
      return false;
   }
}
public class Example
{
   public short myFieldB;
   public int myFieldA;
   private static System.Windows.Controls.TextBlock outputBlock;

   public void MyMethod(long i, char k)
   {
      outputBlock.Text += String.Format("This is MyMethod(long i, char k)\n");
   }
   public void MyMethod(long i, long j)
   {
      outputBlock.Text += String.Format("This is MyMethod(long i, long j)\n");
   }

   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      Example.outputBlock = outputBlock;

      // Get the type of Example.
      Type myType = typeof(Example);

      // Get the instance of Example.
      object myInstance = new Example();

      outputBlock.Text += "Displaying the results of using the MyBinder binder.\n";

      // Get the method information for MyMethod.
      MethodInfo myMethod = 
         myType.GetMethod("MyMethod", 
                          BindingFlags.Public | BindingFlags.Instance,
                          new MyBinder(), 
                          new Type[] { typeof(short), typeof(short) }, 
                          null);
      outputBlock.Text += myMethod.ToString() + "\n";

      // Invoke MyMethod.
      myType.InvokeMember("MyMethod", 
                          BindingFlags.InvokeMethod, 
                          new MyBinder(), 
                          myInstance, 
                          new Object[] { (int)32, (int)32 });
   }
}

/* This code produces the following output:

Displaying the results of using the MyBinder binder.
Void MyMethod(Int64, Int64)
This is MyMethod(long i, long j).
 */

Version Information

Silverlight

Supported in: 5, 4, 3

Silverlight for Windows Phone

Supported in: Windows Phone OS 7.1, Windows Phone OS 7.0

XNA Framework

Supported in: Xbox 360, Windows Phone OS 7.0

Platforms

For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.