La disponibilité de la Beta 2 de Visual Studio 2010 et du .NET Framework 4.0 a été annoncé par Jason Zander, General Manager de Visual Studio ce lundi (19/10/2009) suivi de l’annonce de Scott Guthrie, General Manager de la division .Net chez MS Corp que j’ai eu la chance de rencontrer en Mars dernier à l’occasion du MIX09 à Las Vegas.

Parcourons ensemble ces nouvelles versions !

Visual Studio 2010

Après une 1ère CTP délivrée à Noël dernier qui nous a permis de découvrir les nouvelles possibilités du .NET 4.0 et une Beta 1 en milieu d’année, la Beta 2 diffusée en début de semaine est arrivée à maturation avec l’annonce d’une licence “Go-Live” pour le framework .NET 4.0 et Visual Studio 2010 !

Go-live signifie que vous avez le “GO” de Microsoft pour démarrer des projets de production dessus en vous garantissant un support sur ces versions ! La version finale de ces deux produits étant fixé pour le 22 Mars 2010 (surement à l’occasion du MIX 2010 ?).

L’arrivé de cette version 2010 (10) de Visual Studio fait aussi le ménage dans les nombreuses éditions des versions antérieures. Désormais il n’y aura plus que trois éditions en plus de la gamme “Express” gratuite :

• Visual Studio Express
• Visual Studio 2010 Professional avec MSDN
• Visual Studio 2010 Premium avec MSDN :
• Visual Studio 2010 Ultimate avec MSDN

A ce sujet je vous recommande la lecture de l’article de Christopher Maneu sur son blog : http://blog.christophermaneu.fr/2009/10/vs-2010-le-point-sur-les-versions/

Visual Studio 2008 / .NET 3.5 <> Visual Studio 2010 / .NET 4.0 “side-by-side” ! N’avez plus peur, l’environnement VS2010/NET4 est parfaitement compatible avec l’environnement VS08/NET35 sur la même machine ! Pas de risque de perturbation, vous pouvez comme moi, installer ce nouvel environnement en beta 2 sur votre poste tout en continuant vos développements sous VS2008. De plus avec la License “Go-Live”, vous pouvez y aller :=)

Pour les téléchargements c’est ici : http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

Installation

Après récupération de l’ISO, vous pourrez l’installer comme à votre habitude,

Vous noterez une erreur à la fin de l’installeur en ce qui concerne le SDK de Silverlight 3.0 ! N’en tenez pas compte

Et en prime, une nouvelle icone pour cette nouvelle version !

Premier lancement

Nouvelle icone et nouveau ”Splash Screen” :

… et nouvelle “Start Page” qui a encore évoluée par rapport à la CTP et Beta 1 :

Vous trouverez aussi de nouveau “Project template” en rapport avec Sharepoint 2007/2010, Office 2010, F#, Silverlight 3.0 et Windows Azure* par défaut.

En ce qui concerne le “project template” pour les services Azure il faudra patienter jusqu’en Novembre pour la disponibilité des tools Azure pour VS 2010. Actuellement, la création d’un projet Azure sous VS 2010 vous ouvrira la page suivante : http://blogs.msdn.com/jnak/archive/2009/10/18/windows-azure-tools-and-visual-studio-2010.aspx

Les nouveautés

Editeur de code et designers

Le look & feel de l’éditeur de code et des designer a un peu évolué par rapport aux versions précédentes avec notamment un rendu WPF permettant par exemple de pouvoir zoomer très facilement avec la molette de la souris tout en appuyant sur la touche “Control”. Cela va être très (très .. très) pratique pour les présentations publiques !

Online Template & Recent Project

Fonctionnalité bête mais qui m’a beaucoup plus, la possibilité de “Pin”(ner) un projet dans la liste des projets récents à la Windows Seven permettant d’avoir ses projets principaux à porté de main.

Dans la création de nouveau projet, nous avons la possibilité de lister des “Project template” en ligne, notamment pour accéder à des Starter Kits

Multi-targeting

