Type.DefaultBinder Vlastnost

Definice

Získá odkaz na výchozí pořadač, který implementuje interní pravidla pro výběr příslušných členů, které mají být volány InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) .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

Hodnota vlastnosti

Binder

Odkaz na výchozí pořadač používaný systémem.A reference to the default binder used by the system.

Příklady

Následující příklad získá výchozí pořadač z DefaultBinder vlastnosti a vyvolá člena MyClass předáním DefaultBinder hodnoty jako parametru do InvokeMember .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

Poznámky

Výchozí pořadač poskytovaný s modulem CLR (Common Language Runtime) platí ve všech případech, kromě těch, které jsou to nejvíce specializované.The default binder provided with the common language runtime is applicable in all but the most specialized circumstances. Pokud potřebujete pořadač, který následuje pravidla, která se liší od těch, které jsou uvedeny v zadaném výchozím pořadači, Definujte typ odvozený od Binder třídy a předejte instanci tohoto typu pomocí binder parametru jednoho z InvokeMember přetížení.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.

Modely reflexe jsou pravidla přístupnosti společného systému typů.Reflection models the accessibility rules of the common type system. Například pokud je volající ve stejném sestavení, volající nepotřebuje zvláštní oprávnění pro interní členy.For example, if the caller is in the same assembly, the caller does not need special permissions for internal members. V opačném případě volající vyžaduje ReflectionPermission .Otherwise, the caller needs ReflectionPermission. To je konzistentní s vyhledáváním členů, kteří jsou chráněni, soukromá a tak dále.This is consistent with lookup of members that are protected, private, and so on.

Obecnou zásadou je, že ChangeType by se měly provádět pouze rozšiřující převody, které nikdy neztrácejí data.The general principle is that ChangeType should perform only widening conversions, which never lose data. Příkladem rozšiřujícího převodu je převod hodnoty, která je 32 celé číslo se znaménkem na hodnotu, která je 64 celé číslo se znaménkem.An 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. To se odlišuje od zužujícího převodu, který může přijít o data.This is distinguished from a narrowing conversion, which may lose data. Příkladem zužujícího převodu je převedené celé číslo se znaménkem 64 na 32 bitové číslo se znaménkem.An example of a narrowing conversion is converting a 64-bit signed integer to a 32-bit signed integer.

V následující tabulce jsou uvedeny převody podporované výchozím pořadačem.The following table lists the conversions supported by the default binder.

Typ zdrojeSource Type Cílový typTarget Type
Libovolný typAny type Jeho základní typ.Its base type.
Libovolný typAny type Rozhraní, které implementuje.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 Jednoduchá, DvojitáSingle, Double
Int64Int64 Jednoduchá, DvojitáSingle, Double
JednoduchéSingle dvojitéDouble
Bez odkazuNon-reference Podle odkazu.By-reference.

Platí pro

Viz také