Condividi tramite

Il presente articolo è stato tradotto automaticamente.

Cutting Edge

Utilizzo della parola chiave dynamic in C# 4.0

Dino Esposito

Dino EspositoL'introduzione di tipo statico verifica rappresentata un'attività cardine importante nella cronologia di linguaggi di programmazione. Degli anni ' 70, linguaggi quali Pascal e C avviato applicando i tipi statici e controllo del tipo sicuro. Con controllo del tipo statico, il compilatore genererà un errore per qualsiasi chiamata non riesce a passare un argomento del metodo del tipo appropriato. Analogamente, è possibile che un errore di compilazione se si tenta di chiamare un metodo mancante in un'istanza del tipo.

Altri linguaggi push avanti l'approccio opposto, ovvero controllo di tipo dinamico, ovvero derivino nel corso degli anni. Controllo dei tipi dinamici contraddicono l'idea di che tipo di una variabile deve essere determinata in modo statico in fase di compilazione e non può essere modificato mentre la variabile è nell'ambito. Si noti, tuttavia, controllo dei tipi dinamici non conferire libertà all'ingrosso che contengano una combinazione di tipi, supponendo che siano uguali. Ad esempio, anche con controllo del tipo dinamico, ancora non è possibile aggiungere un valore Boolean in un valore integer. La differenza con il controllo di tipo dinamico è che il controllo si verifica quando il programma esegue invece quando compila.

Tipizzato staticamente o dinamicamente tipizzati

In Visual Studio 2010 e C# 4.0 forniscono una nuova parola chiave, dinamica, che consente la tipizzazione dinamica in ciò che è stato tradizionalmente un linguaggio tipizzato in modo statico. Prima di diving into aspetti dinamici di C# 4.0, tuttavia, è necessario ottenere alcune terminologia di base verso il basso.

Definire una variabile Let’s come percorso di memorizzazione è limitato ai valori di un determinato tipo. Successivamente, specificare let’s quattro proprietà fondamentali di un linguaggio tipizzato in modo statico:

  • Ogni espressione è un tipo noto in fase di compilazione.
  • Le variabili sono limitate a un tipo noto in fase di compilazione.
  • Il compilatore garantisce che le restrizioni di tipo sulle assegnazioni di espressioni in variabili soddisfino le restrizioni sulle variabili.
  • Attività di analisi semantica, ad esempio la risoluzione dell'overload, si verificano in fase di compilazione e i risultati sono salvati nell'assembly.

Un linguaggio dinamico dispone di proprietà opposta. Non tutte le espressioni sono di un tipo noto in fase di compilazione, né è ogni variabile. Limiti di archiviazione, se presenti, sono selezionati in fase di esecuzione e ignorati in fase di compilazione. Analisi semantica si verifica solo in fase di esecuzione.

Un linguaggio tipizzato in modo statico è possibile rendere dinamico alcune operazioni. L'operatore cast esiste pertanto è possibile provare a eseguire una conversione del tipo come operazione runtime. La conversione fa parte di codice del programma e può riepilogare la semantica espresso mediante l'operatore cast come “ dinamicamente, verifica la validità di questa conversione in fase di esecuzione ”.

Tuttavia, riguardanti gli attributi, ad esempio dinamico e statico (o forse sicuro e debole): Oggi meglio applicati a singole caratteristiche di un linguaggio di programmazione rispetto alla lingua nel suo complesso.

Let’s consideri brevemente Python e PHP. Entrambi i linguaggi dinamici, è possibile utilizzare le variabili e consentire l'ambiente di runtime determinare il tipo effettivo in esso memorizzato. Ma con PHP è possibile memorizzare, ad esempio, valori integer e stringhe nella stessa variabile nello stesso ambito. A questo proposito, PHP (come JavaScript) è un linguaggio dinamico, debolmente tipizzato.

D'altra parte, Python offre solo una possibilità di impostare il tipo di una variabile, che rende più fortemente tipizzata. È possibile in modo dinamico assegnare il tipo di variabile e il runtime dedurre dal valore assegnato. In seguito, tuttavia, si non sta è consentito memorizzare qualsiasi valore di un tipo non appropriato a tale variabile.

Tipi dinamici in C#