Cette fonctionnalité a fait son apparition dans Visual Studio 2008 pour nous permettre de sélectionner le framework de destination de notre application (2.0, 3.0 ou 3.5). Etant donné que ces différentes versions du framework exploité la même CLR (qui n’a pas bougé depuis la 2.0), le multi-targeting de VS2008 s’occupé de filtrer les assemblies disponibles dans le Framework choisi. Mais dans certains cas, l’IntelliSense montrait des membres et/ou types des versions supérieures ce qui pouvait engendrer l’utilisation de méthodes du 3.0 ou 3.5 dans un projet 2.0 !

Sous Visual Studio 2010, le multi-targeting a été profondément revu avec ce qu’ils ont appelé les “reference assemblies” qui contiennent les méta données des assemblies d’un framework donné (en quelque sorte la cartographie des assemblies d’un framework).

Grace à cela, les “Property grid” des designers, le profiler, compilateur, Object browser, et tout ce qu’il se trouve dans VS010 se basent sur ces “reference assemblies” pour ne refléter que les types et membres du framework cible sélectionné.

Multi-Monitor

En tant qu’adapte du multi-moniteur, j’ai l’habitude de travailler avec deux écrans en mode étendu sous mon Windows Seven au travail comme à la maison ! J’avoue avoir déjà été gâté lors de l’arrivé de Windows Seven par le “Windows+P” permettant de sélectionner très rapidement et simplement le mode d’affichage.

Avec Visual Studio 2010 vous avez la possibilité de “sortir” vos documents et autres fenêtres de votre Visual Studio comme une fenêtre Windows pour la placer à l’endroit que vous voulez, sur l’écran que vous voulez.

Je peux donc exploiter au mieux mes écrans en plaçant par exemple mon designer WPF sur l’un des écrans pendant que j’édite son code source sur le deuxième :

Navigate To

Nommé initialement “Quick Search”, le “Navigate To” permet de rechercher facilement des symboles (variables, méthodes, classes, types, etc…) dans votre solution. (A l’inverse du “Search” qui recherche du texte brut dans des fichiers !).

Call Hierarchy

Cette fonctionnalité fort pratique nous permet d’avoir un affichage de la hiérarchie des appels sur une méthode.

Highlighted reference

Cette fonctionnalité permet de surligner dans mon code toutes les références d’une variable ou paramètres dans l’éditeur de code ! Assez pratique pour voir d’un seul coup d’œil où votre paramètre/variable est utilisé !

Parallel Programming and Debugging

Avec l’arrivé de Parallel Fx dans le .NET 4.0, VS2010 est doté d’outils de debugging permettant la visualisation et le débogage de chaque thread.

Dependency Graph

Permet de construire des graphs à partir du code source et/ou assemblies de votre solution pour représenter les différentes relations par assembly, namespace, classe ou manière personnalisée en spécifiant ce que l’on veut y voir et avec quel filtre. 

Les Diagrams

On y trouve un nouveau designer permettant de concevoir deux types de diagrammes : les “Layer Diagram” (architecture logique qui nous permettent d’organiser nos classes, namespaces, fichier de code, projets de notre solution, …) et les “UML Diagram” que l’on ne présentent plus.

Architecture Explorer

Cette nouvelle fenêtre nous permet de parcourir les relations dans notre code.

Et bien d’autre…

• Nouvelle version de TFS 2010, le serveur de contrôle de code source et de son client dans VS2010
• Un nouveau profiler de performance
• Nouveau outils à destination de testeur (Microsoft Test and Lab Manager entre autre)
• Nouveau designer pour les Workflows
• Un explorer pour Sharepoint
• Le “Code Optimized Web Development Profile” : un profile sans le designer web qui permet d’éditer le code source directement
• De nouveaux snippets
• …

.NET framework 4.0

Traiter du nouveau framework 4.0 dans son ensemble serait chose impossible dans un seul article tant les nouveautés sont importantes. Tentons d’en donner un petit aperçu.

Un nouveau moteur d’exécution : la CLR 4.0

Le framework 4.0 embarque un nouveau moteur d’exécution, la CLR 4.0 qui n’avait pas évolué depuis la version 2.0 en 2005. Rappelez-vous que le framework 3.0 puis 3.5 n’ont apporté que de nouvelles assemblies (comme WCF, WF, WPF, Linq, Data Service, etc…) mais tout cela reposant sur la CLR 2.0.

