Cet article est juste une lecture du  What's New in the .NET Framework Version 4(beta 2) et de quelques autres articles dont les articles des techdays 2009 : Les nouveautés du CLR 4.0,

Préambule

Le .net framework 4 est une version à part entière comme le framework 2.0 par rapport au 1.1. En effet, les versions 3.0 et 3.5 n’étaient que des surcouches par rapport à la 2.0 (pour simplifier que de nouveaux assemblies comme WCF, WF et WPF).

Déploiement et compatibilité

.NET Framework Client Profile

la fonctionnalité client profile qui permet de déployer des application clientes offre de nouvelles fonctionnalités

• support des packages locaux en plus des installations en mode Web
• s’ouvre à toutes les plate formes qui supporte le .net 4 (en dehors des I64). Avant, seuls les PC XP x86 étaient autorisés.
• Fait parti du framework.

N’ayant jamais été confronté à ce genre de problématique je vous laisse lire la suite.

In-Process Side-by-Side Execution

à l’aide d’un fichier de configuration associé au programme, on peut spécifier dans quelle version du framework exécuter l’assembly.

Ceci est particulièrement utile pour les add-in Office. En effet, un add-in pourra être compatible 4.0 et un autre 2.0 et pourtant s’exécuter dans le même Word.

Pour en savoir plus voir In-Process Side by Side (Part1)et  Les nouveautés du CLR 4.0pour un exemple de ce qui pourrait ne plus marcher entre la 2.0 et la 4.0.

Questions que je me pose à chaud (mais tant que je n’y suis pas confronté, les réponses ne sont pas urgentes):

• mémoire : est ce que de charger le runtime 2.0 et le runtime 4.0 est gourmant ?
• communication : peut-on avoir le cas tordu d’un assembly “4.0” qui a besoin de communiquer avec un assembly “2.0” ou inversement ?
• Quand est ce que la technologie COM sera abandonnée (ou même un début de migration) ? Je suis d’accord il ya du boulot : Office, Explorateur de fichier, Internet Explorer ne sont pas des développement anecdotiques…

programmation parallèle

Avec l’utilisation de plus en plus courante des multi cœur, ces évolutions permettent de faire du multi threading très facilement. Microsoft propose un nouveau Framework, non seulement des instructions pour faciliter la programmation mais aussi des add-ins visual studio pour faciliter le débogage (voir futur article ainsi que La programmation parallèle pour les développeurs ... )

L’intérêt c’est qu’il est plus simple d’écrire de faire du multi thread (voir les exemples suivants tirés de Les nouveautés du CLR 4.0).

Mais le framework s’occupe de tout en fonction de la machine (nombre de cœurs, etc).

A noter que pour la beta 2, beaucoup de pages d’aide du MSDN sont vides. Est ce que ça veut dire que ce n’est pas totalement mature ?

Le MSDN distingue toutefois

• le data parralelism : on a besoin de faire un traitement sur chaque élément d’une liste. Bien entendu, il faut que chaque donnée soit indépendante l’une de l’autre.
• le task parralelism : dans ce cas, certaines tâches distinctes peuvent être parallélisées.

Note de JPC : est ce que si on considère une tâche comme une donnée, ça ne revient pas à faire du data parralelism. D’un autre coté, si on manipule une data c’est bien pour faire une tâche dessus… J’ai l’impression que c’est comme la théorie des dualités des ondes – particules : on prend ce que l’on veut selon son feeling…

à noter TPL and Traditional .NET Asynchronous Programming

Les occasions de faire du multi thread du coté client sont quand même assez rares. Pour l’instant je n’ai pas eu beaucoup l’occasion d’en faire et je ne suis pas certain d’utiliser ce nouveau framework sauf en de rares occasions. Pour l’instant les occasions que j’ai eus :

