1 - Introduction
Visual Studio 10 pointant le bout de son nez ce début d’année, un point sur les nouveautés qu’amène cette version serait de bon augure !
Avec cette nouvelle mouture apparait la venue du tout nouveau, tout beau framework 4.0 et avec celui-ci, la nouvelle version des 2 langages : C# 4.0 et VB 10.
Dans cet article, nous tâcherons de voir les nouveautés apportées aux 2 langages parmi lesquelles les instructions dynamiques et la covariance/contravariance.
2 - Les évolutions du langage C# 4.0
Les évolutions pour le langage C# sont minimes. En effet, elles ont pour but uniquement de faciliter l’usage des paramètres dans les fonctions.
Pour cela, C# autorise dorénavant les paramètres nommés et les paramètres optionnels. Ils peuvent donc maintenant être utilisés directement lors de la définition de méthodes, constructeurs et indexeurs. Voici un petit exemple :
a) Les paramètres optionnels
On parle de paramètres optionnels lorsque l’on attribue à des paramètres, une valeur par défaut.
Ces valeurs sont utilisées si lors de l’appel à la fonction, il n’y a pas de valeur spécifiée pour ces paramètres. Cependant, il faut obligatoirement respecter l'ordre des paramètres.
Ex : Dans l’exemple, on a : b = 10 et c = 6
b) Les paramètres nommés
On parle de paramètres nommés, quand on précise leurs noms et leurs valeurs séparés de « : ».
Cela permet d’alléger le code, et de ne pas se préoccuper de l’ordre des paramètres lorsqu’ils sont nommés !
Ex : Dans l’exemple, on a : b = 10 et c = 6
3 - Les évolutions du langage VB 10.0
Nous allons voir que contrairement au langage C# 4.0, le langage VB 10.0 a été lui littéralement révolutionné empruntant au passage les fonctionnalités déjà existantes du C#.
a) Le saut d'instruction d'implicite
Sous ces termes barbares se cache la possibilité de déclarer une chaîne de caractères en une seule instruction sur plusieurs lignes sans passer par le caractère de saut d’instruction « _ ». Il devient donc plus pratique d’écrire un long string.
Avant :
Maintenant:
b) Les instructions lambda multi-lignes
Pour vous expliquer en quoi cela consiste, un petit exemple. Ce bout de code permet de réaliser un traitement sur des chaînes de caractères de manière asynchrone (voir ci-dessous).
On remarque que pour pouvoir exécuter le code de manière asynchrone, on est obligé de créer une nouvelle méthode dans la classe.
Dorénavant, grâce à Visual Basic 10.0, on peut écrire directement le bout de code grâce aux instructions lambda multi-lignes. On a donc plus besoin de créer une nouvelle méthode dans la classe (voir ci-dessous).
c) Les initialiseurs de collection
Encore une évolution tenant à remettre à niveau VB par rapport à C#. En effet, depuis VB 9.0, on peut initialiser des objets à partir d’une classe en spécifiant directement dans l’instruction, l’instanciation de l’objet et son initialisation.
Maintenant avec VB 10.0, on peut initialiser des collections.
Comme un exemple est plus parlant que du texte, je vous montre :
L’exemple ci-dessus montre comment créer une collection de notes grâce à l’utilisation du mot-clé « From ».
L’exemple ci-dessus montre comment créer une collection d’objets de type « Personne ». On voit aussi que l’on peut directement initialiser l’objet grâce au mot-clé « With ».
d) Les propriétés simplifiées
Pour faire simple, ces propriétés permettent de définir dans une classe, des propriétés sans avoir besoin d’implémenter les attributs qu’ils gèrent, ni le corps des accesseurs (getter/setter). Cela correspond aux accesseurs simplifiés ( { get; set; } ) présents depuis C# 3.0 dans Visual Studio 2008. On parle en anglais de « Auto Properties », ou bien encore d’ « Auto-Implemented Properties ». L’intérêt de cette « nouveauté » est d’écrire moins de code dans les classes et de rajouter au VB, une fonctionnalité déjà présente en C#.
Dans l’exemple ci-dessus, on voit les 2 déclarations possibles :
- L’ « ancienne » : déclaration d’un attribut « Prénom » avec sa propriété prénom d’une Personne
- la « nouvelle » : déclaration d’une propriété « Nom » contenant le nom d’une Personne. On remarque que celle-ci n’a pas d’accesseurs : c’est une propriété simplifiée !
Les 2 déclarations sont bonnes et donnent le même résultat. On peut d’ailleurs le vérifier en utilisant « Reflector »:
4 - Les évolutions communes aux 2 langages
C’est lors de la « Professional Developers Conference 2008 » que Microsoft annonçait qu’à partir de la version Visual Basic 10 et la version C# 4, ils évolueraient ensemble. Ces versions étant maintenant arrivées, voyons les nouvelles possibilités qu’elles nous proposent !
a) Les instructions lambda multi-lignes
Le but du typage dynamique est de pouvoir créer des instructions dynamiques. Grâce à ces dernières, il est possible de déclarer des variables locales, des attributs de classes ou autres paramètres de méthodes, qui seront typés lors de l’exécution de l’application et non pas comme normalement, lors de la compilation: c’est ce que l’on appelle, des « liaisons tardives » : le typage dynamique se fait par l’intermédiaire du mot-clé « dynamic ». Cela va nous permettre par exemple, d’appeler n’importe quel méthode, d’accéder à un index, à des champs ou des propriétés, sans qu’il n’y ait aucune vérification lors de la compilation. Vous l’aurez donc compris, il faut quand même faire attention avec cette nouveauté…
Mais il y a aussi de nombreux avantages. En outre, on note que l’on pourra beaucoup plus facilement manipuler des objets issus de langage de programmation dits « dynamiques » ( Ruby, Python), simplifier l’utilisation d’objets là où on utilisait la réflexion et de pouvoir manipuler des objets « à structures changeantes » comme les objets HTML et DOM.
b) Exemples pour mieux comprendre
1. Premier exemple
L’exemple ci-dessous illustre bien ce qui est dit plus haut :
En effet, Visual Studio 2010 ne voit pas d’erreur dans ce bout de code alors que sous VS 2008, nous aurions une erreur de typage. Le fait est qu’ici, les 2 variables « monString » et « monInt » sont appelées dynamiquement. La fonction ShowVariableDynamic récupère ces variables et les types automatiquement lors du runtime.
Le résultat donne logiquement :
2. Deuxième exemple un peu plus complexe
Ce deuxième exemple va vous montrer que l’on peut aussi appeler des méthodes sans avoir au préalable, typée la variable.
Soit la classe Policier avec comme attributs, un nom et un prénom. On crée une méthode dans cette classe qui affichera une petite phrase de présentation.
On crée ensuite une méthode « SePresenter » qui aura un paramètre défini de manière dynamique et auquel on appliquera la méthode précédemment définie, Presentation.
Le bloc d’instructions crée une instance de la classe Policier et exécute la méthode SePresenter sur l’objet crée.
On a alors ce résultat :
La méthode Presentation a bien été exécutée de manière dynamique car le type de l’objet (en paramètre) n’était pas explicitement défini lors de la compilation.
Attention toutefois à ne pas abuser de ce nouveau type. En effet, ces dynamiques restent quand même ‘dangereuses’ pour peu que l’on en abuse. On peut alors se retrouver face à un énorme bourbier car le compilateur n’effectue aucune vérification. Le mieux étant de typer convenablement dés que possible pour ne pas être confronté à d’éventuels pertes de performances et de soucis avec l’auto complétion…
c) La "covariance" et la "contre-variance"
1. Mise en situation
Il faut savoir que ces fonctionnalités existent depuis le framework 2.0 ! En effet, depuis VB 8.0 et c# 2, il est possible de les appliquer sur des délégués. Ce qui est nouveau, c’est que l’on peut dorénavant étendre les principes de « covariance » et de « contre-variance » aux interfaces génériques.
Un petit rappel sur la variance. Prenons un exemple pour illustrer celle-ci :
3-4 - Co- and Contra-Variance
Dans cet exemple, on déclare une liste générique de strings. Lors de l’exécution, le compilateur se chargera de vérifier que les accès à la liste ne sont uniquement que pour des types « string ». Essayons d’ajouter un string à la liste, puis un int :
On peut voir que si l’on ajoute un string, il n’y a pas de problème mais que si l’on veut ajouter un int, c’est impossible. Jusqu’ici tout va bien …
Le problème survient lorsque l'on essaye d’utiliser ce qu’on appelle « la variance de générique ». En effet, prenons le code suivant :
Visual Studio 2008 nous renvoie alors une belle erreur. Pourtant, il paraitrait logique qu’il n’y ait pas d’erreur puisque qu’un « integer » dérive du type « object ». C’est là que C# 4.0 et VB 10 interviennent ! Le framework 4.0 amène la solution à ces problèmes en amenant les mots-clés « in » et « out ».
2. La covariance
Le framework amène donc avec lui, le mot-clé « out » permettant la covariance avec les génériques.
Le mieux pour comprendre est de prendre un exemple ! Penchons-nous sur la déclaration de l’interface IEnumerable :
Le mot clé « out » avant le type générique, est utilisé pour dire que le type T sera uniquement utilisable dans une position de sortie au sein de l’interface (comme type de retour des méthodes définies dans cette interface). On dit que l’interface est « covariante » de T.
En résumé, cela signifie que tout IEnumerable(A) sera considéré comme un IEnumerable(B) si et seulement si, A est une conversion de référence vers B.
Attention car la variance ne s’applique uniquement que lorsqu’il existe une conversion de référence entre 2 types d’arguments. Le cas échéant, elle ne pourra être utilisée. Un cas simple : un IEnumerable(integer) ne pourra pas être un IEnumerable(object) car la conversion d’un integer vers un object n’est pas une conversion de référence, c’est une conversion dite « de boxing »…
3. La contravariance
Cette fois-ci, c’est la contravariance qu’amène le mot-clé « in » ! Comme toujours, prenons un exemple, l’interface IEqualityComparer :
Cette fois-ci, le mot-clé « in » signifie que T peut se produire uniquement en position d’entrée au sein de l’interface.
On peut résumer ce cas logiquement. En effet, si un IEqualityComparer(T) est capable de comparer 2 objets quelconques du type « objects », alors forcément, il peut comparer 2 strings. C’est cette notion qu’on appelle « contravariance » !
5 - Conclusion
Les nouveautés apportées par le framework 4.0 ne sont pas réellement de vraies révolutions des langages. Il s’agit plutôt de l’apport de différentes possibilités, et différentes évolutions visant à rendre les langages plus souples. Les amateurs de VB seront contents de voir que leur langage préféré a rattrapé son retard et est maintenant (presque) au niveau du C#.
En bref, ces 2 langages n’ont pas été révolutionnés. A part l’arrivée du typage dynamique (sujet à de multiples débats à mon humble avis) et les notions de variance et contravariance, rien de bien nouveau.
On reprend les mêmes et on recommence avec une version plus aboutie et un langage VB remis au niveau du C# pour faciliter la future coévolution.
bf044e5b-99c1-4b03-9d7a-94d269c8b39f|0|.0
C#, vb.net, Visual Studio 2010
c#, vb.net, visual studio 2010, framework 4.0