Binder Class

Selects a member from a list of candidates, and performs type conversion from actual argument type to formal argument type.

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).
 */

System.Reflection Namespace