Type.DefaultBinder Propriété

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

Valeur de propriété

Binder

Référence au binder par défaut utilisé par le système.

Exemples

L’exemple suivant obtient le binder par défaut de la DefaultBinder propriété, puis appelle un membre de MyClass en passant la DefaultBinder valeur en tant que paramètre à 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

Remarques

Le binder par défaut fourni avec le common language runtime s’applique dans toutes les circonstances sauf les plus spécialisées. Si vous avez besoin d’un Binder qui suit des règles qui diffèrent de celles du binder par défaut fourni, définissez un type dérivé de la Binder classe et transmettez une instance de ce type à l’aide du binder paramètre de l’une des InvokeMember surcharges.

La réflexion modélise les règles d’accessibilité du système de type commun. Par exemple, si l’appelant est dans le même assembly, l’appelant n’a pas besoin d’autorisations spéciales pour les membres internes. Dans le cas contraire, l’appelant a besoin de ReflectionPermission . Cela est cohérent avec la recherche de membres qui sont protégés, privés, etc.

Le principe général est que ne ChangeType doit exécuter que des conversions étendues, qui ne perdent jamais de données. La conversion d’une valeur qui est un entier signé 32 bits en valeur qui est un entier signé 64 bits est un exemple de conversion étendue. Cela se distingue d’une conversion restrictive, qui peut entraîner la perte de données. Un exemple de conversion restrictive consiste à convertir un entier signé 64 bits en entier signé 32 bits.

Le tableau suivant répertorie les conversions prises en charge par le binder par défaut.

S’applique à

Voir aussi

• Binder