dynamic (Riferimenti per C#)

Articolo
08/11/2011

Il tipo dynamic abilita le operazioni nelle quali il controllo dei tipi in fase di compilazione viene ignorato. Queste operazioni vengono invece risolte in fase di esecuzione. Il tipo dynamic semplifica l'accesso alle API COM, quali le API di automazione di Office, alle API dinamiche, quali le librerie IronPython, e al modello DOM (Document Object Model) HTML.

Il tipo dynamic si comporta come tipo object nella maggior parte delle circostanze. Le operazioni che contengono espressioni di tipo dynamic tuttavia non vengono risolte o sono sottoposte a controllo del tipo da parte del compilatore. Il compilatore raggruppa le informazioni sull'operazione e tali informazioni vengono utilizzate in un secondo momento per valutare l'operazione in fase di esecuzione. Come parte del processo, le variabili del tipo dynamic vengono compilate in variabili di tipo object. Il tipo dynamic esiste quindi solo in fase di compilazione, non in fase di esecuzione.

Nell'esempio che segue, la variabile di tipo dynamic viene messa a confronto con una variabile di tipo object. Per verificare il tipo di ciascuna variabile in fase di compilazione, posizionare il puntatore del mouse su dyn o obj nelle istruzioni WriteLine. IntelliSense mostra dynamic per dyn e object per 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());
    }
}

Le istruzioni WriteLine visualizzano i tipi di runtime di dyn e obj. A quel punto, entrambi hanno lo stesso tipo, numero intero. Il risultato è il seguente:

System.Int32

Per vedere in fase di compilazione la differenza tra dyn e obj, aggiungere le due righe seguenti tra le dichiarazioni e le istruzioni WriteLine nell'esempio precedente.

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

Viene segnalato un errore del compilatore per il tentativo di aggiunta di un numero intero e di un oggetto in un'espressione obj + 3. Tuttavia, non è stato segnalato alcun errore per dyn + 3. L'espressione che contiene dyn non viene controllata in fase di compilazione perché il tipo di dyn è dynamic.

Contesto

La parola chiave dynamic può essere visualizzata direttamente o come componente di un tipo costruito nelle situazioni seguenti:

Nelle dichiarazioni, come tipo di una proprietà, campo, indicizzatore, parametro, valore restituito, variabile locale o vincolo di tipo. Nella definizione della classe seguente viene utilizzato dynamic in molte dichiarazioni diverse.

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;
        }
    }
}

In conversioni esplicite del tipo, come tipo di destinazione di una conversione.

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

In ogni contesto in cui i tipi vengono utilizzati come valori, come sul lato destro dell'operatore is o dell'operatore as, o come argomento a typeof come parte di un tipo costruito. Ad esempio, nelle seguenti espressioni è possibile utilizzare dynamic.

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));

Esempio

Nell'esempio seguente viene utilizzato dynamic in molte dichiarazioni. Il metodo Main contrappone anche il controllo dei tipi in fase di compilazione con il controllo dei tipi in fase di esecuzione.

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

Per ulteriori informazioni ed esempi, vedere Utilizzo del tipo dinamico (Guida per programmatori C#).

Vedere anche

Condividi tramite

dynamic (Riferimenti per C#)

Contesto

Esempio

Vedere anche

Attività

Riferimenti

Altre risorse

Risorse aggiuntive