Utilisation du type dynamic (Guide de programmation C#)Using type dynamic (C# Programming Guide)

C# 4 introduit un nouveau type, dynamic.C# 4 introduces a new type, dynamic. Il s’agit d’un type statique ; toutefois, un objet de type dynamic ignore la vérification des types statiques.The type is a static type, but an object of type dynamic bypasses static type checking. Dans la plupart des cas, il fonctionne comme s’il était de type object.In most cases, it functions like it has type object. Au moment de la compilation, un élément de type dynamic est supposé prendre en charge n’importe quelle opération.At compile time, an element that is typed as dynamic is assumed to support any operation. Par conséquent, vous n’avez pas besoin de vous demander si l’objet obtient sa valeur d’une API COM, d’un langage dynamique tel qu’IronPython, du modèle DOM (Document Object Model) HTML, de la réflexion ou d’une autre partie du programme.Therefore, you do not have to be concerned about whether the object gets its value from a COM API, from a dynamic language such as IronPython, from the HTML Document Object Model (DOM), from reflection, or from somewhere else in the program. Toutefois, si le code n’est pas valide, des erreurs sont détectées au moment de l’exécution.However, if the code is not valid, errors are caught at run time.

Par exemple, si la méthode d’instance exampleMethod1 du code suivant ne comporte qu’un seul paramètre, le compilateur reconnaît que le premier appel à la méthode, ec.exampleMethod1(10, 4), n’est pas valide car il contient deux arguments.For example, if instance method exampleMethod1 in the following code has only one parameter, the compiler recognizes that the first call to the method, ec.exampleMethod1(10, 4), is not valid because it contains two arguments. Cet appel entraîne une erreur du compilateur.The call causes a compiler error. Le deuxième appel à la méthode, dynamic_ec.exampleMethod1(10, 4), n’est pas vérifié par le compilateur, car le type de dynamic_ec est dynamic.The second call to the method, dynamic_ec.exampleMethod1(10, 4), is not checked by the compiler because the type of dynamic_ec is dynamic. Par conséquent, aucune erreur de compilateur n’est signalée.Therefore, no compiler error is reported. Toutefois, l’erreur ne passe pas indéfiniment inaperçue.However, the error does not escape notice indefinitely. Elle est détectée au moment de l’exécution et provoque une exception runtime.It is caught at run time and causes a run-time exception.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following call to exampleMethod1 causes a compiler error 
    // if exampleMethod1 has only one parameter. Uncomment the line
    // to see the error.
    //ec.exampleMethod1(10, 4);

    dynamic dynamic_ec = new ExampleClass();
    // The following line is not identified as an error by the
    // compiler, but it causes a run-time exception.
    dynamic_ec.exampleMethod1(10, 4);

    // The following calls also do not cause compiler errors, whether 
    // appropriate methods exist or not.
    dynamic_ec.someMethod("some argument", 7, null);
    dynamic_ec.nonexistentMethod();
}
class ExampleClass
{
    public ExampleClass() { }
    public ExampleClass(int v) { }

    public void exampleMethod1(int i) { }

    public void exampleMethod2(string str) { }
}

Dans ces exemples, le rôle du compilateur consiste à regrouper les informations relatives à l’opération que chaque instruction propose d’exécuter sur l’objet ou l’expression de type dynamic.The role of the compiler in these examples is to package together information about what each statement is proposing to do to the object or expression that is typed as dynamic. Au moment de l’exécution, les informations stockées sont examinées, et toute instruction non valide provoque une exception runtime.At run time, the stored information is examined, and any statement that is not valid causes a run-time exception.

Le résultat de la plupart des opérations dynamiques est lui-même de type dynamic.The result of most dynamic operations is itself dynamic. Par exemple, si vous placez le pointeur de la souris sur testSum dans l’exemple suivant, IntelliSense affiche le type (variable locale) dynamic testSum.For example, if you rest the mouse pointer over the use of testSum in the following example, IntelliSense displays the type (local variable) dynamic testSum.

dynamic d = 1;
var testSum = d + 3;
// Rest the mouse pointer over testSum in the following statement.
System.Console.WriteLine(testSum);

Les opérations dans lesquelles le résultat n’est pas dynamic incluent :Operations in which the result is not dynamic include:

  • Les conversions de dynamic vers un autre type.Conversions from dynamic to another type.
  • Les appels de constructeur qui incluent des arguments de type dynamic.Constructor calls that include arguments of type dynamic.

Par exemple, le type de testInstance dans la déclaration suivante est ExampleClass, et non pas dynamic :For example, the type of testInstance in the following declaration is ExampleClass, not dynamic:

var testInstance = new ExampleClass(d);

Des exemples de conversion sont présentés dans la section suivante, "Conversions".Conversion examples are shown in the following section, "Conversions."

ConversionsConversions

Les conversions entre des objets dynamiques et d’autres types sont faciles à exécuter.Conversions between dynamic objects and other types are easy. Les développeurs peuvent ainsi passer du comportement dynamique au comportement non dynamique, et vice versa.This enables the developer to switch between dynamic and non-dynamic behavior.

Tout objet peut être converti implicitement en type dynamique, comme illustré dans les exemples suivants.Any object can be converted to dynamic type implicitly, as shown in the following examples.

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

Inversement, une conversion implicite peut être appliquée de façon dynamique à toute expression de type dynamic.Conversely, an implicit conversion can be dynamically applied to any expression of type dynamic.

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

