Type.DefaultBinder Propriété

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Obtient une référence au binder par défaut, qui implémente les règles internes pour la sélection des membres appropriés appelés par 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

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.

Type de source	Type de cible
Tout type	Son type de base.
Tout type	Interface qu’il implémente.
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
Unique	Double
Non-référence	Par référence.

Voir aussi

• Binder