Utilizzo del tipo dinamico (Guida per programmatori C#)Using type dynamic (C# Programming Guide)

C# 4 introduce un nuovo tipo, dynamic.C# 4 introduces a new type, dynamic. Il tipo è statico, ma un oggetto di tipo dynamic ignora il controllo del tipo statico.The type is a static type, but an object of type dynamic bypasses static type checking. Nella maggior parte dei casi, funziona come se disponesse del tipo object.In most cases, it functions like it has type object. In fase di compilazione, si presume che un elemento tipizzato come dynamicdynamic supporti qualsiasi operazione.At compile time, an element that is typed as dynamic is assumed to support any operation. Non è pertanto importante se l'oggetto ottiene il valore da un'API COM, da un linguaggio dinamico quale IronPython, dal modello DOM (Document Object Model) HTML, dalla reflection o da un altro elemento del programma.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. Se, tuttavia, il codice non è valido, vengono intercettati errori in fase di esecuzione.However, if the code is not valid, errors are caught at run time.

Se, ad esempio, il metodo di istanza exampleMethod1 nel codice seguente dispone di un solo parametro, il compilatore riconosce che la prima chiamata al metodo, ec.exampleMethod1(10, 4), non è valida perché contiene due argomenti.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. La chiamata genera errori di compilazione.The call causes a compiler error. La seconda chiamata al metodo, dynamic_ec.exampleMethod1(10, 4), non viene controllata dal compilatore poiché il tipo di dynamic_ec è 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. Non viene, pertanto, segnalato alcun errore del compilatore.Therefore, no compiler error is reported. L'errore, tuttavia, non viene ignorato indefinitamente.However, the error does not escape notice indefinitely. Viene intercettato in fase di esecuzione e provoca un'eccezione in fase di esecuzione.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) { }
}

Il ruolo del compilatore in questi esempi consiste nel raggruppare le informazioni sull'operazione prevista da ogni istruzione in relazione all'oggetto o all'espressione tipizzata come 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. In fase di esecuzione, le informazioni archiviate vengono esaminate e qualsiasi istruzione non valida provoca un'eccezione in fase di esecuzione.At run time, the stored information is examined, and any statement that is not valid causes a run-time exception.

Il risultato della maggior parte delle operazioni dinamiche è dynamic.The result of most dynamic operations is itself dynamic. Se, ad esempio, si posiziona il puntatore del mouse sull'utilizzo di testSum nell'esempio seguente, IntelliSense visualizza il tipo (variabile 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);

Le operazioni in cui il risultato non è dynamic includono:Operations in which the result is not dynamic include:

  • Le conversioni da dynamic a un altro tipo.Conversions from dynamic to another type.
  • Le chiamate al costruttore che includono argomenti di tipo dynamic.Constructor calls that include arguments of type dynamic.

Il tipo di testInstance, ad esempio, nella dichiarazione seguente è ExampleClass, non dynamic:For example, the type of testInstance in the following declaration is ExampleClass, not dynamic:

var testInstance = new ExampleClass(d);

Esempi di conversione sono illustrati nella sezione seguente, "Conversioni".Conversion examples are shown in the following section, "Conversions."

ConversioniConversions

Le conversioni tra oggetti dinamici e altri tipi sono facili.Conversions between dynamic objects and other types are easy. In questo modo lo sviluppatore può passare dal comportamento dinamico a quello non dinamico e viceversa.This enables the developer to switch between dynamic and non-dynamic behavior.

Ogni oggetto può essere convertito in tipo dinamico in modo implicito, come illustrato negli esempi seguenti.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();

Al contrario, una conversione implicita può essere applicata in modo dinamico a qualsiasi espressione di tipo 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;

Risoluzione dell'overload con argomenti di tipo dinamicoOverload resolution with arguments of type dynamic

La risoluzione dell'overload si verifica in fase di esecuzione anziché in fase di compilazione se uno o più argomenti in una chiamata al metodo dispongono del tipo dynamic o se il ricevitore della chiamata al metodo è di tipo 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. Nell'esempio seguente, se il solo metodo exampleMethod2 accessibile è definito in modo che accetti un argomento di tipo stringa, l'invio di d1 come argomento non provoca un errore del compilatore, bensì un'eccezione in fase di esecuzione.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 risoluzione dell'overload non riesce in fase di esecuzione perché il tipo in fase di esecuzione di d1 è int e exampleMethod2 richiede una stringa.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

DLR (Dynamic Language Runtime) è una nuova API in .NET Framework 4.The dynamic language runtime (DLR) is a new API in .NET Framework 4. Fornisce l'infrastruttura che supporta il tipo dynamic in C# oltre all'implementazione di linguaggi di programmazione dinamici, quali IronPython e 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. Per altre informazioni su DLR, vedere Dynamic Language Runtime Overview (Panoramica su Dynamic Language Runtime).For more information about the DLR, see Dynamic Language Runtime Overview.

interoperabilità COMCOM interop

C# 4 include diverse funzionalità che migliorano l'esperienza di interoperabilità con le API COM, ad esempio le API di automazione di Office.C# 4 includes several features that improve the experience of interoperating with COM APIs such as the Office Automation APIs. Tra i miglioramenti è compreso l'utilizzo del tipo dynamic e di argomenti denominati e facoltativi.Among the improvements are the use of the dynamic type, and of named and optional arguments.

Diversi metodi COM consentono la variazione nei tipi di argomento e nel tipo restituito designando i tipi come object.Many COM methods allow for variation in argument types and return type by designating the types as object. Per questo motivo è necessario il cast esplicito dei valori per la coordinazione con le variabili fortemente tipizzate in C#.This has necessitated explicit casting of the values to coordinate with strongly typed variables in C#. Se si esegue la compilazione utilizzando l'opzione -C# link (opzioni del compilatore) , l'introduzione del tipo di dynamic consente di gestire le occorrenze di object nelle firme com come se fossero di tipo dynamiced evitare così la maggior parte del 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. Le istruzioni seguenti sono ad esempio in contrasto con la modalità di accesso a una cella in un foglio di calcolo di Microsoft Office Excel con il tipo dynamic e senza il tipo 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];
TitoloTitle DescrizioneDescription
dynamicdynamic Viene descritto l'utilizzo della parola chiave dynamic.Describes the usage of the dynamic keyword.
Dynamic Language Runtime Overview (Panoramica su Dynamic Language Runtime)Dynamic Language Runtime Overview Viene fornita una panoramica di DLR, un ambiente di runtime che estende Common Language Runtime (CLR) con un set di servizi per linguaggi dinamici.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).
Procedura dettagliata: Creazione e utilizzo di oggetti dinamiciWalkthrough: Creating and Using Dynamic Objects Fornisce istruzioni dettagliate per la creazione di un oggetto dinamico personalizzato e per la creazione di un progetto che accede a una libreria IronPython.Provides step-by-step instructions for creating a custom dynamic object and for creating a project that accesses an IronPython library.
Come accedere agli oggetti di interoperabilità C# di Office usando le funzionalitàHow to access Office interop objects by using C# features Viene illustrato come creare un progetto che usa argomenti denominati e facoltativi, il tipo dynamic e altri miglioramenti che semplificano l'accesso agli oggetti API di 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.