Type.InvokeMember Metoda

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args);

public:
 virtual System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args);

public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args);

public object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args);

member this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj

abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj
override this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj

Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object()) As Object

Parametry

Návraty

Objekt představující návratovou hodnotu vyvolaného členu.

Implementuje

Výjimky

Příklady

Následující příklad používá InvokeMember pro přístup ke členům typu.

using namespace System;
using namespace System::Reflection;

// This sample class has a field, constructor, method, and property.
ref class MyType
{
private:
   Int32 myField;

public:
   MyType( interior_ptr<Int32> x )
   {
       *x *= 5;
   }

   virtual String^ ToString() override
   {
      return myField.ToString();
   }

   property Int32 MyProp 
   {
      Int32 get()
      {
         return myField;
      }

      void set( Int32 value )
      {
         if ( value < 1 )
                  throw gcnew ArgumentOutOfRangeException( "value",value,"value must be > 0" );

         myField = value;
      }
   }
};

int main()
{
   Type^ t = MyType::typeid;

   // Create an instance of a type.
   array<Object^>^args = {8};
   Console::WriteLine( "The value of x before the constructor is called is {0}.", args[ 0 ] );
   Object^ obj = t->InvokeMember( nullptr, static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, nullptr, args );
   Console::WriteLine( "Type: {0}", obj->GetType() );
   Console::WriteLine( "The value of x after the constructor returns is {0}.", args[ 0 ] );

   // Read and write to a field.
   array<Object^>^obj5 = {5};
   t->InvokeMember( "myField", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetField), nullptr, obj, obj5 );
   Int32 v = safe_cast<Int32>(t->InvokeMember( "myField", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::GetField), nullptr, obj, nullptr ));
   Console::WriteLine( "myField: {0}", v );

   // Call a method.
   String^ s = safe_cast<String^>(t->InvokeMember( "ToString", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::InvokeMethod), nullptr, obj, nullptr ));
   Console::WriteLine( "ToString: {0}", s );

   // Read and write a property. First, attempt to assign an
   // invalid value; then assign a valid value; finally, get
   // the value.
   try
   {
      // Assign the value zero to MyProp. The Property Set 
      // throws an exception, because zero is an invalid value.
      // InvokeMember catches the exception, and throws 
      // TargetInvocationException. To discover the real cause
      // you must catch TargetInvocationException and examine
      // the inner exception. 
      array<Object^>^obj0 = {(int^)0};
      t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetProperty), nullptr, obj, obj0 );
   }
   catch ( TargetInvocationException^ e ) 
   {
      // If the property assignment failed for some unexpected
      // reason, rethrow the TargetInvocationException.
      if ( e->InnerException->GetType() != ArgumentOutOfRangeException::typeid )
            throw;

      Console::WriteLine( "An invalid value was assigned to MyProp." );
   }

   array<Object^>^obj2 = {2};
   t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetProperty), nullptr, obj, obj2 );
   v =  safe_cast<Int32>(t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::GetProperty), nullptr, obj, nullptr ));
   Console::WriteLine( "MyProp: {0}", v );
}

using System;
using System.Reflection;

// This sample class has a field, constructor, method, and property.
class MyType
{
    Int32 myField;
    public MyType(ref Int32 x) {x *= 5;}
    public override String ToString() {return myField.ToString();}
    public Int32 MyProp
    {
        get {return myField;}
        set
        {
            if (value < 1)
                throw new ArgumentOutOfRangeException("value", value, "value must be > 0");
            myField = value;
        }
    }
}

