MethodBase.Invoke Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Richiama il metodo o il costruttore ottenuto mediante reflection da questa istanza di MethodInfo.
Overload
| Invoke(Object, Object[]) |
Richiama il metodo o il costruttore rappresentato dall'istanza corrente usando i parametri specificati. |
| Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Quando viene sottoposto a override in una classe derivata, richiama il metodo o il costruttore ottenuto mediante reflection con i parametri specificati. |
Invoke(Object, Object[])
- Origine:
- MethodBase.cs
- Origine:
- MethodBase.cs
- Origine:
- MethodBase.cs
Richiama il metodo o il costruttore rappresentato dall'istanza corrente usando i parametri specificati.
public:
virtual System::Object ^ Invoke(System::Object ^ obj, cli::array <System::Object ^> ^ parameters);public:
System::Object ^ Invoke(System::Object ^ obj, cli::array <System::Object ^> ^ parameters);public virtual object Invoke (object obj, object[] parameters);public object? Invoke (object? obj, object?[]? parameters);public object Invoke (object obj, object[] parameters);abstract member Invoke : obj * obj[] -> obj
override this.Invoke : obj * obj[] -> objmember this.Invoke : obj * obj[] -> objPublic Overridable Function Invoke (obj As Object, parameters As Object()) As ObjectPublic Function Invoke (obj As Object, parameters As Object()) As ObjectParametri
- obj
- Object
Oggetto su cui richiamare il metodo o il costruttore. Se un metodo è statico, questo argomento viene ignorato. Se un costruttore è statico, questo argomento deve essere null oppure un'istanza della classe che definisce il costruttore.
- parameters
- Object[]
Elenco di argomenti per il metodo o il costruttore richiamato. È costituito da una matrice di oggetti con lo stesso numero, ordine e tipo dei parametri del metodo o del costruttore da richiamare. In assenza di parametri, parameters deve essere null.
Se il metodo o il costruttore rappresentato da questa istanza accetta un parametro ref (ByRef in Visual Basic), non sono richiesti speciali attributi del parametro per poter richiamare il metodo o il costruttore tramite questa funzione. Qualsiasi oggetto in questa matrice non inizializzato in modo esplicito con un valore conterrà il valore predefinito per quel tipo di oggetto. Per gli elementi di tipo riferimento, questo valore è null. Per gli elementi di tipo valore, il valore predefinito è 0, 0,0 o false, a seconda del tipo di elemento specifico.
Restituisce
Oggetto che contiene il valore restituito del metodo richiamato o null nel caso di un costruttore.
Implementazioni
Eccezioni
Il parametro obj è null e il metodo non è statico.
-oppure-
Il metodo non è dichiarato né ereditato dalla classe di obj.
-oppure-
Viene richiamato un costruttore statico e obj non è null né un'istanza della classe che ha dichiarato il costruttore.
Nota: in .NET per le app di Windows Store o nella libreria di classi portabile intercettare Exception .
Gli elementi della matrice di parameters non corrispondono alla firma del metodo o del costruttore ottenuto mediante reflection da questa istanza.
Il metodo o il costruttore richiamato genera un'eccezione.
-oppure-
L'istanza corrente è un oggetto DynamicMethod contenente codice non verificabile. Vedere la sezione "Verifica" nelle note per DynamicMethod.
La matrice parameters non contiene il numero corretto di argomenti.
Il chiamante non è autorizzato a eseguire il metodo o il costruttore rappresentato dall'istanza corrente.
Nota: in .NET per le app di Windows Store o nella libreria di classi portabile intercettare invece l'eccezione della classe di base, MemberAccessException, .
Il tipo che dichiara il metodo è un tipo generico aperto, ovvero la proprietà ContainsGenericParameters restituisce true per il tipo dichiarante.
L'istanza corrente è MethodBuilder.
Esempio
Nell'esempio di codice seguente viene illustrata la ricerca dinamica del metodo tramite reflection. Si noti che non è possibile utilizzare l'oggetto dalla classe base per richiamare il metodo sottoposto a override nella classe derivata, perché l'associazione MethodInfo tardiva non può risolvere gli override.
using namespace System;
using namespace System::Reflection;
public ref class MagicClass
{
private:
int magicBaseValue;
public:
MagicClass()
{
magicBaseValue = 9;
}
int ItsMagic(int preMagic)
{
return preMagic * magicBaseValue;
}
};
public ref class TestMethodInfo
{
public:
static void Main()
{
// Get the constructor and create an instance of MagicClass
Type^ magicType = Type::GetType("MagicClass");
ConstructorInfo^ magicConstructor = magicType->GetConstructor(Type::EmptyTypes);
Object^ magicClassObject = magicConstructor->Invoke(gcnew array<Object^>(0));
// Get the ItsMagic method and invoke with a parameter value of 100
MethodInfo^ magicMethod = magicType->GetMethod("ItsMagic");
Object^ magicValue = magicMethod->Invoke(magicClassObject, gcnew array<Object^>(1){100});
Console::WriteLine("MethodInfo.Invoke() Example\n");
Console::WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue);
}
};
int main()
{
TestMethodInfo::Main();
}
// The example program gives the following output:
//
// MethodInfo.Invoke() Example
//
// MagicClass.ItsMagic() returned: 900
using System;
using System.Reflection;
public class MagicClass
{
private int magicBaseValue;
public MagicClass()
{
magicBaseValue = 9;
}
public int ItsMagic(int preMagic)
{
return preMagic * magicBaseValue;
}
}
public class TestMethodInfo
{
public static void Main()
{
// Get the constructor and create an instance of MagicClass
Type magicType = Type.GetType("MagicClass");
ConstructorInfo magicConstructor = magicType.GetConstructor(Type.EmptyTypes);
object magicClassObject = magicConstructor.Invoke(new object[]{});
// Get the ItsMagic method and invoke with a parameter value of 100
MethodInfo magicMethod = magicType.GetMethod("ItsMagic");
object magicValue = magicMethod.Invoke(magicClassObject, new object[]{100});
Console.WriteLine("MethodInfo.Invoke() Example\n");
Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue);
}
}
// The example program gives the following output:
//
// MethodInfo.Invoke() Example
//
// MagicClass.ItsMagic() returned: 900
Imports System.Reflection
Public Class MagicClass
Private magicBaseValue As Integer
Public Sub New()
magicBaseValue = 9
End Sub
Public Function ItsMagic(preMagic As Integer) As Integer
Return preMagic * magicBaseValue
End Function
End Class
Public Class TestMethodInfo
Public Shared Sub Main()
' Get the constructor and create an instance of MagicClass
Dim magicType As Type = Type.GetType("MagicClass")
Dim magicConstructor As ConstructorInfo = magicType.GetConstructor(Type.EmptyTypes)
Dim magicClassObject As Object = magicConstructor.Invoke(New Object(){})
' Get the ItsMagic method and invoke with a parameter value of 100
Dim magicMethod As MethodInfo = magicType.GetMethod("ItsMagic")
Dim magicValue As Object = magicMethod.Invoke(magicClassObject, New Object(){100})
Console.WriteLine("MethodInfo.Invoke() Example" + Environment.NewLine)
Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue)
End Sub
End Class
' The example program gives the following output:
'
' MethodInfo.Invoke() Example
'
' MagicClass.ItsMagic() returned: 900
Commenti
Si tratta di un metodo pratico che chiama l'overload del Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) metodo, passando Default per invokeAttr e null per binder e culture.
Se il metodo richiamato genera un'eccezione, il Exception.GetBaseException metodo restituisce l'eccezione di origine.
Per richiamare un metodo statico usando il relativo MethodInfo oggetto , passare null per obj.
Nota
Se questo overload del metodo viene utilizzato per richiamare un costruttore di istanza, l'oggetto fornito per obj viene reinizializzato, ovvero vengono eseguiti tutti gli inizializzatori di istanza. Viene restituito il valore null. Se viene richiamato un costruttore di classe, la classe viene reinizializzata; ovvero vengono eseguiti tutti gli inizializzatori di classe. Viene restituito il valore null.
Nota
A partire da .NET Framework 2.0, questo metodo può essere usato per accedere a membri non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei membri non pubblici è limitato al set di concessioni del chiamante o a un subset. Vedere Considerazioni sulla sicurezza per la reflection. Per usare questa funzionalità, l'applicazione deve avere come destinazione .NET Framework 3.5 o versione successiva.
Se un parametro del metodo riflesso è un tipo valore e l'argomento corrispondente in parameters è null, il runtime passa un'istanza inizializzata zero del tipo valore.
Vedi anche
- BindingFlags
- Missing
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
Si applica a
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)
- Origine:
- MethodBase.cs
- Origine:
- MethodBase.cs
- Origine:
- MethodBase.cs
Quando viene sottoposto a override in una classe derivata, richiama il metodo o il costruttore ottenuto mediante reflection con i parametri specificati.
public:
abstract System::Object ^ Invoke(System::Object ^ obj, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, cli::array <System::Object ^> ^ parameters, System::Globalization::CultureInfo ^ culture);public abstract object? Invoke (object? obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object?[]? parameters, System.Globalization.CultureInfo? culture);public abstract object Invoke (object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);abstract member Invoke : obj * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo -> objPublic MustOverride Function Invoke (obj As Object, invokeAttr As BindingFlags, binder As Binder, parameters As Object(), culture As CultureInfo) As ObjectParametri
- obj
- Object
Oggetto su cui richiamare il metodo o il costruttore. Se un metodo è statico, questo argomento viene ignorato. Se un costruttore è statico, questo argomento deve essere null oppure un'istanza della classe che definisce il costruttore.
- invokeAttr
- BindingFlags
Maschera di bit equivalente a una combinazione di 0 o più flag di bit da BindingFlags.
- binder
- Binder
Oggetto che consente il binding, la coercizione dei tipi di argomento, la chiamata dei membri e il recupero di oggetti MemberInfo tramite reflection. Se binder è null, verrà usato il binder predefinito.
- parameters
- Object[]
Elenco di argomenti per il metodo o il costruttore richiamato. È costituito da una matrice di oggetti con lo stesso numero, ordine e tipo dei parametri del metodo o del costruttore da richiamare. In assenza di parametri, deve essere null.
Se il metodo o il costruttore rappresentati da questa istanza accettano un parametro ByRef, non sono richiesti attributi speciali per tale parametro per poter richiamare il metodo o il costruttore che utilizza la funzione. Qualsiasi oggetto in questa matrice non inizializzato in modo esplicito con un valore conterrà il valore predefinito per quel tipo di oggetto. Per gli elementi di tipo riferimento, questo valore è null. Per gli elementi di tipo valore, questo valore è 0, 0.0 o false, a seconda del tipo di elemento specifico.
- culture
- CultureInfo
Istanza di CultureInfo usata per regolare la coercizione dei tipi. Se è null, per il thread corrente verrà usato l'oggetto CultureInfo. Si tratta di un parametro necessario per convertire una stringa che rappresenta, ad esempio, il numero 1000 in un valore Double, dal momento che questo numero è rappresentato in modo diverso nelle varie impostazioni cultura.
Restituisce
Object contenente il valore restituito del metodo richiamato, oppure null nel caso di un costruttore, oppure null se il tipo restituito dal metodo è void. Prima di chiamare il metodo o il costruttore, Invoke verifica che l'utente disponga dell'autorizzazione per l'accesso e che i parametri siano validi.
Implementazioni
Eccezioni
Il parametro obj è null e il metodo non è statico.
-oppure-
Il metodo non è dichiarato né ereditato dalla classe di obj.
-oppure-
Viene richiamato un costruttore statico e obj non è null né un'istanza della classe che ha dichiarato il costruttore.
Il tipo del parametro parameters non corrisponde alla firma del metodo o del costruttore ottenuto mediante reflection da questa istanza.
La matrice parameters non contiene il numero corretto di argomenti.
Il metodo o il costruttore richiamato genera un'eccezione.
Il chiamante non è autorizzato a eseguire il metodo o il costruttore rappresentato dall'istanza corrente.
Il tipo che dichiara il metodo è un tipo generico aperto, ovvero la proprietà ContainsGenericParameters restituisce true per il tipo dichiarante.
Esempio
Nell'esempio seguente vengono illustrati tutti i membri della System.Reflection.Binder classe utilizzando un overload di Type.InvokeMember. Il metodo CanConvertFrom privato trova tipi compatibili per un determinato tipo. Per un altro esempio di richiamo dei membri in uno scenario di associazione personalizzato, vedere Caricamento dinamico e uso di tipi.
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
Commenti
Questo metodo richiama in modo dinamico il metodo riflesso da questa istanza in obje passa lungo i parametri specificati. Se il metodo è statico, il obj parametro viene ignorato. Per i metodi non statici, obj deve essere un'istanza di una classe che eredita o dichiara il metodo e deve essere lo stesso tipo di questa classe. Se il metodo non ha parametri, il valore di parameters deve essere null. In caso contrario, il numero, il tipo e l'ordine degli elementi in parameters devono essere identici al numero, al tipo e all'ordine dei parametri per il metodo riflessa da questa istanza.
Non è possibile omettere parametri facoltativi nelle chiamate a Invoke. Per richiamare un metodo e omettere parametri facoltativi, chiamare Type.InvokeMember invece .
Nota
Se questo overload del metodo viene utilizzato per richiamare un costruttore di istanza, l'oggetto fornito per obj viene reinizializzato, ovvero vengono eseguiti tutti gli inizializzatori di istanza. Viene restituito il valore null. Se viene richiamato un costruttore di classe, la classe viene reinizializzata; ovvero vengono eseguiti tutti gli inizializzatori di classe. Viene restituito il valore null.
Per i parametri primitivi pass-by-value, viene eseguita la normale estensione (ad esempio Int16 -> Int32). Per i parametri di riferimento pass-by-value, è consentita l'estensione del riferimento normale (classe derivata alla classe base e classe base al tipo di interfaccia). Tuttavia, per i parametri primitivi pass-by-reference, i tipi devono corrispondere esattamente. Per i parametri di riferimento pass-by-reference, viene comunque applicata la normale estensione.
Ad esempio, se il metodo riflesso da questa istanza viene dichiarato come public boolean Compare(String a, String b), parameters deve essere una matrice di Objects con lunghezza 2 in modo che parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").
Se un parametro del metodo corrente è un tipo valore e l'argomento corrispondente in parameters è null, il runtime passa un'istanza inizializzata zero del tipo valore.
Reflection usa la ricerca dinamica del metodo quando si richiamano metodi virtuali. Si supponga, ad esempio, che la classe B eredita dalla classe A e che implementi un metodo virtuale denominato M. Si supponga ora di avere un MethodInfo oggetto che rappresenta M nella classe A. Se si usa il Invoke metodo per richiamare M su un oggetto di tipo B, la reflection userà l'implementazione specificata dalla classe B. Anche se l'oggetto di tipo B viene eseguito il cast in A, viene usata l'implementazione specificata dalla classe B (vedere l'esempio di codice seguente).
D'altra parte, se il metodo non è virtuale, la reflection userà l'implementazione specificata dal tipo da cui MethodInfo è stato ottenuto, indipendentemente dal tipo dell'oggetto passato come destinazione.
Le restrizioni di accesso vengono ignorate per il codice completamente attendibile. Ovvero, i costruttori privati, i metodi, i campi e le proprietà possono essere accessibili e richiamati tramite reflection ogni volta che il codice è completamente attendibile.
Se il metodo richiamato genera un'eccezione, il Exception.GetBaseException metodo restituisce l'eccezione di origine.
Nota
A partire da .NET Framework 2.0, questo metodo può essere usato per accedere a membri non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessione dei membri non pubblici è limitato al set di concessione del chiamante o a un subset. Vedere Considerazioni sulla sicurezza per Reflection. Per usare questa funzionalità, l'applicazione deve essere di destinazione .NET Framework 3.5 o successiva.
Vedi anche
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
- Caricamento e utilizzo dinamico dei tipi
