C# 4.0 introduit un nouveau type : dynamique, qui est un type statique, mais une instance d’objet de ce type peut contourner le processus de vérification statique des types. Dans la plupart des cas, le type fonctionne comme une classe objet. Au moment de la compilation, une instance d’une classe dynamique prend en charge toute opération, il n’y a donc pas besoin de s’inquiéter que l’objet provienne d’une API COM, d’un langage dynamique comme IronPython, du DOM HTML, de la réflexion ou d’un autre endroit dans le programme. Cependant, si le code fait quelque chose d’invalide, l’erreur est détectée à l’exécution.
Par exemple, l’exemple de méthode exampleMethod1 dans le code snippet suivant n’a qu’un seul paramètre, et le compilateur peut identifier qu’il est invalide lors de l’appel de ec.exampleMethod1(10,4) au moment de la compilation ; C’est une erreur de compilation. Le second appel dynamic_ec.exampleMethod1(10,4) n’est pas vérifié pour les types statiques. Par conséquent, le compilateur ne signale pas d’erreurs de compilation. Cependant, le bug ne se cache pas éternellement ; Il sera détecté à l’exécution et déclenchera une exception à l’époque.
vide statique Main(string[] args){
ExampleClass ec = nouvelle ExampleClass() ;
dynamique dynamic_ec = nouvelle ExampleClass() ;
dynamic_ec.exempleMéthode1(10, 4) ;
dynamic_ec.someMethod (« un argument », 7, null) ;
dynamic_ec.nonexistentMethod() ;
}
classe Exemple Classe {
public ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void exampleMethod2(string str) { }
}
Voici un exemple d’utilisation dynamique pour appeler IronPython :
utilisant IronPython.Hosting ;
utilisant Microsoft.scrip{filtering}ting. Animation ;
Console.WriteLine(« Chargement random.py... ») ;
scrip{filter}tRuntime py = Python.CreateRuntime() ;
aléatoire dynamique = py. UseFile(« random.py ») ;
Console.WriteLine(« random.py chargé ! ») ;
var items = Énumérable. Plage(1, 7). ToArray() ;
pour (int s = 0 ; s < 10000 ; s++) {
random.shuffle(items) ;
Console.Write(« Sequence {0} : « , s) ;
foreach (int i in items) {
Console.Write (« {0} « , i) ;
}
Console.WriteLine() ;
}
Pour les objets ou expressions dynamiques de type, le rôle du compilateur est d’encapsuler les actions que chaque expression est censée effectuer, et au moment de l’exécution, de vérifier les informations stockées, et toute instruction invalide déclenchera une exception à l’exécution.
Le type de résultat de la plupart des opérations dynamiques est également dynamique. Par exemple, si vous passez le pointeur de la souris au-dessus du testSum dans l’exemple suivant, l’invite intelligente affichera un testSum dynamique (variable locale).
dynamique d = 1 ;
var testSum = d + 3 ;
Passez le pointeur de la souris au-dessus du testSum ci-dessous.
System.Console.WriteLine(testSum) ;
Conversion de type
La transition entre des instances de type dynamique et d’autres types d’instances est simple, et les développeurs peuvent facilement passer de comportements dynmiques à non dynamiques. Toute instance peut être implicitement convertie en instance de type dynamique, voir l’exemple suivant :
dynamique d1 = 7 ;
dynamique d2 = « une corde » ;
dynamique d3 = System.DateTime.Today ;
dynamique d4 = System.Diagnostics.Process.GetProcesses() ;
Inversement, une conversion implicite peut être appliquée dynamiquement à toute expression de type dynamique.
Et inversement, toute expression de dynamique de type peut aussi être implicitement convertie en d’autres types.
int i = d1 ;
string str = d2 ;
DateHeure dt = d3 ;
System.Diagnostics.Process[] procs = d4 ;
Problème de surcharge avec les paramètres de type dynamique dans la méthode
Si une méthode est appelée «
DLR à l’exécution dynamique du langage
L’exécution dynamique du langage est . NET Framework 4 Beta 1 est un nouvel ensemble d’API qui prennent en charge les types dynamiques en C# et implémente également des langages de programmation dynamiques comme IronPython et IronRuby.
Interopérabilité COM
C# 4.0 inclut plusieurs fonctionnalités qui améliorent l’interopérabilité avec les interfaces API COM traditionnelles telles que l’automatisation de Office. Les types dynamiques, les paramètres nommés et les paramètres optionnels font également partie de l’amélioration.
De nombreuses méthodes COM permettent que leurs paramètres et valeurs de retour soient de type objet, donc pour les langages fortement typés comme C#, beaucoup de conversion de type forcée est nécessaire. Cependant, dans C# 4.0, si vous ajoutez l’option /link au moment de la compilation, le type dynamique a un nouvel effet : il rend le type d’objet (type de paramètre ou type de retour) dans la signature de méthode de l’interface COM considéré comme dynamique, évitant ainsi une grande conversion de type. Par exemple, l’affirmation suivante contraste avec cela.
Il n’est pas utilisé dynamique.
((Excel.Range)Excel. Cellules[1, 1]). Value2 = « Nom » ;
Excel.Plage = (Excel.Plage)excel. Cellules[1, 1] ;
C’était un jeu dynamique.
Excel. Cellules[1, 1]. Valeur = « Nom » ;
Excel. Plage = excel. Cellules[1, 1] ; |
Publié sur 07/07/2016 10:23:00
|
|
|