class MyApp
{
    static void Main()
    {
        Type t = typeof(MyType);
        // Create an instance of a type.
        Object[] args = new Object[] {8};
        Console.WriteLine("The value of x before the constructor is called is {0}.", args[0]);
        Object obj = t.InvokeMember(null,
            BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.CreateInstance, null, null, args);
        Console.WriteLine("Type: " + obj.GetType().ToString());
        Console.WriteLine("The value of x after the constructor returns is {0}.", args[0]);

        // Read and write to a field.
        t.InvokeMember("myField",
            BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.SetField, null, obj, new Object[] {5});
        Int32 v = (Int32) t.InvokeMember("myField",
            BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.GetField, null, obj, null);
        Console.WriteLine("myField: " + v);

        // Call a method.
        String s = (String) t.InvokeMember("ToString",
            BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, null);
        Console.WriteLine("ToString: " + s);

        // Read and write a property. First, attempt to assign an
        // invalid value; then assign a valid value; finally, get
        // the value.
        try
        {
            // Assign the value zero to MyProp. The Property Set
            // throws an exception, because zero is an invalid value.
            // InvokeMember catches the exception, and throws
            // TargetInvocationException. To discover the real cause
            // you must catch TargetInvocationException and examine
            // the inner exception.
            t.InvokeMember("MyProp",
                BindingFlags.DeclaredOnly |
                BindingFlags.Public | BindingFlags.NonPublic |
                BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] {0});
        }
        catch (TargetInvocationException e)
        {
            // If the property assignment failed for some unexpected
            // reason, rethrow the TargetInvocationException.
            if (e.InnerException.GetType() !=
                typeof(ArgumentOutOfRangeException))
                throw;
            Console.WriteLine("An invalid value was assigned to MyProp.");
        }
        t.InvokeMember("MyProp",
            BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] {2});
        v = (Int32) t.InvokeMember("MyProp",
            BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.GetProperty, null, obj, null);
        Console.WriteLine("MyProp: " + v);
    }
}

open System
open System.Reflection

// This sample class has a field, constructor, method, and property.
type MyType() =
    let mutable myField = 0

    member _.MyType(x: int byref) =
        x <- x * 5
    
    override _.ToString() =
        string myField
    
    member _.MyProp
        with get () = myField
        and set value =
            if value < 1 then
                raise (ArgumentOutOfRangeException("value", value, "value must be > 0"))
            myField <- value

let t = typeof<MyType>
// Create an instance of a type.
let args = Array.zeroCreate<obj> 8
printfn $"The value of x before the constructor is called is {args[0]}."
let obj = t.InvokeMember(null,
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.CreateInstance, null, null, args)
printfn $"Type: {obj.GetType()}"
printfn $"The value of x after the constructor returns is {args[0]}."

// Read and write to a field.
t.InvokeMember("myField",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.SetField, null, obj, Array.zeroCreate<obj> 5) |> ignore
let v = t.InvokeMember("myField",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.GetField, null, obj, null) :?> int
printfn $"myField: {v}"

// Call a method.
let s = t.InvokeMember("ToString",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.InvokeMethod, null, obj, null) :?> string
printfn $"ToString: {s}"

// Read and write a property. First, attempt to assign an
// invalid value then assign a valid value finally, get
// the value.
try
    // Assign the value zero to MyProp. The Property Set
    // throws an exception, because zero is an invalid value.
    // InvokeMember catches the exception, and throws
    // TargetInvocationException. To discover the real cause
    // you must catch TargetInvocationException and examine
    // the inner exception.
    t.InvokeMember("MyProp",
        BindingFlags.DeclaredOnly |||
        BindingFlags.Public ||| BindingFlags.NonPublic |||
        BindingFlags.Instance ||| BindingFlags.SetProperty, null, obj, Array.zeroCreate<obj> 0) |> ignore
with :? TargetInvocationException as e ->
    // If the property assignment failed for some unexpected
    // reason, rethrow the TargetInvocationException.
    if e.InnerException.GetType() <> typeof<ArgumentOutOfRangeException> then
        reraise ()
    printfn "An invalid value was assigned to MyProp."
t.InvokeMember("MyProp",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.SetProperty, null, obj, Array.zeroCreate<obj> 2) |> ignore
let v2 = t.InvokeMember("MyProp",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.GetProperty, null, obj, null)
printfn $"MyProp: {v2}"

Imports System.Reflection

' This sample class has a field, constructor, method, and property.
Class MyType
    Private myField As Int32

    Public Sub New(ByRef x As Int32)
        x *= 5
    End Sub

    Public Overrides Function ToString() As [String]
        Return myField.ToString()
    End Function 'ToString

    Public Property MyProp() As Int32
        Get
            Return myField
        End Get
        Set(ByVal Value As Int32)
            If Value < 1 Then
                Throw New ArgumentOutOfRangeException("value", Value, "value must be > 0")
            End If
            myField = Value
        End Set
    End Property
End Class