Avec ce nouveau framework la CLR à dû évoluer pour améliorer le support du multi-coeur, du garbage collector et des langages dynamiques (DLR).

Nouveau langages : C# 4.0 et VB 2010

Vous trouverez une série sur les nouveautés de VB 2010 sur le blog de Redo : http://blogs.developpeur.org/redo/archive/2009/02/10/nouveaut-s-de-visual-basic-2010-vb10-le-livre-blanc-recueil-de-blog.aspx

Concernant C# 4.0, nous pouvons citer entre autre :

• Les types “dynamic”
• La co- et contra- variance sur les collections
• Les paramètres nommées et optionnels
• L’amélioration de l’interopérabilité COM
• …

ADO.NET 4.0

Englobant :

• La beta 2  de Entity Framwork 4
• La beta 2 de ADO.NET Data Service 4 (ex Astoria)
• Lire : http://bit.ly/3zWNB1

ASP.NET 4.0

• Nouveaux contrôles pour les graphiques
• Nouveau framework pour ASP.NET Ajax 4.0
• ASP.NET MVC 2
• L’URL Routing pour Web Forms

WPF 4.0

• Support du multi-touch et extensibilité de la taskbar pour Windows Seven
• SDK de Surface 2.0
• Nouveaux contrôles (dont le Rubbon)
• Amélioration des performances, stabilité, ..

WCF & WF 4.0

• WF : Nouvelles Activities (lire http://bit.ly/12Htlb)
• WCF : Service de découverte, support du REST, service de routing

Et bien d’autre

• ParallelFx : Nouvelle API pour simplifier le développement parallèle comme TPL (Task Parrallel Library) ou PLINQ (Parrallel LINQ)
• MEF : Managed Extensibility Framework dont j’ai traité un article à ce sujet en début d’année

Et avant de finir, quelques liens :

• .NET Framework 4.0 Beta 2 (redistribuable) : http://www.microsoft.com/downloads/details.aspx?FamilyID=ded875c8-fe5e-4cc9-b973-2171b61fe982&displaylang=en
• Liste complètes des nouveautés de VS2010 : http://msdn.microsoft.com/en-us/library/bb385832(VS.100).aspx
• Annonce de Scott Gu : http://weblogs.asp.net/scottgu/archive/2009/10/19/vs-2010-and-net-4-0-beta-2.aspx
• Annonce de Jason Zander : http://blogs.msdn.com/jasonz/archive/2009/10/19/announcing-vs2010-net-framework-beta-2.aspx
• Site MSDN pour VS2010/.NET4 (Ressources et téléchargements) : http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx
• Téléchargement direct de Visual Studio 2010 Ultimate Beta 2 au format ISO : http://www.microsoft.com/downloads/details.aspx?FamilyID=dc333ac8-596d-41e3-ba6c-84264e761b81&displaylang=en

En préparant du contenu pour des sessions sur le futur de .NET (VS2010, .NET 4.0, C# 4.0 ou encore VB 10), j’ ai été amené à faire un petit tableau récapitulatif des dates et versions des principaux éléments de .NET : le framework, la CLR, l’ IDE Visual Studio et les deux principaux langages .net (C# et VB.net).

Un petit copier/coller pour vous en faire profiter :

A bientôt

Introduite dans la version 2.0 du framework, la classe StopWatch (dans l’ espace de nom System.Diagnostic) permet de mesurer facilement et d’ une grande précision de l’ ordre de la microseconde (0.000001 seconde).

Cette classe n’ est qu’ une abstraction de ce que l’ on devait faire avant sous .NET 1.x en utilisant la méthode QueryPerformanceCounter via un DllImport de kernel32.dll, simplifiant ainsi la mesure de temps. (En quelque sorte, une amélioration de ma classe PerfTimer que j’ avais utilisé pour mesurer mon algo de résolution de Mastermind il y a déjà quelques années ^^).

L’ utilisation de StopWatch est très simple. On crée notre objet StopWatch pour pouvoir appeler les méthodes Start et Stop qui vont respectivement permettre de démarrer et arrêter notre timer et on récupère le temps écoulé via les propriétés Elapsed, ElapsedMilliseconds, ou ElapsedTicks. (documentation MSDN de StopWatch).

Exemple très simple :

1
2
3
4
5

StopWatch stopWatch = new StopWatch();
stopWatch.Start();
// -- Code à mesurer ici --
stopWatch.Stop();
Console.WriteLine("Temps écoulé en ms : " + stopWatch.ElapsedMilliseconds.ToString());

Maintenant introduit à l’ objet StopWatch pour ceux qui ne connaissaient pas, revenons sur MySimpleWatch ! Historiquement, j’ avais réalisé l’ an passé une petite classe, enfin du moins une simple méthode dans un de mes projets, permettant grâce aux délégués et méthodes anonymes introduits dans C#2.0 d’ exécuter du code avant et après mon délégué. Plus récemment, mardi dernier, pendant une session sur « LINQ avancé » aux TechDays 2008, Mitsu nous donnait dans la même lignée une astuce pour démarrer/arrêter un StopWatch, ce qui m’ a donné l’ envie de récrire cela dans une belle classe que je pourrais utiliser un peu partout dans mes développements.

L’ idée est très simple : avoir une méthode prenant en paramètre une Action (code à exécuter) que l’ on mesurera. En résumé :

1
2
3

stopWatch.Start();
action();
stopWatch.Stop();

De plus, j’ ai ajouté la possibilité de passer un deuxième délégué dans cette méthode de type Action<Stopwatch> qui sera exécuté à la fin pour traiter le résultat du timer (par exemple pour écrire le résultat dans un log, Trace, etc…).

Le code de ma classe étant très simple, je ne rentre pas plus sur son explication, mais voyons plutôt son utilisation dans notre code.

MySimpleWatch contient trois méthodes publiques :

1. SimpleWatch : permet simplement d’ exécuter un bout de code en nous renvoyant un StopWatch contenant le temps d’ exécution de ce code.
2. DisplayWatch : exécute le code de l’Action et affiche le résultat dans la Console. (avec possibilité de donner un nom à la tache – utile si plusieurs résultats sont affichés dans la console !)
3. ProcessWatch : exécute le code de l’Action comme toujours puis exécute le deuxième délégué pour traiter la réponse en passant en paramètre le StopWatch du résultat (en clair un Action<Stopwatch>)

Rien ne vaut de bons exemples :

1) Afficher simplement la mesure dans la console :

1
2
3
4
5
6
7

MySimpleWatch watch = new MySimpleWatch();
 
watch.DisplayWatch(delegate
{
    // Code à mesurer ici ! Ex :
    Thread.Sleep(1000);
});

2) Obtenir le StopWatch d’un bout de code :

