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

Definizione

Ottiene un riferimento al binder predefinito, il quale implementa regole interne per la selezione dei membri appropriati che devono essere chiamati con il metodo 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

Valore della proprietà

Riferimento al binder predefinito usato dal sistema.A reference to the default binder used by the system.

Esempi

Nell'esempio seguente viene ottenuto il binder predefinito dalla DefaultBinder proprietà e viene richiamato un membro di MyClass passando il DefaultBinder valore come parametro a 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

Commenti

Il binder predefinito fornito con la Common Language Runtime è applicabile in tutte le circostanze, tranne quelle più specializzate.The default binder provided with the common language runtime is applicable in all but the most specialized circumstances. Se è necessario un gestore di associazione che segue regole che differiscono da quelle del binder predefinito specificato, definire un tipo derivato Binder dalla classe e passare un'istanza di tale tipo utilizzando binder il InvokeMember parametro di uno degli overload.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.

Modelli di Reflection le regole di accessibilità del Common Type System.Reflection models the accessibility rules of the common type system. Se, ad esempio, il chiamante si trova nello stesso assembly, il chiamante non necessita di autorizzazioni speciali per i membri interni.For example, if the caller is in the same assembly, the caller does not need special permissions for internal members. In caso contrario, il ReflectionPermissionchiamante deve avere.Otherwise, the caller needs ReflectionPermission. Questo è coerente con la ricerca di membri protetti, privati e così via.This is consistent with lookup of members that are protected, private, and so on.

Il principio generale è che ChangeType deve eseguire solo conversioni verso un tipo di dati più grande, che non perdono mai i dati.The general principle is that ChangeType should perform only widening conversions, which never lose data. Un esempio di conversione verso un tipo di conversione più ampio è la conversione di un valore che corrisponde a un intero con segno a 32 bit in un valore che corrisponde a un intero con segno a 64 bit.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. Si distingue da una conversione verso un tipo di dati più piccolo, che potrebbe perdere dati.This is distinguished from a narrowing conversion, which may lose data. Un esempio di conversione verso un tipo di caratteri più piccolo consiste nella conversione di un intero con segno a 64 bit in un intero con segno a 32 bit.An example of a narrowing conversion is converting a 64-bit signed integer to a 32-bit signed integer.

Nella tabella seguente sono elencate le conversioni supportate dal binder predefinito.The following table lists the conversions supported by the default binder.

Tipo di origineSource Type Tipo di destinazioneTarget Type
Qualsiasi tipoAny type Tipo di base.Its base type.
Qualsiasi tipoAny type Interfaccia implementata.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
Non di riferimentoNon-reference Per riferimento.By-reference.

Si applica a

Vedi anche