Class MyApp

    Shared Sub Main()
        Dim t As Type = GetType(MyType)
        ' Create an instance of a type.
        Dim args() As [Object] = {8}
        Console.WriteLine("The value of x before the constructor is called is {0}.", args(0))
        Dim obj As [Object] = t.InvokeMember(Nothing, BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.CreateInstance, Nothing, Nothing, args)
        Console.WriteLine("Type: {0}", obj.GetType().ToString())
        Console.WriteLine("The value of x after the constructor returns is {0}.", args(0))

        ' Read and write to a field.
        t.InvokeMember("myField", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetField, Nothing, obj, New [Object]() {5})
        Dim v As Int32 = CType(t.InvokeMember("myField", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.GetField, Nothing, obj, Nothing), Int32)
        Console.WriteLine("myField: {0}", v)

        ' Call a method.
        Dim s As [String] = CType(t.InvokeMember("ToString", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.InvokeMethod, Nothing, obj, Nothing), [String])
        Console.WriteLine("ToString: {0}", s)

        ' Read and write a property. First, attempt to assign an
        ' invalid value; then assign a valid value; finally, get
        ' the value.
        Try
            ' Assign the value zero to MyProp. The Property Set 
            ' throws an exception, because zero is an invalid value.
            ' InvokeMember catches the exception, and throws 
            ' TargetInvocationException. To discover the real cause
            ' you must catch TargetInvocationException and examine
            ' the inner exception. 
            t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetProperty, Nothing, obj, New [Object]() {0})
        Catch e As TargetInvocationException
            ' If the property assignment failed for some unexpected
            ' reason, rethrow the TargetInvocationException.
            If Not e.InnerException.GetType() Is GetType(ArgumentOutOfRangeException) Then
                Throw
            End If
            Console.WriteLine("An invalid value was assigned to MyProp.")
        End Try
        t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetProperty, Nothing, obj, New [Object]() {2})
        v = CType(t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.GetProperty, Nothing, obj, Nothing), Int32)
        Console.WriteLine("MyProp: {0}", v)
    End Sub
End Class

Poznámky

BindingFlags Následující příznaky filtru lze použít k definování členů, které se mají zahrnout do hledání:

• Zadejte BindingFlags.Public , aby se do hledání zahrnuli veřejní členové.

• Zadejte BindingFlags.NonPublic , aby se do hledání zahrnuli neveřejní členové (tj. soukromé a chráněné členy).

• Zadejte BindingFlags.FlattenHierarchy , aby se statické členy zahrnuly v hierarchii.

Pomocí následujících BindingFlags modifikačních příznaků můžete změnit fungování vyhledávání:

• BindingFlags.IgnoreCase pokud chcete ignorovat případ name.

• BindingFlags.DeclaredOnly prohledat pouze členy deklarované na Type, nikoli členy, které byly jednoduše zděděny.

K označení akce, kterou se má člen provést, můžete použít následující BindingFlags příznaky vyvolání:

• CreateInstance k vyvolání konstruktoru. name se ignoruje. Není platné s jinými příznaky vyvolání.

• InvokeMethod k vyvolání metody, ale ne konstruktoru nebo inicializátoru typu. Neplatné s SetField nebo SetProperty. Pokud InvokeMethod je zadaný sám, BindingFlags.Publicautomaticky se zahrnou , BindingFlags.Instancea BindingFlags.Static .

• GetField a získejte hodnotu pole. Není platné pro SetField.

• SetField a nastavte hodnotu pole. Není platné pro GetField.

• GetProperty a získejte vlastnost. Není platné pro SetProperty.

• SetProperty a nastavte vlastnost. Není platné pro GetProperty.

Další informace naleznete v tématu System.Reflection.BindingFlags.

Metoda bude vyvolána, pokud jsou splněny obě následující podmínky:

• Počet parametrů v deklaraci metody se rovná počtu argumentů v args matici (pokud nejsou u členu definovány výchozí argumenty a BindingFlags.OptionalParamBinding nejsou zadány).

• Typ každého argumentu může pořadač převést na typ parametru.

Pořadač najde všechny odpovídající metody. Tyto metody se najdou na základě typu požadované vazby (BindingFlags hodnoty InvokeMethod, GetPropertyatd.). Sada metod je filtrována podle názvu, počtu argumentů a sady modifikátorů hledání definovaných v pořadači.

Po výběru je metoda vyvolána. Přístupnost je v tomto okamžiku zaškrtnutá. Vyhledávání může řídit, která sada metod se prohledá na základě atributu přístupnosti přidruženého k metodě. Metoda Binder.BindToMethodBinder třídy je zodpovědná za výběr metody, která se má vyvolat. Výchozí pořadač vybere nejkonifernější shodu.

