Type.DefaultBinder Eigenschaft

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.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

Das folgende Beispiel ruft den Standardbinder aus der -Eigenschaft ab und ruft einen Member von MyClass auf, indem der Wert DefaultBinder als Parameter an übergeben DefaultBinder InvokeMember wird.

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");
        }	
    }
}

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 standardbinder, der mit der Common Language Runtime bereitgestellt wird, gilt nur in den speziellsten Fällen. Wenn Sie einen Binder benötigen, der Regeln folgt, die sich von denen des angegebenen Standardbinder unterscheiden, definieren Sie einen von der -Klasse abgeleiteten Typ, und übergeben Sie eine Instanz dieses Typs mithilfe des -Parameters einer der Binder binder InvokeMember Überladungen.

Reflektion modelliert die Zugriffsregeln des allgemeinen Typsystems. Wenn sich der Aufrufer beispielsweise in derselben Assembly befindet, benötigt der Aufrufer keine besonderen Berechtigungen für interne Member. Andernfalls benötigt der Aufrufer ReflectionPermission . Dies ist konsistent mit der Suche nach membern, die geschützt, privat und so weiter sind.

Das allgemeine Prinzip ist, dass nur sich ausweitende Konvertierungen ausführen ChangeType sollten, die niemals Daten verlieren. Ein Beispiel für eine sich ausweitende Konvertierung ist die Konvertierung eines Werts, der eine 32-Bit-Ganzzahl mit Vorzeichen ist, in einen Wert, der eine 64-Bit-Ganzzahl mit Vorzeichen ist. Dies unterscheidet sich von einer schmalen Konvertierung, bei der Daten verloren geht. Ein Beispiel für eine schmale Konvertierung ist die Konvertierung einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen.

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

Quellentyp	Zieltyp
Beliebiger Typ	Der Basistyp.
Beliebiger Typ	Die Schnittstelle, die implementiert wird.
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
Kein Verweis	Als Verweis.

Siehe auch

• Binder