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

Valor da propriedade

Uma referência ao associador padrão usado pelo sistema.A reference to the default binder used by the system.

Exemplos

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

Comentários

O associador padrão fornecido com o Common Language Runtime é aplicável em todas as circunstâncias, exceto as mais especializadas.The default binder provided with the common language runtime is applicable in all but the most specialized circumstances. Se você precisar de um fichário que siga as regras que diferem das do fichário padrão fornecido, defina um tipo derivado Binder da classe e passe uma instância desse tipo usando o binder InvokeMember parâmetro de uma das sobrecargas.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.

A reflexão modela as regras de acessibilidade do Common Type System.Reflection models the accessibility rules of the common type system. Por exemplo, se o chamador estiver no mesmo assembly, o chamador não precisará de permissões especiais para membros internos.For example, if the caller is in the same assembly, the caller does not need special permissions for internal members. Caso contrário, o chamador ReflectionPermissionprecisará.Otherwise, the caller needs ReflectionPermission. Isso é consistente com a pesquisa de membros protegidos, privados e assim por diante.This is consistent with lookup of members that are protected, private, and so on.

O princípio geral é que ChangeType o deve executar apenas conversões ampliadoras, que nunca perdem dados.The general principle is that ChangeType should perform only widening conversions, which never lose data. Um exemplo de uma conversão de ampliação é converter um valor que é um inteiro assinado de 32 bits para um valor que é um inteiro com sinal de 64 bits.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. Isso é diferenciado de uma conversão de restrição, que pode perder dados.This is distinguished from a narrowing conversion, which may lose data. Um exemplo de uma conversão de restrição é a conversão de um inteiro assinado de 64 bits para um inteiro com sinal de 32 bits.An example of a narrowing conversion is converting a 64-bit signed integer to a 32-bit signed integer.

A tabela a seguir lista as conversões com suporte no fichário padrão.The following table lists the conversions supported by the default binder.

Tipo de origemSource Type Tipo de destinoTarget Type
Qualquer tipoAny type Seu tipo base.Its base type.
Qualquer tipoAny type A interface que ele implementa.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 e DoubleChar, Unt16, Int16, UInt32, Int32, UInt64, Int64, Single, Double
SByteSByte Int16, Int32, Int64, Single e DoubleInt16, Int32, Int64, Single, Double
UInt16UInt16 UInt32, Int32, UInt64, Int64, Single e DoubleUInt32, Int32, UInt64, Int64, Single, Double
Int16Int16 Int32, Int64, Single e DoubleInt32, Int64, Single, Double
UInt32UInt32 UInt64, Int64, Single e DoubleUInt64, Int64, Single, Double
Int32Int32 Int64, Single e DoubleInt64, Single, Double
UInt64UInt64 Single e DoubleSingle, Double
Int64Int64 Single e DoubleSingle, Double
SimplesSingle DuploDouble
Não referênciaNon-reference Por referência.By-reference.

Aplica-se a

Veja também