Omezení přístupu jsou ignorována pro plně důvěryhodný kód. to znamená, že privátní konstruktory, metody, pole a vlastnosti mohou být přístupné a vyvolány prostřednictvím System.Reflection vždy, když je kód plně důvěryhodný.

Můžete použít Type.InvokeMember k nastavení pole na určitou hodnotu zadáním BindingFlags.SetField. Pokud například chcete nastavit pole veřejné instance s názvem F ve třídě C a F je String, můžete použít například kód:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {"strings new value"});

Pokud je String[]F , můžete použít například kód:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {new String[]{"a","z","c","d"}});

, který inicializuje pole F na toto nové pole. Můžete také použít Type.InvokeMember k nastavení pozice v poli zadáním indexu hodnoty a pak další hodnoty pomocí kódu, jako je například následující:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {1, "b"});

Tím se změní řetězec "z" v poli, který F drží na řetězec "b".

Při vyvolání člena IDispatch můžete místo názvu člena zadat dispID pomocí formátu řetězce [DispID=##]. Pokud je například DispID myComMethod 3, můžete místo "MyComMethod" zadat řetězec "[DispID=3]". Vyvolání člena pomocí DispID je rychlejší než vyhledání člena podle jména. Ve složitých scénářích agregace je dispID někdy jediným způsobem, jak vyvolat požadovaného člena.

Viz také

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture);

public:
 virtual System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture);

public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args, System.Globalization.CultureInfo? culture);

public object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Globalization.CultureInfo culture);

member this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj

abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj
override this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj

Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object(), culture As CultureInfo) As Object

Parametry

Návraty

Objekt představující návratovou hodnotu vyvolaného členu.

Implementuje

Výjimky

Poznámky

I když výchozí pořadač nezpracovává CultureInfo ( culture parametr), můžete použít abstraktní System.Reflection.Binder třídu k zápisu vlastního pořadače, který zpracovává culture.

Následující BindingFlags příznaky filtru lze použít k definování členů, které se mají zahrnout do hledání:

• Zadejte BindingFlags.Public , chcete-li do hledání zahrnout veřejné členy.

• Zadejte BindingFlags.NonPublic , pokud chcete do hledání zahrnout neveřejné členy (tj. soukromé, interní a chráněné členy).

• Zadejte BindingFlags.FlattenHierarchy , chcete-li zahrnout statické členy v hierarchii.

Pomocí následujících BindingFlags příznaků modifikátoru můžete změnit způsob fungování vyhledávání:

• BindingFlags.IgnoreCase pokud chcete ignorovat případ name.

• BindingFlags.DeclaredOnly hledat pouze členy deklarované na Type, nikoli členy, které byly jednoduše zděděny.

Následující BindingFlags příznaky volání se dají použít k označení akce, která se má s členem provést:

• CreateInstance pro vyvolání konstruktoru. name se ignoruje. Není platné u jiných příznaků volání.

• InvokeMethod k vyvolání metody, ale ne konstruktoru nebo inicializátoru typu. Není platné pro SetField nebo SetProperty. Pokud InvokeMethod je zadaný samostatně, BindingFlags.Publicautomaticky se zahrnou , BindingFlags.Instancea BindingFlags.Static .

• GetField , abyste získali hodnotu pole. Není platné pro SetField.

• SetField a nastavte hodnotu pole. Není platné pro GetField.

• GetProperty a získejte vlastnost. Není platné pro SetProperty.

• SetProperty a nastavte vlastnost. Není platné pro GetProperty.

Další informace naleznete v tématu System.Reflection.BindingFlags.

Metoda bude vyvolána, pokud jsou splněny obě následující podmínky:

• Počet parametrů v deklaraci metody se rovná počtu argumentů v args matici (pokud nejsou u členu definovány výchozí argumenty a BindingFlags.OptionalParamBinding nejsou zadány).

• Typ každého argumentu může být převeden pořadačem na typ parametru.

Pořadač najde všechny odpovídající metody. Tyto metody se najdou na základě typu požadované vazby (BindingFlags hodnoty InvokeMethod, GetPropertyatd.). Sada metod je filtrována podle názvu, počtu argumentů a sady modifikátorů vyhledávání definovaných v pořadači.

