MethodBase.Invoke Methode
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Roept de methode of constructor aan die door dit MethodInfo exemplaar wordt weerspiegeld.
Overloads
| Name | Description |
|---|---|
| Invoke(Object, Object[]) |
Roept de methode of constructor aan die wordt vertegenwoordigd door het huidige exemplaar, met behulp van de opgegeven parameters. |
| Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Wanneer deze wordt overschreven in een afgeleide klasse, roept u de weerspiegelingsmethode of constructor aan met de opgegeven parameters. |
Invoke(Object, Object[])
Roept de methode of constructor aan die wordt vertegenwoordigd door het huidige exemplaar, met behulp van de opgegeven parameters.
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);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 ObjectParameters
- obj
- Object
Het object waarop de methode of constructor moet worden aangeroepen. Als een methode statisch is, wordt dit argument genegeerd. Als een constructor statisch is, moet null dit argument of een exemplaar van de klasse zijn die de constructor definieert.
- parameters
- Object[]
Een lijst met argumenten voor de aangeroepen methode of constructor. Dit is een matrix van objecten met hetzelfde aantal, dezelfde volgorde en type als de parameters van de methode of constructor die moeten worden aangeroepen. Als er geen parameters zijn, parameters moet dit zijn null.
Als de methode of constructor die wordt vertegenwoordigd door dit exemplaar een parameter ref (ByRef in Visual Basic) gebruikt, is er geen speciaal kenmerk vereist voor die parameter om de methode of constructor aan te roepen met behulp van deze functie. Elk object in deze matrix dat niet expliciet is geïnitialiseerd met een waarde, bevat de standaardwaarde voor dat objecttype. Voor verwijzingstype-elementen is nulldeze waarde . Voor elementen van het waardetype is de standaardwaarde 0, 0,0 of false, afhankelijk van het specifieke elementtype.
Retouren
Een object met de retourwaarde van de aangeroepen methode of null in het geval van een constructor.
Implementeringen
Uitzonderingen
De obj parameter is null en de methode is niet statisch.
– of –
De methode wordt niet gedeclareerd of overgenomen door de klasse van obj.
– of –
Er wordt een statische constructor aangeroepen en obj is noch null een exemplaar van de klasse die de constructor heeft gedeclareerd.
Opmerking: In .NET voor Windows Store-apps of de Portable Class Library kunt u in plaats daarvan Exception vangen.
De elementen van de parameters matrix komen niet overeen met de handtekening van de methode of constructor die door dit exemplaar wordt weerspiegeld.
De aangeroepen methode of constructor genereert een uitzondering.
– of –
Het huidige exemplaar is een DynamicMethod exemplaar dat niet-verifieerbare code bevat. Zie de sectie 'Verificatie' in Opmerkingen voor DynamicMethod.
De parameters matrix heeft niet het juiste aantal argumenten.
De aanroeper is niet gemachtigd om de methode of constructor uit te voeren die wordt vertegenwoordigd door het huidige exemplaar.
Opmerking: In .NET voor Windows Store-apps of de Portable Class Library, haalt u in plaats daarvan de uitzondering van de basisklasse op, MemberAccessException.
Het type dat de methode declareert, is een open algemeen type. Dat wil gezegd, de ContainsGenericParameters eigenschap retourneert true voor het declaratietype.
Het huidige exemplaar is een MethodBuilder.
Voorbeelden
In het volgende codevoorbeeld ziet u dynamische methodezoekactie met behulp van weerspiegeling. Houd er rekening mee dat u het MethodInfo object van de basisklasse niet kunt gebruiken om de overschreven methode in de afgeleide klasse aan te roepen, omdat latere binding onderdrukkingen niet kan oplossen.
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
Opmerkingen
Dit is een handige methode die de overbelasting van de Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) methode aanroept, doorgeeft Default voor en voor invokeAttrbinder en nullculture.
Als de aangeroepen methode een uitzondering genereert, retourneert de Exception.GetBaseException methode de oorspronkelijke uitzondering.
Als u een statische methode wilt aanroepen met behulp van het MethodInfo object, geeft u door null voor obj.
Note
Als deze overbelasting van de methode wordt gebruikt om een exemplaarconstructor aan te roepen, wordt het object waarvoor wordt opgegeven obj , opnieuw geïnitialiseerd. Dat wil wel dat alle initialisatiefuncties van exemplaren worden uitgevoerd. De retourwaarde is null. Als een klasseconstructor wordt aangeroepen, wordt de klasse opnieuw geïnitialiseerd; Dat wil gezegd, alle klasse-initializers worden uitgevoerd. De retourwaarde is null.
Note
Deze methode kan worden gebruikt voor toegang tot niet-openbare leden als de beller is verleend ReflectionPermission met de ReflectionPermissionFlag.RestrictedMemberAccess vlag en als de toekenningsset van de niet-openbare leden is beperkt tot de toekenningsset van de beller of een subset daarvan. (Zie Beveiligingsoverwegingen voor reflectie.) Als u deze functionaliteit wilt gebruiken, moet uw toepassing zich richten op .NET Framework 3.5 of hoger.
Als een parameter van de weerspiegelde methode een waardetype is en het bijbehorende argument is parametersnull, geeft de runtime een door nul geïnitialiseerd exemplaar van het waardetype door.
Zie ook
- BindingFlags
- Missing
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
Van toepassing op
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)
Wanneer deze wordt overschreven in een afgeleide klasse, roept u de weerspiegelingsmethode of constructor aan met de opgegeven parameters.
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);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 ObjectParameters
- obj
- Object
Het object waarop de methode of constructor moet worden aangeroepen. Als een methode statisch is, wordt dit argument genegeerd. Als een constructor statisch is, moet null dit argument of een exemplaar van de klasse zijn die de constructor definieert.
- invokeAttr
- BindingFlags
Een bitmasker dat een combinatie is van 0 of meer bitvlagken van BindingFlags.
- binder
- Binder
Een object dat de binding, dwang van argumenttypen, het aanroepen van leden en het ophalen van MemberInfo objecten via reflectie mogelijk maakt. Als binder dat het is null, wordt de standaardbinding gebruikt.
- parameters
- Object[]
Een lijst met argumenten voor de aangeroepen methode of constructor. Dit is een matrix van objecten met hetzelfde aantal, dezelfde volgorde en type als de parameters van de methode of constructor die moeten worden aangeroepen. Als er geen parameters zijn, moet dit zijn null.
Als de methode of constructor die wordt vertegenwoordigd door dit exemplaar een ByRef-parameter gebruikt, is er geen speciaal kenmerk vereist voor die parameter om de methode of constructor aan te roepen met behulp van deze functie. Elk object in deze matrix dat niet expliciet is geïnitialiseerd met een waarde, bevat de standaardwaarde voor dat objecttype. Voor verwijzingstype-elementen is nulldeze waarde . Voor elementen van het waardetype is deze waarde 0, 0,0 of false, afhankelijk van het specifieke elementtype.
- culture
- CultureInfo
Een exemplaar dat CultureInfo wordt gebruikt om de dwang van typen te bepalen. Als dit het is null, wordt het CultureInfo voor de huidige thread gebruikt. (Dit is nodig om een tekenreeks te converteren die 1000 vertegenwoordigt naar een Double waarde, bijvoorbeeld omdat 1000 verschillend wordt weergegeven door verschillende culturen.)
Retouren
Een Object met de retourwaarde van de aangeroepen methode, of null in het geval van een constructor, of null als het retourtype van de methode is void. Voordat u de methode of constructor aanroept, Invoke controleert u of de gebruiker toegangsmachtigingen heeft en controleert u of de parameters geldig zijn.
Implementeringen
Uitzonderingen
De obj parameter is null en de methode is niet statisch.
– of –
De methode wordt niet gedeclareerd of overgenomen door de klasse van obj.
– of –
Er wordt een statische constructor aangeroepen en obj is noch null een exemplaar van de klasse die de constructor heeft gedeclareerd.
Het type van de parameters parameter komt niet overeen met de handtekening van de methode of constructor die door dit exemplaar wordt weerspiegeld.
De parameters matrix heeft niet het juiste aantal argumenten.
De aangeroepen methode of constructor genereert een uitzondering.
De aanroeper is niet gemachtigd om de methode of constructor uit te voeren die wordt vertegenwoordigd door het huidige exemplaar.
Het type dat de methode declareert, is een open algemeen type. Dat wil gezegd, de ContainsGenericParameters eigenschap retourneert true voor het declaratietype.
Voorbeelden
In het volgende voorbeeld ziet u alle leden van de System.Reflection.Binder klasse met een overbelasting van Type.InvokeMember. Met de privémethode CanConvertFrom worden compatibele typen voor een bepaald type gevonden. Zie Dynamisch laden en typen gebruiken voor een ander voorbeeld van het aanroepen van leden in een aangepast bindingsscenario.
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
Opmerkingen
Deze methode roept de methode dynamisch aan die wordt weerspiegeld door dit exemplaar op objen geeft de opgegeven parameters door. Als de methode statisch is, wordt de obj parameter genegeerd. Voor niet-statische methoden obj moet dit een exemplaar zijn van een klasse die de methode over neemt of declareert en hetzelfde type moet zijn als deze klasse. Als de methode geen parameters heeft, moet de waarde zijn parametersnull. Anders moeten het aantal, het type en de volgorde van elementen parameters identiek zijn aan het aantal, het type en de volgorde van parameters voor de methode die door dit exemplaar wordt weerspiegeld.
U mag optionele parameters in aanroepen naar Invokeniet weglaten. Als u een methode wilt aanroepen en optionele parameters weglaat, roept Type.InvokeMember u in plaats daarvan aan.
Note
Als deze overbelasting van de methode wordt gebruikt om een exemplaarconstructor aan te roepen, wordt het object waarvoor wordt opgegeven obj , opnieuw geïnitialiseerd. Dat wil wel dat alle initialisatiefuncties van exemplaren worden uitgevoerd. De retourwaarde is null. Als een klasseconstructor wordt aangeroepen, wordt de klasse opnieuw geïnitialiseerd; Dat wil gezegd, alle klasse-initializers worden uitgevoerd. De retourwaarde is null.
Voor primitieve parameters voor pass-by-value wordt normale widening uitgevoerd (bijvoorbeeld Int16 -> Int32). Voor referentieparameters voor pass-by-value is normale verwijzingsverbreeding toegestaan (afgeleide klasse naar basisklasse en basisklasse naar interfacetype). Voor primitieve parameters voor pass-by-reference moeten de typen echter exact overeenkomen. Voor referentieparameters voor pass-by-reference is de normale widening nog steeds van toepassing.
Als de methode die door dit exemplaar wordt weerspiegeld, bijvoorbeeld wordt gedeclareerd als public boolean Compare(String a, String b), moet dit parameters een matrix met Objects lengte 2 parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2")zijn.
Als een parameter van de huidige methode een waardetype is en het bijbehorende argument is parametersnull, geeft de runtime een door nul geïnitialiseerd exemplaar van het waardetype door.
Reflectie maakt gebruik van dynamische methodezoekfunctie bij het aanroepen van virtuele methoden. Stel dat klasse B wordt overgenomen van klasse A en beide een virtuele methode met de naam M implementeren. Stel nu dat u een MethodInfo object hebt dat M op klasse A vertegenwoordigt. Als u de Invoke methode gebruikt om M aan te roepen voor een object van het type B, gebruikt reflectie de implementatie van klasse B. Zelfs als het object van het type B naar A wordt gecast, wordt de implementatie van klasse B gebruikt (zie het onderstaande codevoorbeeld).
Aan de andere kant, als de methode niet-virtueel is, gebruikt reflectie de implementatie die is gegeven door het type waaruit de MethodInfo is verkregen, ongeacht het type van het object dat als doel is doorgegeven.
Toegangsbeperkingen worden genegeerd voor volledig vertrouwde code. Dat wil gezegd, privéconstructors, methoden, velden en eigenschappen kunnen worden geopend en aangeroepen via reflectie wanneer de code volledig wordt vertrouwd.
Als de aangeroepen methode een uitzondering genereert, retourneert de Exception.GetBaseException methode de oorspronkelijke uitzondering.
Note
Deze methode kan worden gebruikt voor toegang tot niet-openbare leden als de beller is verleend ReflectionPermission met de ReflectionPermissionFlag.RestrictedMemberAccess vlag en als de toekenningsset van de niet-openbare leden is beperkt tot de toekenningsset van de beller of een subset daarvan. (Zie Beveiligingsoverwegingen voor reflectie.) Als u deze functionaliteit wilt gebruiken, moet uw toepassing zich richten op .NET Framework 3.5 of hoger.
Zie ook
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
- Dynamisch laden en typen gebruiken