Le framework .NET (qui arrive gentiment sur ses 10 ans) évolue de version en version. La deuxième version a apporté les Génériques, la 3.0 a propulsé LINQ et tout ce qui était nécessaire à son intégration. Quelle surprise nous réserve le Framwork 4.0 ?

Pour répondre à cette question, il faut comprendre les grandes tendances actuelles en matière de développement :

• Les développeurs  se tournent de plus en plus vers des langages déclaratifs, qui leurs permettent de se concentrer d’avantage sur ce qu’ils doivent faire et pas sur la façon dont ils pourront rendre leur code impératif fonctionnel.
• Les langages dynamiques tels que Php, Javascript, Ruby… connaissent un succès qui ne se dément pas. La simplicité du développement, le typage implicite et l’absence de compilation y sont pour beaucoup.
• Paradoxalement, on observe un intérêt sans cesse renouvelé pour les langages statiques. Ils apportent leur lot de robustesse, de performance et d’outils intelligents comme IntelliSense dans Visual Studio, ainsi que, généralement, une meilleure sécurité lors de la montée en charge (le code étant compilé, il est moins évident de passer à côté d’une erreur, même si le projet fait plusieurs millions de lignes).
• Enfin, un besoin important d’économiser de l’énergie en privilégiant les technologie multicoeurs, et donc de maitriser les problématiques d’accès concurrent et de gestion de ressources démultipliées.

Voici la réponse de Microsoft à ces problématiques.

1. Le Dynamic Language Runtime

C# 4.0 poursuivra le travail de C# 3.0 et continuera à promouvoir l’utilisation de LINQ, afin de rendre le code plus fonctionnel et d’en faciliter la relecture., mais il fournira également de nouvelles fonctionnalités, orientées « programmation dynamique » grâce à la DLR, un socle de création de langages dynamiques implanté en surcouche de la CLR qui donnera accès aussi bien à un Object Binder .NET qu’à des Binder Silverlight, Python ou Ruby…

2. Le typage dynamique des objets

La grosse révolution de C# 4.0 est le typage dynamique d’objets. C# 4.0 introduira un type statique dynamic dont la résolution se fera non pas à la compilation, mais à l’exécution (la compilation générant en fait du script). Une vraie révolution dans le monde du .NET et une annonce très attendue par ceux qui utilisent la réflexion à outrance. L’exemple donnée est assez parlant.

Imaginez que vous ayez une méthode GetCalculator() en provenance d’une usine logicielle, qui renvoie un objet de type Object (mais dont vous savez qu’il s’agit d’un calculateur). Voici ce qu’il fallait écrire avant pour calculer 10+20 :

object calc = GetCalculator();
Type calctype = calc.gettype();
object res = calctype.InvokeMember("Add", BindingFlags.InvokeMethod, null, new object[] {10, 20});
int sum = convert.ToInt32(res).

Le code n’est pas très intuitif, et cela est principalement dû à la phase d’appel à la procédure par invocation… Voilà ce que cela pourra donner en C# 4.0 :

dynamic calc = GetCalculator();
int sum = calc.add(10,20);

3. Paramètres optionnels et nommés

C# 4.0 introduira la possibilité de définir des paramètres optionnels et nommés (oui, il aura fallu un certain temps diront les détracteurs…). Il ne sera donc plus la peine de développer 8 signatures d’une même méthode pour définir des valeurs par défaut ; autant de temps gagné par les développeurs pour s’interroger sur de vrais problèmes.

4. Améliorations relatives à l’usage de COM

Outre les paramètres optionnels et nommés déjà décrits, qui permettront d’écrire :

var maVariable = comObject.method();

au lieu de :

var maVariable = comObject.method(System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing);

C# 4.0 utilisera également ses nouvelles fonctionnalités « dynamiques » pour permettre le mapping automatique des objets (en réalité, il résoudra ce problème à l’exécution).

5. Covariance et contra-variance

Lorsque vous instanciez une classe générique avec un type référence B dérivant de A, le transtypage de B vers A des éléments de la liste était impossible. Via une astuce de déclaration de l’interface de la classe générique, cette covariance sera désormais autorisée :

IBoite<cookie> maBoiteACookies = new Boite<cookie>();
IBoite<biscuit> maBoiteABiscuits = maBoiteACookies;

Réciproquement, un second mot clé permettra des opérations de contra-variance (de la classe vers ses dérivées) et on peut dès lors imaginer des scénarios mixtes mélangeant co et contra-variance, comme l’écriture de délégués ayant des paramètres d’entrée et sortie (d’où les mots clés choisis… in et out).

6. Co-évolution des langages

Microsoft s’est engagé à faire évoluer conjointement C# et VB.NET à partir de cette version du Framework. Voilà une grande nouvelle qui devrait réjouir les développeurs VB.NET, jusque-là un peu moins bien traités que leurs camarades C#-istes.

Pour aller plus loin

Si vous désirez aller plus loin dans la compréhension des nouveautés du Framework .NET 4.0, Nexdotnet vous invite à imprimer le poster prévisionnel du Framework .NET 4.0 et à lire les articles suivants :

• [Dossier] Tour d’horizon des nouveautés de C# 4.0, par Jérôme Lambert
• [Video] The Future of C# (EN), présenté par Anders Hejlsberg
• [Video] Future Directions for Visual Basic (EN), présenté par Paul Vick et Lucian Wischik
• [Word] C# Futures, par Mads Torgersen