Po výběru metody se vyvolá. V tomto okamžiku je zaškrtnuté políčko Přístupnost. Vyhledávání může řídit, která sada metod se prohledá na základě atributu přístupnosti přidruženého k metodě. Metoda Binder.BindToMethodBinder třídy je zodpovědná za výběr metody, která má být vyvolána. Výchozí pořadač vybere nejkonseifnější shodu.

Omezení přístupu jsou ignorována pro plně důvěryhodný kód; To znamená, že k soukromým konstruktorům, metodám, polím a vlastnostem lze přistupovat a vyvolat je prostřednictvím reflexe vždy, když je kód plně důvěryhodný.

Zadáním příkazu Type.InvokeMember můžete nastavit pole na určitou hodnotu.BindingFlags.SetField Pokud například chcete nastavit pole veřejné instance s názvem F ve třídě C a F je , String můžete použít například následující kód:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {"strings new value"}, null);

Pokud je F , String[]můžete použít například následující kód:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {new String[]{"a","z","c","d"}}, null);

, která inicializuje pole F do tohoto nového pole. Můžete také použít Type.InvokeMember k nastavení pozice v poli tak, že zadáte index hodnoty a pak další hodnotu pomocí kódu, jako je tento:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {1, "b"}, null);

Tím se změní řetězec "z" v poli, který F drží na řetězec "b".

Při vyvolání členu IDispatch můžete místo názvu členu zadat DispID pomocí formátu řetězce "[DispID=##]". Pokud je například DispID myComMethod 3, můžete místo "MyComMethod" zadat řetězec "[DispID=3]". Vyvolání člena podle DispID je rychlejší než vyhledání člena podle jména. Ve složitých scénářích agregace je dispID někdy jediným způsobem, jak vyvolat požadovaného člena.

Viz také

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

public:
 abstract System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, cli::array <System::Reflection::ParameterModifier> ^ modifiers, System::Globalization::CultureInfo ^ culture, cli::array <System::String ^> ^ namedParameters);

public abstract object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args, System.Reflection.ParameterModifier[]? modifiers, System.Globalization.CultureInfo? culture, string[]? namedParameters);

public abstract object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters);

abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Reflection.ParameterModifier[] * System.Globalization.CultureInfo * string[] -> obj

Public MustOverride Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object(), modifiers As ParameterModifier(), culture As CultureInfo, namedParameters As String()) As Object

Parametry

Návraty

Objekt představující návratovou hodnotu vyvolaného členu.

Implementuje

Výjimky

Poznámky

InvokeMember volá člen konstruktoru nebo člen metody, získá nebo nastaví člen vlastnosti, získá nebo nastaví člena datového pole nebo získá nebo nastaví prvek člena pole.