C# 4.0 presenta caratteristiche che rendono più dinamici e statici, nonché come sia scarsamente che fortemente tipizzata. Se la data di nascita come linguaggio tipizzato in modo statico, C# diventa dinamicamente tipizzate in qualsiasi contesto in cui è possibile utilizzare la parola chiave dinamica, ad esempio:

dynamic number = 10;
Console.WriteLine(number);

E poiché dinamica è una parola chiave contestuale, non uno riservato, contiene ancora se si dispone di variabili esistenti o metodi denominati dinamico.

Si noti che C# 4.0 non forzare utilizzare dinamici nello stesso modo in C# 3.0 non forzare utilizzare var, lambdas o gli inizializzatori di oggetto. C# 4.0 fornisce la nuova parola chiave dinamica in modo specifico per rendere più semplice gestire alcuni scenari noti. Il linguaggio rimane essenzialmente tipizzato staticamente, anche se è aggiunta la possibilità di interagire in modo più efficace con oggetti dinamici.

Motivo per cui si desidera utilizzare un oggetto dinamico Innanzitutto, si potrebbe non sapere il tipo di oggetto da affrontare. Potrebbe essere indizi ma non la certezza in modo statico digitare una determinata variabile, ovvero che è esattamente ciò che accade in molte situazioni comuni, ad esempio quando si lavora con gli oggetti COM o quando si utilizza la reflection per ottenere le istanze. In questo contesto, la parola chiave dinamica rende meno complicato gestire alcune situazioni. Il codice scritto con dinamico è più facile lettura e scrittura, creazione di un'applicazione è più facile da comprendere e gestire.

In secondo luogo, l'oggetto può avere una natura implicitamente la modifica. È possibile che sia in uso con gli oggetti creati in ambienti di programmazione dinamici quali IronPython e IronRuby. Ma è inoltre possibile utilizzare questa funzionalità con gli oggetti HTML DOM (con le proprietà expando) e gli oggetti di Microsoft .NET Framework 4 creati appositamente per avere natures dinamico.

Utilizzo dinamico

È importante comprendere il concetto che in C# digitare sistema dinamico è un tipo. Ha un significato speciale molto, ma vale indubbiamente un tipo di ed è importante considerare come tali. È possibile indicare il tipo di una variabile dichiarata, il tipo di elementi in un insieme o il valore restituito di un metodo dinamico. È inoltre possibile utilizzare come tipo di parametro di un metodo dinamico. Al contrario, non è possibile utilizzare dinamica con l'operatore typeof e non è possibile utilizzare come tipo di base di una classe.

Il codice riportato di seguito viene illustrato come dichiarare una variabile dinamica nel corpo di un metodo:

public void Execute()  { 
  dynamic calc = GetCalculator();
  int result = calc.Sum(1, 1);
}

Se si conosce sufficientemente sul tipo di oggetto restituito dal metodo GetCalculator, è possibile dichiarare la variabile calc di tale tipo oppure è possibile dichiarare la variabile come var, consentendo al compilatore scoprire informazioni precise e dettagliate. Ma utilizza var o un tipo statico esplicito richiede di essere certi che un metodo che somma presente nel contratto esposto dal tipo che GetCalculator restituisce. Se il metodo non esiste, viene visualizzato un errore del compilatore.

Dinamico, è possibile ritardare qualsiasi decisione sulla correttezza dell'espressione in fase di esecuzione. Il codice viene compilato e viene risolto in fase di esecuzione come un metodo SUM è disponibile per il tipo memorizzato nella variabile Calc

È inoltre possibile utilizzare la parola chiave per definire una proprietà su una classe. In tal modo, decorare il membro con qualsiasi modificatore di visibilità che è quello desiderato, ad esempio public, protected e persino statico.

Nella figura 1 viene illustrata la versatilità della parola chiave dinamica. Nel programma principale è stato creata un'istanza con il valore restituito di una chiamata di funzione una variabile dinamica. Se non per il fatto che la funzione riceve e restituisce un oggetto dinamico che non sarebbe molto grandi. È interessante vedere cosa accade quando, come nell'esempio, si passa un numero e quindi si tenta raddoppiare all'interno della funzione.

Figura 1 Utilizzo dinamico nella firma di una funzione

class Program {
  static void Main(string[] args) {
    // The dynamic variable gets the return 
    // value of a function call and outputs it.
    dynamic x = DoubleIt(2);
    Console.WriteLine(x);

    // Stop and wait
    Console.WriteLine(“Press any key”);
    Console.ReadLine();
  }