• séparer un traitement de l’interface graphique. Si le traitement est long (récupérer une page web, accéder à des fichiers dans une arborescence), cela permet d’afficher une boite de progression et d’offrir l’opportunité d’annuler. Mais là aucun besoin d’un framework massivement parallèle : un nouveau thread suffit. De plus le framework offre en général un mécanisme transparent : les méthodes async de System.net et de system.io…
• cloner des objets en mémoire (dans le cadre d’une gestion de undo/redo). Pas besoin de massivement parallèle…

Par contre, j’aurais pu avoir une opportunité c’est quand j’ai fait un petit injecteur de données/messages en parallèle. J’ai fait une bête boucle for “à la main”…

Bref, je pense qu’il faut attendre pour voir car même en cas de traitement serveur le nombre de cas restera assez limité. En effet, aujourd’hui le défit est de bien penser sa conception pour éviter d’arriver dans ce genre de situation…

Reste à voir les avancées de Visual Studio pour le débogage.

Sécurité

La sécurité a été simplifiée : plus (dans le sens plus du tout et pas encore plus) de sécurité “machine”. Les applications clients lourd (native) s’exécutent en mode full trust ainsi que les application venant d’un partage réseau (YES!!!!!!). Les applications hostées (Sandbox) s’exécutent dans un contexte de sécurité propre au programme (Internet Explorer, clickonce, etc).

Security Changes in the .NET Framework 4

Core

Diagnostics and Performance

On peut maintenant monitorer mémoire et cpu par AppDomain. En mode “client”, les applications avec plusieurs AppDomain sont assez limités. Par contre, en mode serveur, ça peut être utile :

• des applications web IIS. Avant pour monitorer, il fallait faire plusieurs applications pool. Perso, je vais toujours garder cette logique ne serait ce que pour les autres intérêt : isolation, si un tombe pas l’autre, etc…
• Dans Biztalk. On peut donc surveiller plusieurs “application”. Mais l'à encore Biztalk propose déjà des moyens d’isolation (par processus/service)

==> intérêt ????

Garbage Collection

Je dois avouer que j’ai pas tout compris So, what’s new in the CLR 4.0 GC? . J’ai pas compris le principe technique mais pas les enjeux, les problèmes et … les solutions.

Par contre, l’explication de Les nouveautés du CLR 4.0est relativement claire.

Code Contracts

voilà un truc que j’attendais depuis très très longtemps. Pour moi une des principales limitations actuelles de .net.

Les codes contracts permettent de spécifier des pré conditions, des post conditions, et des objects invariants. Avant on pouvait insérer des Debug.Assert ou utiliser d’utiliser d’autres artifices mais rien de bien pratique. Perso je trouve que cette nouvelle fonctionnalité s’inspire de l’écriture de tests unitaires dans Visual Studio Test Edition (classe Assert). Cette nouvelle fonctionnalité va faciliter l’écriture de tests unitaires, la documentation,  …

Plutôt qu’un long discours, voici un exemple de code qui explique tout.

Certaines contraintes et possibilités :

1. chaque membre d’un pré condition doit avoir au moins le même niveau de visibilité que la méthode elle même (autrement la pré condition risque de na pas être comprise par l’appelant).
2. possibilité de lever une exception custo lors de la pré/post condition
3. possibilité lors d’une post condition de faire référence à la valeur AVANT d’entrer dans la méthode (OldValue).
4. Les conditions d’invariance sont des conditions que l’objet DOIT respecter tout au long de sa durée de vie (par exemple des cordonnées ne peuvent pas être négatives).
5. possibilité de mettre les contract séparément de la classe (voir l’attribut ContractClassAttributeet l’exemple dans le MSDN ) ==> on peut mettre des contrat sur des interfaces…
6. l’héritage a été prévu : les contraintes sont hérités et il est impossible de modifier la contrainte dans les “override”
7. les vérifications s’activent ou pas selon le type et les options de compilation. Plutôt qu’un long discourt une copie d’écran de la doc (documentation en PDF ; non vous ne rêvez pas Microsoft utilise le format “ennemi” ).
   Et puis une capture d’écran de Visual Studio (doit y a avoir encore quelques bugs car j’arrive pas à accéder à l’écran d’option)
   Donc, comme on peut le voir, on peut faire des versions “sans trop de vérifications” pour ne pas impacter les performances. (Note de JPC : de nos jours, je suis persuadé que plus de la moitié de la CPU est consacré par les vérifications – avant d’appeler la couche basse et si une couche haute nous appelle - et le fait de pouvoir les désactiver tout ou partie m’enchante).

