Type.DefaultBinder Propriedade

Definição

Obtém uma referência ao associador padrão, que implementa regras internas para selecionar os membros adequados a serem chamados por 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; }
static member DefaultBinder : System.Reflection.Binder
Public Shared ReadOnly Property DefaultBinder As Binder

Valor da propriedade

Binder

Uma referência ao associador padrão usado pelo sistema.

Exemplos

O exemplo a seguir obtém o associador padrão da DefaultBinder propriedade e invoca um membro de MyClass passando o DefaultBinder valor como um parâmetro para 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");
        }	
    }
}
open System
open System.Reflection

type MyClass() =
    member _.HelloWorld() =
        printfn "Hello World"

try
    let defaultBinder = Type.DefaultBinder
    let myClass = MyClass()
    // Invoke the HelloWorld method of MyClass.
    myClass.GetType().InvokeMember("HelloWorld", BindingFlags.InvokeMethod, defaultBinder, myClass, [||])
    |> ignore
with e ->
    printfn $"Exception: {e.Message}"
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

Comentários

O associador padrão fornecido com o Common Language Runtime é aplicável em todas as circunstâncias menos especializadas. Se você precisar de um associador que siga regras que diferem das do associador padrão fornecido, defina um tipo derivado da Binder classe e passe uma instância desse tipo usando o binder parâmetro de uma das InvokeMember sobrecargas.

A reflexão modela as regras de acessibilidade do sistema de tipos comuns. Por exemplo, se o chamador estiver no mesmo assembly, o chamador não precisará de permissões especiais para membros internos. Caso contrário, o chamador precisará ReflectionPermissionde . Isso é consistente com a pesquisa de membros protegidos, privados e assim por diante.

O princípio geral é que ChangeType deve executar apenas conversões de expansão, que nunca perdem dados. Um exemplo de uma conversão de expansão é converter um valor que é um inteiro com sinal de 32 bits em um valor que é um inteiro com sinal de 64 bits. Isso é diferenciado de uma conversão de restrição, que pode perder dados. Um exemplo de conversão de restrição é converter um inteiro com sinal de 64 bits em um inteiro com sinal de 32 bits.

A tabela a seguir lista as conversões compatíveis com o associador padrão.

Tipo de Fonte Tipo de destino
Qualquer tipo Seu tipo base.
Qualquer tipo A interface que ela implementa.
Char Unt16, UInt32, Int32, UInt64, Int64, Single, Double
Byte Char, Unt16, Int16, UInt32, Int32, UInt64, Int64, Single, Double
SByte Int16, Int32, Int64, Single e Double
UInt16 UInt32, Int32, UInt64, Int64, Single e Double
Int16 Int32, Int64, Single e Double
UInt32 UInt64, Int64, Single e Double
Int32 Int64, Single e Double
UInt64 Single e Double
Int64 Single e Double
Single Double
Não referência Por referência.

Aplica-se a

Confira também