Résolution de surcharge avec des arguments de type dynamicOverload resolution with arguments of type dynamic

La résolution de surcharge a lieu au moment de l’exécution, et non pas au moment de la compilation, si un ou plusieurs arguments d’un appel de méthode sont de type dynamic, ou si le récepteur de l’appel de méthode est de type dynamic.Overload resolution occurs at run time instead of at compile time if one or more of the arguments in a method call have the type dynamic, or if the receiver of the method call is of type dynamic. Dans l’exemple suivant, si la seule méthode exampleMethod2 accessible est définie pour accepter un argument de chaîne, l’envoi de d1 en tant qu’argument n’entraîne pas d’erreur du compilateur, mais provoque une exception runtime.In the following example, if the only accessible exampleMethod2 method is defined to take a string argument, sending d1 as the argument does not cause a compiler error, but it does cause a run-time exception. La résolution de surcharge échoue au moment de l’exécution car le type de d1 est int, et exampleMethod2 exige une chaîne.Overload resolution fails at run time because the run-time type of d1 is int, and exampleMethod2 requires a string.

// Valid.
ec.exampleMethod2("a string");

// The following statement does not cause a compiler error, even though ec is not
// dynamic. A run-time exception is raised because the run-time type of d1 is int.
ec.exampleMethod2(d1);
// The following statement does cause a compiler error.
//ec.exampleMethod2(7);

Dynamic Language RuntimeDynamic language runtime

Le composant Dynamic Language Runtime (DLR) est une nouvelle API de .NET Framework 4.The dynamic language runtime (DLR) is a new API in .NET Framework 4. Il fournit l’infrastructure qui prend en charge le type dynamic en C#, ainsi que l’implémentation des langages de programmation dynamique tels qu’IronPython et IronRuby.It provides the infrastructure that supports the dynamic type in C#, and also the implementation of dynamic programming languages such as IronPython and IronRuby. Pour plus d’informations sur le DLR, consultez Vue d’ensemble du Dynamic Language Runtime.For more information about the DLR, see Dynamic Language Runtime Overview.

COM interopCOM interop

C# 4 inclut plusieurs fonctionnalités qui améliorent l’interopérabilité avec les API COM telles que les API Office Automation.C# 4 includes several features that improve the experience of interoperating with COM APIs such as the Office Automation APIs. L’utilisation du type dynamic et des arguments nommés et facultatifs fait partie des améliorations offertes.Among the improvements are the use of the dynamic type, and of named and optional arguments.

De nombreuses méthodes COM autorisent une variation des types d’arguments et du type de retour en désignant les types comme object.Many COM methods allow for variation in argument types and return type by designating the types as object. Cela a nécessité un cast explicite des valeurs pour la coordination avec les variables fortement typées en C#.This has necessitated explicit casting of the values to coordinate with strongly typed variables in C#. Si vous compilez à l’aide de l’option -Link (C# options du compilateur) , l’introduction du type de dynamic vous permet de traiter les occurrences de object dans les signatures com comme si elles étaient de type dynamic, et donc d’éviter une grande partie du cast.If you compile by using the -link (C# Compiler Options) option, the introduction of the dynamic type enables you to treat the occurrences of object in COM signatures as if they were of type dynamic, and thereby to avoid much of the casting. Par exemple, les instructions suivantes permettent de comparer la façon dont vous accédez à une cellule d’une feuille de calcul Microsoft Office Excel avec le type dynamic et sans le type dynamic.For example, the following statements contrast how you access a cell in a Microsoft Office Excel spreadsheet with the dynamic type and without the dynamic type.

// Before the introduction of dynamic.
((Excel.Range)excelApp.Cells[1, 1]).Value2 = "Name";
Excel.Range range2008 = (Excel.Range)excelApp.Cells[1, 1];
// After the introduction of dynamic, the access to the Value property and
// the conversion to Excel.Range are handled by the run-time COM binder.
excelApp.Cells[1, 1].Value = "Name";
Excel.Range range2010 = excelApp.Cells[1, 1];
TitreTitle DescriptionDescription
dynamicdynamic Décrit l’utilisation du mot clé dynamic.Describes the usage of the dynamic keyword.
Vue d’ensemble du Dynamic Language RuntimeDynamic Language Runtime Overview Fournit une vue d’ensemble du DLR, qui est un environnement d’exécution ajoutant au Common Language Runtime (CLR) un ensemble de services pour les langages dynamiques.Provides an overview of the DLR, which is a runtime environment that adds a set of services for dynamic languages to the common language runtime (CLR).
Procédure pas à pas : création et utilisation d’objets dynamiquesWalkthrough: Creating and Using Dynamic Objects Fournit des instructions pas à pas pour la création d’un objet dynamique personnalisé et pour la création d’un projet qui accède à une bibliothèque IronPython.Provides step-by-step instructions for creating a custom dynamic object and for creating a project that accesses an IronPython library.
Guide pratique pour accéder aux objets Office Interop à l’aide des fonctionnalités Visual C#How to: Access Office Interop Objects by Using Visual C# Features Montre comment créer un projet qui utilise les arguments nommés et facultatifs, le type dynamic et d’autres améliorations qui simplifient l’accès aux objets d’API Office.Demonstrates how to create a project that uses named and optional arguments, the dynamic type, and other enhancements that simplify access to Office API objects.