1
2
3
4
5
6
7
8
9
10

MySimpleWatch watch = new MySimpleWatch();
 
var result = watch.SimpleWatch(delegate
{
    // Code à mesurer ici ! Ex :
    Thread.Sleep(1000);
});
 
// Exemple de traitement du resultat :
Trace.WriteLine("Elapsed time in ms : " + result.ElapsedMilliseconds.ToString());

3) Exécuter du code pour traiter le résultat :

1
2
3
4
5
6
7
8
9
10
11
12
13

MySimpleWatch watch = new MySimpleWatch();
 
watch.ProcessWatch(delegate
{
    // Code à mesurer ici ! Ex :
    Thread.Sleep(1000);
},
delegate(Stopwatch w)
{ 
    // Code pour traiter le resultat ici !
    // Exemple:
    Trace.WriteLine("Elapsed time in ms : " + w.ElapsedMilliseconds.ToString());
});

En utilisant les expressions lambda introduitent dans C# 3.0, nous pouvons aussi simplifier le code par :

1
2
3
4
5
6
7

MySimpleWatch watch = new MySimpleWatch();
 
watch.ProcessWatch(delegate
{
    // Code à mesurer ici ! Ex :
    Thread.Sleep(1000);
}, (w => Trace.WriteLine("Elapsed time in ms : " + w.ElapsedMilliseconds.ToString())));

Voilà, j’ espère que cela pourra vous être utile Le code de la classe MySimpleWatch est disponible ici.