Při vyvolání člena IDispatch můžete místo názvu člena zadat DispID pomocí formátu řetězce [DispID=##].. Pokud je například DispID myComMethod 3, můžete místo "MyComMethod" zadat řetězec "[DispID=3]". Vyvolání člena pomocí DispID je rychlejší než vyhledání člena podle jména. Ve složitých scénářích agregace je dispID někdy jediným způsobem, jak vyvolat požadovaného člena.

I když výchozí pořadač nezpracuje ParameterModifier nebo CultureInfo ( modifiers parametry a culture ), můžete použít abstraktní System.Reflection.Binder třídu k zápisu vlastního pořadače, který zpracovává modifiers a culture. ParameterModifier se používá pouze při volání prostřednictvím zprostředkovatele komunikace COM a jsou zpracovány pouze parametry, které jsou předány odkazem.

Každý parametr v namedParameters poli získá hodnotu v odpovídajícím prvku v args poli. Pokud je délka parametru args větší než délka parametru namedParameters, předají se zbývající hodnoty argumentů v pořadí.

Pole namedParameters lze použít ke změně pořadí argumentů ve vstupním poli. Například s ohledem na metodu M(string a, int b) (M(ByVal a As String, ByVal b As Integer) v jazyce Visual Basic) a vstupní pole { 42, "x" }lze vstupní pole předat beze změny do args , pokud je pole { "b", "a" } zadáno pro namedParameters.

BindingFlags Následující příznaky filtru lze použít k definování členů, které se mají zahrnout do hledání:

• Zadejte BindingFlags.Public , aby se do hledání zahrnuli veřejní členové.

• Zadejte BindingFlags.NonPublic , aby se do hledání zahrnuli neveřejní členové (tj. soukromé, interní a chráněné členy).

• Zadejte BindingFlags.FlattenHierarchy , aby se statické členy zahrnuly v hierarchii.

Pomocí následujících BindingFlags modifikačních příznaků můžete změnit fungování vyhledávání:

• BindingFlags.IgnoreCase pokud chcete ignorovat případ name.

• BindingFlags.DeclaredOnly prohledat pouze členy deklarované na Type, nikoli členy, které byly jednoduše zděděny.

K označení akce, kterou se má člen provést, můžete použít následující BindingFlags příznaky vyvolání:

• CreateInstance k vyvolání konstruktoru. name se ignoruje. Není platné s jinými příznaky vyvolání.

• InvokeMethod k vyvolání metody, ale ne konstruktoru nebo inicializátoru typu. Neplatné s SetField nebo SetProperty. Pokud InvokeMethod je zadaný sám, BindingFlags.Publicautomaticky se zahrnou , BindingFlags.Instancea BindingFlags.Static .

• GetField a získejte hodnotu pole. Není platné pro SetField.

• SetField a nastavte hodnotu pole. Není platné pro GetField.

• GetProperty a získejte vlastnost. Není platné pro SetProperty.

• SetProperty a nastavte vlastnost. Není platné pro GetProperty.

Další informace naleznete v tématu System.Reflection.BindingFlags.

Metoda bude vyvolána, pokud jsou splněny obě následující podmínky:

• Počet parametrů v deklaraci metody se rovná počtu argumentů v args matici (pokud nejsou u členu definovány výchozí argumenty a BindingFlags.OptionalParamBinding nejsou zadány).

• Typ každého argumentu může pořadač převést na typ parametru.

Pořadač najde všechny odpovídající metody. Tyto metody se najdou na základě typu požadované vazby (BindingFlags hodnoty InvokeMethod, GetPropertyatd.). Sada metod je filtrována podle názvu, počtu argumentů a sady modifikátorů hledání definovaných v pořadači.

Po výběru je metoda vyvolána. Přístupnost je v tomto okamžiku zaškrtnutá. Vyhledávání může řídit, která sada metod se prohledá na základě atributu přístupnosti přidruženého k metodě. Metoda Binder.BindToMethodBinder třídy je zodpovědná za výběr metody, která se má vyvolat. Výchozí pořadač vybere nejkonifernější shodu.

InvokeMember lze použít k vyvolání metod s parametry, které mají výchozí hodnoty. Pokud chcete vytvořit vazbu na tyto metody, reflexe vyžaduje BindingFlags.OptionalParamBinding , aby byla zadána. U parametru, který má výchozí hodnotu, můžete buď zadat jinou hodnotu, nebo zadat Missing.Value výchozí hodnotu.

Představte si například metodu MyMethod(int x, float y = 2.0). Chcete-li vyvolat tuto metodu pouze s prvním argumentem jako MyMethod(4), předejte jeden z výše uvedených příznaků vazby a předejte dva argumenty, a to 4 pro první argument a Missing.Value pro druhý argument. Pokud nepoužíváte Missing.Value, nesmíte vynechat volitelné parametry metody Invoke . Pokud to musíte udělat, použijte InvokeMember místo toho.

Omezení přístupu jsou ignorována pro plně důvěryhodný kód. to znamená, že privátní konstruktory, metody, pole a vlastnosti mohou být přístupné a vyvolány prostřednictvím System.Reflection vždy, když je kód plně důvěryhodný.

Můžete použít Type.InvokeMember k nastavení pole na určitou hodnotu zadáním BindingFlags.SetField. Pokud například chcete nastavit pole veřejné instance s názvem F ve třídě C a F je String, můžete použít například kód:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {"strings new value"}, null, null, null);

Pokud je String[]F , můžete použít například kód:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {new String[]{"a","z","c","d"}}, null, null, null);

, který inicializuje pole F na toto nové pole. Můžete také použít Type.InvokeMember k nastavení pozice v poli zadáním indexu hodnoty a pak další hodnoty pomocí kódu, jako je například následující:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {1, "b"}, null, null, null);

Tím se změní řetězec "z" v poli, který F drží na řetězec "b".

Viz také

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission