MethodBase.Invoke Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ruft die Methode oder den Konstruktor auf, die von dieser MethodInfo Instanz wiedergegeben wird.
Überlädt
| Name | Beschreibung |
|---|---|
| Invoke(Object, Object[]) |
Ruft die von der aktuellen Instanz dargestellte Methode oder den Konstruktor mithilfe der angegebenen Parameter auf. |
| Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird die reflektierte Methode oder der Konstruktor mit den angegebenen Parametern aufgerufen. |
Invoke(Object, Object[])
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
Ruft die von der aktuellen Instanz dargestellte Methode oder den Konstruktor mithilfe der angegebenen Parameter auf.
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 ObjectParameter
- obj
- Object
Das Objekt, für das die Methode oder der Konstruktor aufgerufen werden soll. Wenn eine Methode statisch ist, wird dieses Argument ignoriert. Wenn ein Konstruktor statisch ist, muss dieses Argument eine Instanz der Klasse sein null , die den Konstruktor definiert.
- parameters
- Object[]
Eine Argumentliste für die aufgerufene Methode oder den Konstruktor. Dies ist ein Array von Objekten mit derselben Anzahl, Reihenfolge und Typ wie die Parameter der methode oder des Konstruktors, die aufgerufen werden sollen. Wenn keine Parameter vorhanden sind, parameters sollte es sich um null.
Wenn die von dieser Instanz dargestellte Methode oder der Konstruktor einen ref Parameter (ByRef in Visual Basic) verwendet, ist kein spezielles Attribut für diesen Parameter erforderlich, um die Methode oder den Konstruktor mit dieser Funktion aufzurufen. Jedes Objekt in diesem Array, das nicht explizit mit einem Wert initialisiert wird, enthält den Standardwert für diesen Objekttyp. Für Referenztypelemente ist nulldieser Wert . Bei Werttypelementen ist der Standardwert je nach Elementtyp 0, 0,0 oder false, je nach elementtyp.
Gibt zurück
Ein Objekt, das den Rückgabewert der aufgerufenen Methode oder null im Fall eines Konstruktors enthält.
Implementiert
Ausnahmen
Der obj Parameter ist null und die Methode ist nicht statisch.
- oder -
Die Methode wird nicht von der Klasse von obj.
- oder -
Ein statischer Konstruktor wird aufgerufen und obj ist weder null eine Instanz der Klasse, die den Konstruktor deklariert hat.
Die Elemente des parameters Arrays stimmen nicht mit der Signatur der Methode oder des Konstruktors überein, die von dieser Instanz widerspiegelt wird.
Die aufgerufene Methode oder der Konstruktor löst eine Ausnahme aus.
- oder -
Die aktuelle Instanz ist ein DynamicMethod Code, der unverifizierbaren Code enthält. Weitere Informationen finden Sie im Abschnitt "Verifizierung" in den Hinweisen für DynamicMethod.
Das parameters Array weist nicht die richtige Anzahl von Argumenten auf.
Der Aufrufer verfügt nicht über die Berechtigung zum Ausführen der Methode oder des Konstruktors, die von der aktuellen Instanz dargestellt wird.
Der Typ, der die Methode deklariert, ist ein offener generischer Typ. Das heißt, die ContainsGenericParameters Eigenschaft gibt für den deklarierenden Typ zurück true .
Die aktuelle Instanz ist ein MethodBuilder.
Beispiele
Im folgenden Codebeispiel wird die dynamische Methodensuche mithilfe von Spiegelung veranschaulicht. Beachten Sie, dass Sie das MethodInfo Objekt nicht aus der Basisklasse verwenden können, um die überschriebene Methode in der abgeleiteten Klasse aufzurufen, da späte Bindung keine Außerkraftsetzungen auflösen kann.
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
Hinweise
Dies ist eine Komfortmethode, die die Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) Methodenüberladung aufruft, für invokeAttrDefault und für und null für und für .culturebinder
Wenn die aufgerufene Methode eine Ausnahme auslöst, gibt die Exception.GetBaseException Methode die ursprüngliche Ausnahme zurück.
Übergeben Sie zum null Aufrufen einer statischen Methode mithilfe des MethodInfo Objekts für obj.
Note
Wenn diese Methodenüberladung verwendet wird, um einen Instanzkonstruktor aufzurufen, wird das bereitgestellte obj Objekt erneut initialisiert. Das heißt, alle Instanzinitialisierer werden ausgeführt. Der Rückgabewert lautet null. Wenn ein Klassenkonstruktor aufgerufen wird, wird die Klasse erneut initialisiert. d. h., alle Klasseninitialisierer werden ausgeführt. Der Rückgabewert lautet null.
Note
Diese Methode kann verwendet werden, um auf nicht öffentliche Member zuzugreifen, wenn der Aufrufer mit der ReflectionPermission Kennzeichnung erteilt ReflectionPermissionFlag.RestrictedMemberAccess wurde und wenn der Grant-Satz der nicht öffentlichen Mitglieder auf den Grant-Satz des Aufrufers oder eine Teilmenge davon beschränkt ist. (Siehe Security Considerations for Reflection.) Um diese Funktionalität zu verwenden, sollte Ihre Anwendung auf .NET Framework 3.5 oder höher abzielen.
Wenn ein Parameter der reflektierten Methode ein Werttyp ist und das entsprechende Argument darin parameters enthalten ist null, übergibt die Laufzeit eine nullinitialisierte Instanz des Werttyps.
Weitere Informationen
- BindingFlags
- Missing
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
Gilt für:
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
- Quelle:
- MethodBase.cs
Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird die reflektierte Methode oder der Konstruktor mit den angegebenen Parametern aufgerufen.
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 ObjectParameter
- obj
- Object
Das Objekt, für das die Methode oder der Konstruktor aufgerufen werden soll. Wenn eine Methode statisch ist, wird dieses Argument ignoriert. Wenn ein Konstruktor statisch ist, muss dieses Argument eine Instanz der Klasse sein null , die den Konstruktor definiert.
- invokeAttr
- BindingFlags
Eine Bitmaske, die eine Kombination aus 0 oder mehr Bit-Flags aus BindingFlagsist.
- binder
- Binder
Ein Objekt, das die Bindung, die Koersion von Argumenttypen, den Aufruf von Elementen und das Abrufen von MemberInfo Objekten über Spiegelung ermöglicht. Ist binder dies nullder Grund, wird der Standardordner verwendet.
- parameters
- Object[]
Eine Argumentliste für die aufgerufene Methode oder den Konstruktor. Dies ist ein Array von Objekten mit derselben Anzahl, Reihenfolge und Typ wie die Parameter der methode oder des Konstruktors, die aufgerufen werden sollen. Wenn keine Parameter vorhanden sind, sollte dies sein null.
Wenn die von dieser Instanz dargestellte Methode oder der Konstruktor einen ByRef-Parameter verwendet, ist für diesen Parameter kein spezielles Attribut erforderlich, um die Methode oder den Konstruktor mithilfe dieser Funktion aufzurufen. Jedes Objekt in diesem Array, das nicht explizit mit einem Wert initialisiert wird, enthält den Standardwert für diesen Objekttyp. Für Referenztypelemente ist nulldieser Wert . Bei Werttypelementen ist dieser Wert abhängig vom jeweiligen Elementtyp 0, 0,0 oder false.
- culture
- CultureInfo
Eine Instanz, die zum Steuern der CultureInfo Koersion von Typen verwendet wird. Wenn dies der Fall ist null, wird der CultureInfo aktuelle Thread verwendet. (Dies ist erforderlich, um eine Zeichenfolge zu konvertieren, die 1000 in einen Double Wert darstellt, z. B. da 1000 unterschiedlich durch verschiedene Kulturen dargestellt wird.)
Gibt zurück
Ein Object Wert mit dem Rückgabewert der aufgerufenen Methode oder null im Fall eines Konstruktors oder null wenn der Rückgabetyp der Methode lautet void. Überprüfen Sie vor dem Aufrufen der Methode oder des Konstruktors, Invoke ob der Benutzer über Zugriffsberechtigungen verfügt, und überprüft, ob die Parameter gültig sind.
Implementiert
Ausnahmen
Der obj Parameter ist null und die Methode ist nicht statisch.
- oder -
Die Methode wird nicht von der Klasse von obj.
- oder -
Ein statischer Konstruktor wird aufgerufen und obj ist weder null eine Instanz der Klasse, die den Konstruktor deklariert hat.
Der Typ des parameters Parameters stimmt nicht mit der Signatur der Methode oder des Konstruktors überein, die von dieser Instanz widerspiegelt wird.
Das parameters Array weist nicht die richtige Anzahl von Argumenten auf.
Die aufgerufene Methode oder der Konstruktor löst eine Ausnahme aus.
Der Aufrufer verfügt nicht über die Berechtigung zum Ausführen der Methode oder des Konstruktors, die von der aktuellen Instanz dargestellt wird.
Der Typ, der die Methode deklariert, ist ein offener generischer Typ. Das heißt, die ContainsGenericParameters Eigenschaft gibt für den deklarierenden Typ zurück true .
Beispiele
Das folgende Beispiel veranschaulicht alle Member der System.Reflection.Binder Klasse mithilfe einer Überladung von Type.InvokeMember. Die private Methode CanConvertFrom findet kompatible Typen für einen bestimmten Typ. Ein weiteres Beispiel für das Aufrufen von Mitgliedern in einem benutzerdefinierten Bindungsszenario finden Sie unter "Dynamisches Laden und Verwenden von Typen".
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
Hinweise
Diese Methode ruft die von dieser Instanz objwiedergegebene Methode dynamisch auf und übergibt die angegebenen Parameter. Wenn die Methode statisch ist, wird der obj Parameter ignoriert. Bei nicht statischen Methoden sollte es sich um eine Instanz einer Klasse handeln, obj die die Methode erbt oder deklariert und denselben Typ wie diese Klasse aufweisen muss. Wenn die Methode keine Parameter aufweist, sollte der Wert parameters sein null. Andernfalls sollte die Anzahl, der Typ und die Reihenfolge der Elemente parameters identisch mit der Zahl, dem Typ und der Reihenfolge der Parameter für die Methode sein, die von dieser Instanz widerzuspiegeln ist.
Sie dürfen optionale Parameter in Aufrufen von Invoke. Wenn Sie eine Methode aufrufen und optionale Parameter weglassen möchten, rufen Sie stattdessen auf Type.InvokeMember .
Note
Wenn diese Methodenüberladung verwendet wird, um einen Instanzkonstruktor aufzurufen, wird das bereitgestellte obj Objekt erneut initialisiert. Das heißt, alle Instanzinitialisierer werden ausgeführt. Der Rückgabewert lautet null. Wenn ein Klassenkonstruktor aufgerufen wird, wird die Klasse erneut initialisiert. d. h., alle Klasseninitialisierer werden ausgeführt. Der Rückgabewert lautet null.
Für Pass-by-Value-Grundtypen wird eine normale Verbreiterung ausgeführt (z. B. Int16 -> Int32). Bei Pass-by-Value-Referenzparametern ist eine normale Verweisweiterung zulässig (abgeleitete Klasse für Basisklasse und Basisklasse zum Schnittstellentyp). Bei pass-by-Reference-Grundtypen müssen die Typen jedoch exakt übereinstimmen. Bei Pass-by-Reference-Referenzparametern gilt weiterhin die normale Verbreiterung.
Wenn die von dieser Instanz widerspiegelte Methode z. B. als deklariert public boolean Compare(String a, String b)wird, sollte es parameters sich um ein Array mit Objects Der Länge 2 handelt, parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2")sodass dies der Fall ist.
Wenn ein Parameter der aktuellen Methode ein Werttyp ist und das entsprechende Argument darin parameters enthalten ist null, übergibt die Laufzeit eine nullinitialisierte Instanz des Werttyps.
Reflection verwendet dynamische Methodensuche beim Aufrufen virtueller Methoden. Angenommen, Klasse B erbt von Klasse A und implementiert beide eine virtuelle Methode mit dem Namen M. Angenommen, Sie haben ein MethodInfo Objekt, das M für Klasse A darstellt. Wenn Sie die Invoke Methode verwenden, um M für ein Objekt vom Typ B aufzurufen, verwendet die Spiegelung die implementierung der Klasse B. Auch wenn das Objekt vom Typ B in A umgegossen wird, wird die von Klasse B angegebene Implementierung verwendet (siehe Codebeispiel unten).
Wenn die Methode nicht virtuell ist, verwendet die Spiegelung hingegen die Implementierung des Typs, von dem die MethodInfo Methode abgerufen wurde, unabhängig vom Typ des als Ziel übergebenen Objekts.
Zugriffsbeschränkungen werden für voll vertrauenswürdigen Code ignoriert. Das heißt, auf private Konstruktoren, Methoden, Felder und Eigenschaften kann über Spiegelung zugegriffen und aufgerufen werden, wenn der Code vollständig vertrauenswürdig ist.
Wenn die aufgerufene Methode eine Ausnahme auslöst, gibt die Exception.GetBaseException Methode die ursprüngliche Ausnahme zurück.
Note
Diese Methode kann verwendet werden, um auf nicht öffentliche Member zuzugreifen, wenn der Aufrufer mit der ReflectionPermission Kennzeichnung erteilt ReflectionPermissionFlag.RestrictedMemberAccess wurde und wenn der Grant-Satz der nicht öffentlichen Mitglieder auf den Grant-Satz des Aufrufers oder eine Teilmenge davon beschränkt ist. (Siehe Security Considerations for Reflection.) Um diese Funktionalität zu verwenden, sollte Ihre Anwendung auf .NET Framework 3.5 oder höher abzielen.
Weitere Informationen
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
- Dynamisches Laden und Verwenden von Typen
