Condividi tramite


Type.DefaultBinder Proprietà

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[]).

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à

Binder

Riferimento al binder predefinito usato dal sistema.

Esempio

L'esempio seguente ottiene il gestore di associazione predefinito dalla proprietà e richiama un membro di MyClass passando il DefaultBinder valore come parametro a DefaultBinder 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 Common Language Runtime è applicabile in tutte le circostanze, ma nelle circostanze più specializzate. Se è necessario uno strumento di associazione che segue regole diverse da quelle dello strumento di associazione predefinito fornito, definire un tipo derivato dalla classe e passare un'istanza di tale tipo usando il parametro di uno degli Binder binder overload InvokeMember .

La reflection modella le regole di accessibilità del sistema di tipi comune. Ad esempio, se il chiamante si trova nello stesso assembly, il chiamante non richiede autorizzazioni speciali per i membri interni. In caso contrario, il chiamante deve ReflectionPermission avere . Ciò è coerente con la ricerca di membri protetti, privati e così via.

Il principio generale è che deve eseguire solo conversioni verso un tipo di dati più ChangeType grande, che non perdono mai i dati. Un esempio di conversione verso un tipo di dati più grande è la conversione di un valore intero con segno a 32 bit in un valore con segno a 64 bit. Ciò si distingue da una conversione verso un tipo di dati più ristretto, che può causare la perdita di dati. Un esempio di conversione verso un tipo di dati più piccolo è la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit.

Nella tabella seguente sono elencate le conversioni supportate dal binder predefinito.

Tipo di origine Tipo destinazione
Qualsiasi tipo Tipo di base.
Qualsiasi tipo Interfaccia implementata.
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
Non di riferimento Per riferimento.

Si applica a

Vedi anche