Un petit post rapide pour vous annoncez la sortie hier du site de Jacques Himpens que j’avais réalisé en Octobre dernier.

Jacques Himpens est d’abord un ami et artiste avec beaucoup de talent qui maitrise diverse technique comme la sculpture, peinture, assemblage, et j’en passe

Il n’y a qu’a visiter son site pour voir les nombreuses oeuvres qu’il a réalisées : tout simplement épatant (surtout en vrai !!).

Si je fais de la pub, c’est aussi pour moi et vous présentez mon travail de A à Z, de Photoshop à la mise en page XHTML/CSS en passant bien sûr par le développement coté serveur (asp.net) et coté client (js).

C’est aussi mon 1er site « Atlas », d’ailleurs le site tourne encore avec la Beta 2 d’ASP.NET Ajax (enfin non à cette époque on parle encore d’Atlas ). Vous retrouverez aussi l’implémentation de mon script Scroller présent aussi sur la Wygwam TV

Longue vie à www.jacqueshimpens.fr

Vous connaissez les graphiques en radar ? Mais si, ces sortes de graphique en étoile :

Je me suis amusé pendant mes heures libres a développer une petite classe de génération de graphique de type radar. Bon certe, qu’on se le dise tout de suite, face a Office 2007 mes graphiques ne valent pas grand chose mais au moins c’est facilement exploitable sous .NET

J’avais initialement écrit cela dans un contexte professionnel et puis je me suis dis que ça valait le coup de pousser le bouchon un peu plus loin de en faire quelque chose de facilement ré-exploitable dans mes (et vos ^^) développements prochains..

Au début, je me suis demandé comment j’allais faire… Et puis quelques minutes plus tard j’ai repensé a une classe que j’avais écrite l’an dernier sur les complexes et publiée sur ce blog en Avril 2006 : Les complexes, pas complexe !!!
Et en effet avec les complexes, il n’y avait plus rien de complexe

Explications : je connais la taille de graphique voulu (passée dans le constructeur de ma classe), donc je devine assez facilement la taille d’une branche ainsi que le centre de mon graphique; j’ai donc ma 1er droite.
Pour avoir mes autres droites, il me suffit tout d’abord de calculer l’angle en fonction du nombre de branche par le calcul :
2PI/Nb.Branches
Par exemple, pour un graphique a 6 branches, mon angle est 2PI/6 soit PI/3 radian ou 60° degré ! Il me reste donc plus qu’a effectuer une rotation de mon point initial A de l’angle PI/3 par rapport au centre et j’obtiens bien mon 2eme point B.

Pour la suite, c’est identique sauf que le prochain point sera une rotation de l’angle PI/3 * 2; pour le suivant PI/3 * 3, etc… jusqu’à ce qu’on fasse le tour !
Il ne me reste plus qu’a dessiner les X droites partant du centre jusqu’aux points calculés et j’ai déjà ma base :

Pour placer les valeurs, il n’y a toujours rien de compliqué. Comme je connais mon centre et mon point A, j’ai une petite méthode qui me renvoi la position en pixel de ma valeur (branchSize – ((pourcentage * branchSize ) / 100)). Par exemple. 100% revient a placer le point sur le point A, par contre 0% sur le centre, 50% a mi-chemin entre le centre et le point A !
La 1er valeur est placée ! Pour le reste, je fais de même : je place ma valeur sur la 1er droite puis j’applique une rotation pour la placée sur la bonne branche et le tour est joué Il ne me reste plus qu’a mettre le tout dans un tableau de Point et de l’envoyer à la méthode DrawPolygon() de l’objet Graphic :

Comme quoi les complexes simplifient vraiment la vie Au final, nous n’utilisons que la méthode Rotation() du complexe a déplacer en lui passant comme argument l’angle (double) de rotation et le centre (complexe). J’ai quand même effectué quelques changements dans cette classe pour :

• Proposer un constructeur prenant un objet Point; afin de construire un complexe facilement a partir d’un point
• Proposer un accesseur get/set de type Point pour facilement passer d’un point à un complexe et vise vers sa !
• Ré-ecrire en plus propre (oui, oui, en 10mois on fais des progrès )

