Binder 클래스
정의
중요
일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.
후보 목록에서 멤버를 선택한 다음 실제 인수 형식에서 형식 인수 형식으로 형식 변환을 수행합니다.
public ref class Binder abstractpublic abstract class Binder[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public abstract class Binder[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Bindertype Binder = class[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Binder = class[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Binder = classPublic MustInherit Class Binder- 상속
-
Binder
- 특성
예제
다음 예제에서는 구현 하 고 클래스의 모든 멤버를 보여 줍니다 Binder . 프라이빗 메서드 CanConvertFrom 는 지정된 형식에 대해 호환되는 형식을 찾습니다.
using namespace System;
using namespace System::Reflection;
using namespace System::Globalization;
using namespace System::Runtime::InteropServices;
public ref class MyBinder: public Binder
{
public:
MyBinder()
: Binder()
{}
private:
ref class BinderState
{
public:
array<Object^>^args;
};
public:
virtual FieldInfo^ BindToField( BindingFlags bindingAttr, array<FieldInfo^>^match, Object^ value, CultureInfo^ culture ) override
{
if ( match == nullptr )
throw gcnew 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 ) != nullptr )
return match[ i ];
return nullptr;
}
virtual MethodBase^ BindToMethod( BindingFlags bindingAttr, array<MethodBase^>^match, array<Object^>^%args, array<ParameterModifier>^ modifiers, CultureInfo^ culture, array<String^>^names, [Out]Object^% state ) override
{
// Store the arguments to the method in a state Object*.
BinderState^ myBinderState = gcnew BinderState;
array<Object^>^arguments = gcnew array<Object^>(args->Length);
args->CopyTo( arguments, 0 );
myBinderState->args = arguments;
state = myBinderState;
if ( match == nullptr )
throw gcnew 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;
array<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 0, then reorder args.
if ( names != nullptr )
{
if ( names->Length != args->Length )
throw gcnew 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 ] ) == 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 ) != nullptr )
count += 1;
else
break;
}
if ( count == args->Length )
return match[ i ];
}
return nullptr;
}
virtual Object^ ChangeType( Object^ value, Type^ myChangeType, CultureInfo^ culture ) override
{
// 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 );
else
return nullptr;
}
virtual void ReorderArgumentArray( array<Object^>^%args, Object^ state ) override
{
// Return the args that had been reordered by BindToMethod.
(safe_cast<BinderState^>(state))->args->CopyTo( args, 0 );
}
virtual MethodBase^ SelectMethod( BindingFlags bindingAttr, array<MethodBase^>^match, array<Type^>^types, array<ParameterModifier>^ modifiers ) override
{
if ( match == nullptr )
throw gcnew ArgumentNullException( "match" );
for ( int i = 0; i < match->Length; i++ )
{
// Count the number of parameters that match.
int count = 0;
array<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 nullptr;
}
virtual PropertyInfo^ SelectProperty( BindingFlags bindingAttr, array<PropertyInfo^>^match, Type^ returnType, array<Type^>^indexes, array<ParameterModifier>^ modifiers ) override
{
if ( match == nullptr )
throw gcnew ArgumentNullException( "match" );
for ( int i = 0; i < match->Length; i++ )
{
// Count the number of indexes that match.
int count = 0;
array<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 nullptr;
}
private:
// Determines whether type1 can be converted to type2. Check only for primitive types.
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 ref class MyClass1
{
public:
short myFieldB;
int myFieldA;
void MyMethod( long i, char k )
{
Console::WriteLine( "\nThis is MyMethod(long i, char k)" );
}
void MyMethod( long i, long j )
{
Console::WriteLine( "\nThis is MyMethod(long i, long j)" );
}
};
int main()
{
// Get the type of MyClass1.
Type^ myType = MyClass1::typeid;
// Get the instance of MyClass1.
MyClass1^ myInstance = gcnew MyClass1;
Console::WriteLine( "\nDisplaying the results of using the MyBinder binder.\n" );
// Get the method information for MyMethod.
array<Type^>^types = {short::typeid,short::typeid};
MethodInfo^ myMethod = myType->GetMethod( "MyMethod", static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance), gcnew MyBinder, types, nullptr );
Console::WriteLine( myMethod );
// Invoke MyMethod.
array<Object^>^obj = {32,32};
myMethod->Invoke( myInstance, BindingFlags::InvokeMethod, gcnew MyBinder, obj, CultureInfo::CurrentCulture );
}
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);
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 MyClass1
{
public short myFieldB;
public int myFieldA;
public void MyMethod(long i, char k)
{
Console.WriteLine("\nThis is MyMethod(long i, char k)");
}
public void MyMethod(long i, long j)
{
Console.WriteLine("\nThis is MyMethod(long i, long j)");
}
}
public class Binder_Example
{
public static void Main()
{
// Get the type of MyClass1.
Type myType = typeof(MyClass1);
// Get the instance of MyClass1.
MyClass1 myInstance = new MyClass1();
Console.WriteLine("\nDisplaying 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);
Console.WriteLine(myMethod);
// Invoke MyMethod.
myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, new MyBinder(), new Object[] {(int)32, (int)32}, CultureInfo.CurrentCulture);
}
}
Imports System.Reflection
Imports System.Globalization
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 'BindToField
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 'BindToMethod
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)
' Return null.
Else
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 'SelectMethod
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 'SelectProperty
' 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 'CanConvertFrom
End Class
Public Class MyClass1
Public myFieldB As Short
Public myFieldA As Integer
Public Overloads Sub MyMethod(ByVal i As Long, ByVal k As Char)
Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, char k).")
End Sub
Public Overloads Sub MyMethod(ByVal i As Long, ByVal j As Long)
Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, long j).")
End Sub
End Class
Public Class Binder_Example
Public Shared Sub Main()
' Get the type of MyClass1.
Dim myType As Type = GetType(MyClass1)
' Get the instance of MyClass1.
Dim myInstance As New MyClass1()
Console.WriteLine(ControlChars.Cr & "Displaying the results of using the MyBinder binder.")
Console.WriteLine()
' 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)
Console.WriteLine(MyMethod)
' Invoke MyMethod.
myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, New MyBinder(), New [Object]() {CInt(32), CInt(32)}, CultureInfo.CurrentCulture)
End Sub
End Class
설명
클래스의 Binder 구현은 매개 변수 형식 및 인수 값 Type.GetMethod집합에 따라 실행할 가능한 멤버 집합에서 선택하는 와 같은 Type.InvokeMember메서드에서 사용됩니다. 매개 변수 형식을 기반으로 메서드를 선택하는 등입니다.
클래스의 Binder 기본 구현은 속성에 Type.DefaultBinder 의해 제공됩니다.
구현자 참고
에서 Binder상속하는 경우 , SelectProperty(BindingFlags, PropertyInfo[], Type, Type[], ParameterModifier[])BindToField(BindingFlags, FieldInfo[], Object, CultureInfo)ReorderArgumentArray(Object[], Object)SelectMethod(BindingFlags, MethodBase[], Type[], ParameterModifier[])및 ChangeType(Object, Type, CultureInfo)멤버BindToMethod(BindingFlags, MethodBase[], Object[], ParameterModifier[], CultureInfo, String[], Object)를 재정의해야 합니다.
생성자
| Binder() |
Binder 클래스의 새 인스턴스를 초기화합니다. |
메서드
| BindToField(BindingFlags, FieldInfo[], Object, CultureInfo) |
지정된 기준을 기초로 필드 집합에서 필드를 선택합니다. |
| BindToMethod(BindingFlags, MethodBase[], Object[], ParameterModifier[], CultureInfo, String[], Object) |
제공된 인수를 기반으로 지정된 메서드 집합에서 호출할 메서드를 선택합니다. |
| ChangeType(Object, Type, CultureInfo) |
지정된 |
| Equals(Object) |
지정된 개체가 현재 개체와 같은지 확인합니다. (다음에서 상속됨 Object) |
| GetHashCode() |
기본 해시 함수로 작동합니다. (다음에서 상속됨 Object) |
| GetType() |
현재 인스턴스의 Type을 가져옵니다. (다음에서 상속됨 Object) |
| MemberwiseClone() |
현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object) |
| ReorderArgumentArray(Object[], Object) |
BindToMethod(BindingFlags, MethodBase[], Object[], ParameterModifier[], CultureInfo, String[], Object)에서 반환하면 |
| SelectMethod(BindingFlags, MethodBase[], Type[], ParameterModifier[]) |
인수 형식을 기초로 지정된 메서드 집합에서 메서드를 선택합니다. |
| SelectProperty(BindingFlags, PropertyInfo[], Type, Type[], ParameterModifier[]) |
지정된 기준을 기초로 속성 집합에서 속성을 선택합니다. |
| ToString() |
현재 개체를 나타내는 문자열을 반환합니다. (다음에서 상속됨 Object) |
적용 대상
GitHub에서 Microsoft와 공동 작업
이 콘텐츠의 원본은 GitHub에서 찾을 수 있으며, 여기서 문제와 끌어오기 요청을 만들고 검토할 수도 있습니다. 자세한 내용은 참여자 가이드를 참조하세요.
.NET