Type.DefaultBinder Eigenschaft

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Ruft einen Verweis auf den Standardbinder ab, der interne Regeln für die Auswahl der passenden Member implementiert, die von InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) aufgerufen werden sollen.

public:
 static property System::Reflection::Binder ^ DefaultBinder { System::Reflection::Binder ^ get(); };
public static System.Reflection.Binder DefaultBinder { get; }
member this.DefaultBinder : System.Reflection.Binder
Public Shared ReadOnly Property DefaultBinder As Binder

Eigenschaftswert

Binder

Ein Verweis auf den vom System verwendeten Standardbinder.

Beispiele

Im folgenden Beispiel wird der Standardbinder aus der DefaultBinder Eigenschaft abgerufen und ein Element von MyClass aufgerufen, indem der DefaultBinder Wert als Parameter übergeben wird InvokeMember.

using namespace System;
using namespace System::Reflection;
ref class MyClass
{
public:
   void HelloWorld()
   {
      Console::WriteLine( "Hello World" );
   }

};

int main()
{
   try
   {
      Binder^ defaultBinder = Type::DefaultBinder;
      MyClass^ myClass = gcnew MyClass;
      
      // Invoke the HelloWorld method of MyClass.
      myClass->GetType()->InvokeMember( "HelloWorld", BindingFlags::InvokeMethod, defaultBinder, myClass, nullptr );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception : {0}", e->Message );
   }

}

using System;
using System.Reflection;

public class MyDefaultBinderSample
{
    public static void Main()
    {
        try
        {
            Binder defaultBinder = Type.DefaultBinder;
            MyClass myClass = new MyClass();
            // Invoke the HelloWorld method of MyClass.
            myClass.GetType().InvokeMember("HelloWorld", BindingFlags.InvokeMethod,
                defaultBinder, myClass, new object [] {});
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception :" + e.Message);
        }
    }	

    class MyClass
    {
        public void HelloWorld()
        {
            Console.WriteLine("Hello World");
        }	
    }
}

open System
open System.Reflection

type MyClass() =
    member _.HelloWorld() =
        printfn "Hello World"

try
    let defaultBinder = Type.DefaultBinder
    let myClass = MyClass()
    // Invoke the HelloWorld method of MyClass.
    myClass.GetType().InvokeMember("HelloWorld", BindingFlags.InvokeMethod, defaultBinder, myClass, [||])
    |> ignore
with e ->
    printfn $"Exception: {e.Message}"

Imports System.Reflection

Public Class MyDefaultBinderSample
    Public Shared Sub Main()
        Try
            Dim defaultBinder As Binder = Type.DefaultBinder
            Dim [myClass] As New [MyClass]()
            ' Invoke the HelloWorld method of MyClass.
            [myClass].GetType().InvokeMember("HelloWorld", BindingFlags.InvokeMethod, defaultBinder, [myClass], New Object() {})
        Catch e As Exception
            Console.WriteLine("Exception :" + e.Message.ToString())
        End Try
    End Sub

    Class [MyClass]

        Public Sub HelloWorld()
            Console.WriteLine("Hello World")
        End Sub
    End Class
End Class

Hinweise

Der Standardordner, der mit der allgemeinen Sprachlaufzeit bereitgestellt wird, ist in allen, aber den speziellsten Umständen anwendbar. Wenn Sie einen Binder benötigen, der sich von denen der angegebenen Standardbinder unterscheidet, definieren Sie einen Vom Klassentyp abgeleiteten Binder Typ und übergeben eine Instanz dieses Typs mithilfe binder des Parameters InvokeMember einer der Überladungen.

Spiegelung modelliert die Barrierefreiheitsregeln des allgemeinen Typsystems. Wenn sich der Anrufer beispielsweise in derselben Assembly befindet, benötigt der Anrufer keine speziellen Berechtigungen für interne Mitglieder. Andernfalls benötigt ReflectionPermissionder Anrufer . Dies entspricht dem Nachschlagevorgang von Mitgliedern, die geschützt, privat und so weiter sind.

Das allgemeine Prinzip besteht darin, dass ChangeType nur Verbreiterungskonvertierungen ausgeführt werden sollen, die niemals Daten verlieren. Ein Beispiel für eine Erweiterungskonvertierung ist das Konvertieren eines Werts, der eine 32-Bit-Ganzzahl ist, in einen Wert, der eine 64-Bit-Zeichenzahl ist. Dies unterscheidet sich von einer schmalen Konvertierung, die Daten verlieren kann. Ein Beispiel für eine Schmalungskonvertierung wird eine 64-Bit-Ganzzahl in eine 32-Bit-Ganzzahl konvertiert.

In der folgenden Tabelle sind die Konvertierungen aufgeführt, die vom Standardordner unterstützt werden.

Quellentyp Zieltyp
Beliebiger Typ Der Basistyp.
Beliebiger Typ Die Schnittstelle, die sie implementiert.
Char Unt16, UInt32, Int32, UInt64, Int64, Single, Double
Byte Char, Unt16, Int16, UInt32, Int32, UInt64, Int64, Single, Double
SByte Int16, Int32, Int64, Single, Double
UInt16 UInt32, Int32, UInt64, Int64, Single, Double
Int16 Int32, Int64, Single, Double
UInt32 UInt64, Int64, Single, Double
Int32 Int64, Single, Double
UInt64 Single, Double
Int64 Single, Double
Single Double
Nichtverweis Nachverweis.

Gilt für:

Siehe auch