Pour plus d’infos sur ma classe Complexe, je vous renvoie ici !

Utilisation : l’utilisation de ma classe de génération est vraiment très facile !
Tout d’abord, nous allons générer une liste de RadarItem contenant les valeurs, couleurs, noms etc.. des séries de votre graphique ! Ensuite nous construirons l’objet RadarChart pour appeler la methode GenerateChart qui vous renverra une simple image !

1ère étape : la liste de ChartItem
L’objet RadarItem représente les informations pour une série. Elle contient un tableau de double pour les valeurs, un Pen pour dessiner, un string pour le nom de la série et la possibilité de mettre un Brush pour remplir le polygon ! Exemple :

1
2
3
4
5

List<RadarItem> liste = new List<RadarItem>();
liste.Add(new RadarItem(new double[] { 20, 45, 38, 85, 34 },
              new Pen(Brushes.Blue), "Serie 1"));
liste.Add(new RadarItem(new double[] { 30, 18, 23, 52, 69 },
              new Pen(Brushes.Red), "Serie 2"));

Nous créons ici une liste de 2 séries : « Serie 1″ et « Serie 2″, de couleur bleu et rouge avec les valeurs passées dans le tableau de double.
Si il n’y a pas assez de valeurs qu’il n’y a de branches, alors les valeurs manquantes seront initialisées à 0. Si à l’inverse, il y a trop valeurs qu’il n’y a de branches, les valeurs en trop ne seront pas dessinées !

2ème étape : construction de l’objet RadarChart
Une fois notre liste de valeur prête, nous allons construire notre objet RadarChart ! L’objet propose plusieurs constructeurs car vous avez la possibilité de définir :

• La taille de l’image générée
• Le nombre de branche (qui doit être > 3)
• Le padding : marge à gauche et marge en haut
• Le stylo (Pen) pour dessiner la base
• La nombre de graduation (int)
• Un tableau de string : pour les labels placés sur les branches
• Font et Brushes : pour définir la police et couleur des labels
• La couleur du fond

Exemple concret :

1
2
3
4
5
6
7

RadarChart myGraph = new RadarChart(370, 350, 5,
                new Size(30, 30), new Pen(Brushes.Gray),
                5, new string[] { "Perf", "Rapidité",
                         "Communauté", "Simplicité",
                         "Portabilité" },
                new Font("Arial", 8), Brushes.Black,
                Brushes.White);

Nous construisons ici l’objet myGraph qui retournera une image de 370×350 avec 5 branches, une marge de 30px sur la gauche et le haut, une base dessinée en Gray (gris) avec 5 niveaux de graduation. Les branches auront les libellés : Perf, Rapidités, …. et seront écrit en Arial, taille 8 de couleur noir et le tout sur un fond blanc !
Graphiquement, cela donne :

3ème étape : génération du graphique
Une fois notre objet construit, il ne nous reste plus qu’a générer notre graphique par la méthode GenerateChart() qui nous retournera une Image.
Le 1er argument est notre liste de RadarItem (liste des séries). Ensuite les 3 arguments optionnels sont :

• bool drawLegend : dessine la légende
• bool drawValues : affiche les valeurs
• bool drawPoint : dessine les points

J’ai donc placé une PictureBox sur une form et placé le code :

1
2

pictureBox1.Image = myGraph.GenerateChart(liste,
                true, true, true);

Ce qui nous retourne l’image :

Alors c’est compliqué de générer des graphiques ? Vive les complexes ! Avec les sources trouverez un projet Winform avec une form de démo permettant de tester plusieurs graphiques à l’exécution :

Ce n’est pas une version finale, il faudrait y mettre des accesseurs aux propriétés passées dans le constructeur pour permettre de modifier le graphique sans pour autant recréer un objet. Et graphiquement il y a aussi des petites qui peuvent être revu comme la légende, placement des labels et valeurs, etc… mais là plus le temps

Si un jour vous avez besoin de générer des graphiques de ce type n’hésitez pas !! Les commentaires/suggestions/critiques sont les bienvenues

Télécharger le projet

(ps: je ne sais pas si je dois encore le dire, mais c’est codé en c# sous .NET 2.0 ^^)