Type.DefaultBinder Type.DefaultBinder Type.DefaultBinder Type.DefaultBinder Property

Definition

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.Gets a reference to the default binder, which implements internal rules for selecting the appropriate members to be called by InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).

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

Ein Verweis auf den vom System verwendeten Standardbinder.A reference to the default binder used by the system.

Beispiele

Im folgenden Beispiel wird der Standard Binder aus der DefaultBinder -Eigenschaft abgerufen und ein Member von MyClass aufgerufen, indem DefaultBinder der-Wert als Parameter InvokeMemberan übergeben wird.The following example gets the default binder from the DefaultBinder property, and invokes a member of MyClass by passing the DefaultBinder value as a parameter to 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");
        }	
    }
}
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 Standard Binder, der mit dem Common Language Runtime bereitgestellt wird, gilt nur für die spezielleren Umstände.The default binder provided with the common language runtime is applicable in all but the most specialized circumstances. Wenn Sie einen Binder benötigen, der auf Regeln folgt, die sich von denen des bereitgestellten Standard Binders unterscheiden, definieren Binder Sie einen von der-Klasse abgeleiteten Typ, binder und übergeben Sie mithilfe des InvokeMember -Parameters einer der-über Ladungen eine Instanz dieses Typs.If you need a binder that follows rules that differ from those of the supplied default binder, define a type derived from the Binder class and pass an instance of that type using the binder parameter of one of the InvokeMember overloads.

Reflektion modelliert die Zugriffsregeln für das allgemeine Typsystem.Reflection models the accessibility rules of the common type system. Wenn sich der Aufrufer z. b. in derselben Assembly befindet, benötigt der Aufrufer keine speziellen Berechtigungen für interne Member.For example, if the caller is in the same assembly, the caller does not need special permissions for internal members. Andernfalls benötigt ReflectionPermissionder Aufrufer.Otherwise, the caller needs ReflectionPermission. Dies entspricht der Suche nach Elementen, die geschützt, privat sind usw.This is consistent with lookup of members that are protected, private, and so on.

Das allgemeine Prinzip ist, ChangeType dass nur erweiternde Konvertierungen durchführen soll, bei denen Daten niemals verloren gehen.The general principle is that ChangeType should perform only widening conversions, which never lose data. Ein Beispiel für eine erweiternde Konvertierung ist das Konvertieren eines Werts, bei dem es sich um eine 32-Bit-Ganzzahl mit Vorzeichen handelt, in einen Wert, bei dem es sich um eine 64An example of a widening conversion is converting a value that is a 32-bit signed integer to a value that is a 64-bit signed integer. Dies unterscheidet sich von einer einschränkenden Konvertierung, bei der Daten verloren gehen können.This is distinguished from a narrowing conversion, which may lose data. Ein Beispiel für eine einschränkende Konvertierung ist das Konvertieren einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen.An example of a narrowing conversion is converting a 64-bit signed integer to a 32-bit signed integer.

In der folgenden Tabelle sind die Konvertierungen aufgeführt, die vom Standard Binder unterstützt werden.The following table lists the conversions supported by the default binder.

QuelltypSource Type ZieltypTarget Type
Beliebiger TypAny type Der Basistyp.Its base type.
Beliebiger TypAny type Die Schnittstelle, die implementiert wird.The interface it implements.
CharChar Unt16, UInt32, Int32, UInt64, Int64, Single, DoubleUnt16, UInt32, Int32, UInt64, Int64, Single, Double
ByteByte Char, Unt16, Int16, UInt32, Int32, UInt64, Int64, Single, DoubleChar, Unt16, Int16, UInt32, Int32, UInt64, Int64, Single, Double
SByteSByte Int16, Int32, Int64, Single, DoubleInt16, Int32, Int64, Single, Double
UInt16UInt16 UInt32, Int32, UInt64, Int64, Single, DoubleUInt32, Int32, UInt64, Int64, Single, Double
Int16Int16 Int32, Int64, Single, DoubleInt32, Int64, Single, Double
UInt32UInt32 UInt64, Int64, Single, DoubleUInt64, Int64, Single, Double
Int32Int32 Int64, Single, DoubleInt64, Single, Double
UInt64UInt64 Single, DoubleSingle, Double
Int64Int64 Single, DoubleSingle, Double
SingleSingle DoubleDouble
Nicht VerweisNon-reference Nach Verweis.By-reference.

Gilt für:

Siehe auch