  // The function receives and returns a dynamic object 
  private static dynamic DoubleIt(dynamic p) {
    // Attempt to "double" the argument whatever 
    // that happens to produce
    
    return p + p;
  }
}

Se si feed in un valore pari a 2 e si tenta di questo codice, viene visualizzato un valore di 4. Se feed in 2 come una stringa, si otterrà 22 invece. All'interno della funzione, i + operatore è stato risolto in modo dinamico in base al tipo di fase di esecuzione degli operandi. Se si modifica il tipo a System.Object, generato un errore di compilazione, poiché il + operatore non è definito in System.Object. La parola chiave dinamica consente scenari in cui non fosse possibili senza di esso.

confronto tra e dinamiche. System.Object

Fino a .NET Framework 4, con un metodo a restituire tipi diversi in base a condizioni diverse era possibile solo per ricorrere a una classe base comune. Probabilmente già risolto questo problema, ricorrere a System.Object. Una funzione che restituisce System.Object rende disponibili al chiamante un'istanza che è possibile eseguire il cast a quasi nulla. In che modo utilizza dinamico più efficiente rispetto all'utilizzo di System.Object?

In C# 4, il tipo effettivo dietro la variabile viene dichiarata dinamico viene risolta in fase di esecuzione e il compilatore presuppone che l'oggetto in una variabile dichiarata dinamica appena supporta tutte le operazioni semplicemente. Questo significa che è effettivamente possibile scrivere codice che chiama un metodo sull'oggetto che si prevede che sia presente in fase di esecuzione, come illustrato di seguito:

dynamic p = GetSomeReturnValue();
p.DoSomething();

In C# 4.0, il compilatore non lamentano che il codice. Il codice analogo utilizzando System.Object non verrà compilato e richiede alcuni hacks autonomamente, ovvero reflection o curiosi cast, ovvero per il funzionamento.

VAR vs. dinamico

Le parole chiave var e dinamico sono solo apparentemente simile. VAR indica che deve essere impostato per il tipo in fase di compilazione dell'inizializzatore di tipo della variabile.

Ma dinamico significa che il tipo della variabile di tipo dinamico, disponibile in C# 4.0. In conclusione, dinamici e var hanno un significato piuttosto opposto. VAR è Rinforzo e il miglioramento della tipizzazione statica. Mira a garantire che il tipo di una variabile viene dedotto dal compilatore osservando il tipo esatto da restituire dall'inizializzatore di.

La parola chiave dinamica è informazioni su come evitare del tutto la tipizzazione statica. Quando viene utilizzata in una dichiarazione di variabile, dinamico indica al compilatore di interrompere il funzionamento del tutto il tipo della variabile. Il tipo deve essere inteso come il tipo di che caso che in fase di esecuzione. Var, il codice è come tipizzazione statica come sarebbe stato aveva è optato per il classico approccio dell'utilizzo dei tipi espliciti in una dichiarazione di variabile.

Un'altra differenza tra le due parole chiave è che var può trovarsi solo all'interno di una dichiarazione di variabile locale. Non è possibile utilizzare var per definire una proprietà su una classe, né si utilizzarlo per specificare il valore restituito o un parametro di una funzione.

Lo sviluppatore è prevista la parola chiave dinamica con le variabili per contenere gli oggetti di tipo incertezza, ad esempio utilizzare gli oggetti restituiti da COM o DOM API, ottenuto da un linguaggio dinamico (IronRuby, ad esempio), dalla reflection; espandere dagli oggetti generati dinamicamente in C# 4.0 utilizzando la nuova funzionalità.

Il tipo dinamico non viene tuttavia ignorare controlli di tipo. Sposta solo li tutti in fase di esecuzione. Se vengono rilevate delle incompatibilità di tipo in fase di esecuzione, vengono generate eccezioni.

Dino Esposito è autore dell'imminente “ Programming ASP.NET MVC ” da Microsoft Press e coautore di “ Microsoft. NET: Architettura delle applicazioni per le aziende ” (Microsoft Press, 2008). Esposito, che vive in Italia, è spesso come relatore a eventi del settore in tutto il mondo. È possibile unire il suo blog all'indirizzo indirizzo weblogs.ASP.NET/despos.

Grazie all'esperto tecnica seguente per la revisione di questo articolo:   Eric Lippert