La doc est pour l’instant assez limitée. Attention à l’édition : la vérification statique n’est disponible que dans VSTS Ultimate.

Questions que je me suis posé :

• est ce que le compilateur détecte et signale qu’une pré condition est TOUJOURS fausse ?
  réponse : Oui à condition d’activer les vérifications statiques. D’après la doc ça reste assez limité (ForAll, Exists et c# iterators).
• est ce que le compilateur détecte et n’effectue pas le test au moment de l’exécution d’une pré condition qui est TOUJOURS vraie ?
  réponse : si le test est activé dans l’option de génération de build alors le test est toujours fait
• Peut on arriver à modifier l’état d’un objet lors de ces pré/post conditions ?
  prévu : le framework fait certains checks mais en surface. En particulier tous les accesseurs Get sont considérés comme “purs”. Mais rien n’interdit le codeur de modifier l’objet à l’intérieur d’un Get.
• Peut-on propager les contraintes ?
  Cas le plus fréquent, une méthode/un constructeur est surchargé
  Autre cas, je construit un wrapper “visuel” sur un objet métier
  Autre cas, y a t-il moyen de faire un “ContractValidator” qui détecte tout seul sur une appli les erreurs sur un objet bindé
  Autrement dit, le rêve de TOUT développeur : les contraintes décrites dans la base de donnée sont “générés” par le DAL et propagées jusqu’à la couche UI.
  

Donc, très prometteur mais il manque certaines choses :

• propagation des contraintes surtout jusqu’à la couche UI.

Design-Time-Only Interop Assemblies

You no longer have to ship primary interop assemblies (PIAs) to deploy applications that interoperate with COM objects.

jamais été confronté à cette problématique ==> je passe

Dynamic Language Runtime

Permet d’offrir un certain nombre de service pour les langages dynamiques. Permet également d’offrir certains services à des langages “statiques”. Le MSDN cite l’exemple d’incrémenter une variable XML

(à noter que moi j’aurait fait “ XMLNode node = ….. node.InnerText = ….” Bref à chacun sa sauce)

Question de JPC : pourra-t-on facilement permettre aux utilisateurs de nos applications d’utiliser LEURS macros comme dans Word, etc…

Covariance and Contravariance

L’intérêt de ces fonctionnalités me semble assez limité et ne s’appliquer qu’à certains cas particuliers.
Vous pouvez voir aussi Tour d'horizon des nouveautés de C# 4.0; c’est très très bien expliqué

BigInteger and Complex Numbers

Bon c’est plutôt réservé aux scientifiques.

Ce que je ne comprends pas c’est que l'a problématique BingInteger est connu depuis plus de 10 ans (j’en ai fait durant ma thèse). Pourquoi n’était-est pas inclus dans le .net ?

Tuples

La possibilité de créer de nouveaux à la fois simples et pratiques sans avoir besoin d’écrire une nouvelle classe.

Qui n’a pas eu besoin d’avoir une variable qui contient 2 ou plus variables. Bref d’avoir une structure mais en plus light…
Merci les tuples…
Le plus fort ce sont les Equals et Comparer qui marchent …

File System Enumerations

Qui n’a pas eu la problématique d’énumérer tous les fichier *.extension d’une arborescence et d’être frustré : pas moyen d’obtenir la liste au fur et à mesure qu’elle est construite. C’est à dire : pas de barre de progression, pas de moyen de remplir une liste au fur et à mesure…

Un exemple que j’ai testé

Les résultats

Memory-Mapped Files

La possibilité d’avoir des gros fichiers en mémoire et de pouvoir y accéder très simplement.

64-Bit Operating Systems and Processes

On peut savoir si on est sur une plateforme 64 bits et d’accéder au registre 32 ou 64 bits…

Other New Features

que ce qui m’intéresse :

• String.IsNullOrWhiteSpace
• String.Concat<T>
• The new System..::.IObservable<(Of <(T>)>) and System..::.IObserver<(Of <(T>)>) interfaces provide a generalized mechanism for push-based notifications.
• You can now enable lazy initialization for any custom type by wrapping the type inside a System..::.Lazy<(Of <(T>)>) class.
• You can now parse System..::.Guid structures.
• The new Microsoft.Win32..::.RegistryOptions enumeration lets you specify a volatile registry key that does not persist after the computer restarts. ==> ENFIN!! Plus obligé de passer par les API Win32
• Registry keys no longer are restricted to a maximum length of 255 characters.

Networking

Améliorations sur l’authentification intégrée (attention Windows 7/Windows 2008 R2 nécessaire ==> pas avant 50 ans chez certains de nos clients :-) ou même chez Atos :-( )

Amélioration du support NAT en IPv6 et teredo.

De nouveaux compteurs pour le HttpWebRequest

D’autres améliorations…

Web

Parmi toutes les nouveautés d’ASP.Net 4, je ne retiens que quelques points :

• Auto-Start Web Applications ==> yes la fonctionnalité la plus intéressante. Qui n’a pas ralé car le premier accès à une application est lent… Plus d’excuse pour supprimer le recyclage. Par contre, seulement sur W2008R2.
  
  Et en plus on peut si on le veut, précharger des données ou autre.
  
• Permanently Redirecting a Page
  
• ASP.NET Web Forms. Nombreuses améliorations : meta tags, More control over view state, More control over generated IDs, The ability to persist selected rows in data controls, Filtering support for data source controls,
• ASP.NET Chart Control : YESS!!!! (avec Ajax )
• Microsoft Ajax Functionality : Yes !!! Json and Co…
• au moment du déploiement, il est maintenant prévu de manipuler le web.config…
• Support for MVC-Based Web Applications
• Automatic validation that is based on constraints that are defined in the data model. YES !!!!!!! A TESTER ABSOLUMENT.

Client

WPF

Nouveaux contrôles : DataGrid, Calendar et DatePicker (Enfin !!! plus besoin de hoster le contrôle Winform)
Visual State Manager : améliorations dans les Controltemplate.
Touch and Manipulation : support des écrans tactiles.
Graphics and Animations : comprends pas tout ; je ne suis pas graphiste.
Text : même le rendu de texte a été amélioré.
Binding : Bind to commands on InputBinding, Bind to Dynamic Objects, Bindable Text Run
XAML Browser Applications
WPF and Windows : support de la barre des tâche de Windows 7

Managed Extensibility Framework

The Managed Extensibility Framework (MEF) is a new library in the .NET Framework 4 Beta 2 that helps you build extensible and composable applications. MEF enables you to specify points where an application can be extended, to expose services to offer to other extensible applications and to create parts for consumption by extensible applications. It also enables easy discoverability of available parts based on metadata, without the need to load the assemblies for the parts. For more information, see Managed Extensibility Framework. For a list of the MEF types, see the System.ComponentModel.Composition namespace.

JPC : à tester et surtout lire des Guidance à l’occasion

Data

ADO.NET provides new features for the Entity Framework, including Persistence-Ignorant Objects, functions in LINQ queries, and Customized Object Layer Code Generation.

ADO.NET Entity Framework

à tester sur un micro projet et un plus gros. Lire avant des guidance et le Entity Framework Overview.

Communications and Workflow

Comme je n’ai jamais fait de Windows Workflow, je vais pas comprendre les nouveautés.

Pour les nouveautés WCF, je n’ai vu aucune modification qui aurait pu améliorer mon code existant.

 

à suivre dans le prochain article les nouveautés c# 4 puis les nouveautés de Visual Studio 2010 et enfin les nouveautés de TFS.