dynamic (Référence C#)

Article
08/10/2011

Le type dynamic permet les opérations dans lesquelles il ignore la vérification de type de compilation. À la place, ces opérations sont résolues au moment de l'exécution. Le type dynamic simplifie l'accès aux API COM telles que les API d'Automation d'Office, et également aux API dynamiques telles que les bibliothèques IronPython et au DOM (Document Object Model) HTML.

Le type dynamic se comporte comme le type object dans la plupart des circonstances. Toutefois, les opérations qui contiennent des expressions de type dynamic ne sont pas résolues ou le type est vérifié par le compilateur. Le compilateur crée un package des informations concernant l'opération. Ces informations sont utilisées ultérieurement pour évaluer l'opération au moment de l'exécution. Dans le cadre du processus, les variables de type dynamic sont compilées dans les variables de type object. Par conséquent, le type dynamic existe uniquement au moment de la compilation, pas au moment de l'exécution.

L'exemple suivant compare une variable de type dynamic à une variable de type object. Pour vérifier le type de chaque variable au moment de la compilation, placez le pointeur de la souris sur dyn ou obj dans les instructions WriteLine. IntelliSense affiche dynamique pour dyn et objet pour obj.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

Les instructions WriteLine affichent les types d'exécution de dyn et obj. À ce stade, les deux ont le même type, entier. La sortie suivante est produite :

System.Int32

Pour voir la différence entre dyn et obj au moment de la compilation, ajoutez les deux lignes suivantes entre les déclarations et les instructions WriteLine de l'exemple précédent.

dyn = dyn + 3;
obj = obj + 3;

Une erreur du compilateur est signalée pour l'ajout tentée d'un entier et un objet dans l'expression obj + 3. Toutefois, aucune erreur n'est signalée pour dyn + 3. L'expression qui contient dyn n'est pas vérifiée au moment de la compilation parce que le type de dyn est dynamic.

Contexte

Le mot clé dynamic peut s'afficher directement ou comme un composant d'un type construit dans les situations suivantes :

Dans les déclarations, comme le type d'une propriété, d'un champ, d'un indexeur, d'un paramètre, d'une valeur de retour, d'une variable locale ou d'une contrainte de type. La définition de classe suivante utilise dynamic dans plusieurs déclarations différentes.

class ExampleClass
{
    // A dynamic field.
    static dynamic field;

    // A dynamic property.
    dynamic prop { get; set; }

    // A dynamic return type and a dynamic paramater type.
    public dynamic exampleMethod(dynamic d)
    {
        // A dynamic local variable.
        dynamic local = "Local variable";
        int two = 2;

        if (d is int)
        {
            return local;
        }
        else
        {
            return two;
        }
    }
}

Dans les conversions de type explicites, comme le type de cible d'une conversion.

static void convertToDynamic()
{
    dynamic d;
    int i = 20;
    d = (dynamic)i;
    Console.WriteLine(d);

    string s = "Example string.";
    d = (dynamic)s;
    Console.WriteLine(d);

    DateTime dt = DateTime.Today;
    d = (dynamic)dt;
    Console.WriteLine(d);

}
// Results:
// 20
// Example string.
// 2/17/2009 9:12:00 AM

Dans tout contexte où les types servent comme valeurs, comme sur le côté droit d'un opérateur is ou d'un opérateur as ou comme pour l'argument à typeof dans le cadre d'un type construit. Par exemple, dynamic peut être utilisé dans les expressions suivantes.

int i = 8;
dynamic d;
// With the is operator.
// The dynamic type behaves like object. The following
// expression returns true unless someVar has the value null.
if (someVar is dynamic) { }

// With the as operator.
d = i as dynamic;

// With typeof, as part of a constructed type.
Console.WriteLine(typeof(List<dynamic>));

// The following statement causes a compiler error.
//Console.WriteLine(typeof(dynamic));

Exemple

L'exemple suivant utilise dynamic dans plusieurs déclarations. La méthode Main compare également la vérification de type de compilation avec la vérification de type d'exécution.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.exampleMethod(10));
            Console.WriteLine(ec.exampleMethod("value"));

            // The following line causes a compiler error because exampleMethod
            // takes only one argument.
            //Console.WriteLine(ec.exampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.exampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to exampleMethod
            // with two arguments does not produce an error at compile time.
            // However, itdoes cause a run-time error. 
            //Console.WriteLine(dynamic_ec.exampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic field;
        dynamic prop { get; set; }

        public dynamic exampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results:
// Local variable
// 2
// Local variable

Pour plus d'informations et d'exemples, consultez Utilisation du type dynamic (Guide de programmation C#).

Voir aussi

Partager via

dynamic (Référence C#)

Contexte

Exemple

Voir aussi

Tâches

Référence

Autres ressources

Ressources supplémentaires