En février, RedGate le repreneur de Reflector annonçait avec la venue de Reflector 7, la fin de la gratuité de Reflector. Suite à cela, j’ai écrit un petit pamphlet sur ce changement brusque, sur ma déception et surtout sur les alternatives telles qu’ILSpy ou JustDecompile.

La grogne des développeurs se fit entendre et RedGate reçut tellement de critiques qu’ils se décidèrent à laisser une version gratuite de Reflector mais attention, il ne s’agit que de l’ancienne version de Reflector, la version 6. La version 7 et les versions postérieures resteront toutes payantes.

RedGate a néanmoins mis ses conditions sur cette version gratuite : la version 6.8.

1. Tout d'abord, cette version n’est PAS téléchargeable. Vous devez posséder une ancienne version de Reflector (je vous conseille de chercher la version 6.6 que l’on trouve sur plusieurs sites de stockages tels MegaUpload
2. Une fois téléchargée et lancée, la version 6.6 va vous proposer d’installer la version 7. Vous devez refuser. À la place, cliquez sur le menu Help > Check for Update qui aura pour effet de télécharger la version 6.8
3. Cette fois-ci, le logiciel va vous demander de vous enregistrer (voir capture). Vous recevez alors par mail une clé à activer dans Reflector. L’activation sera possible pour 5 machines

Un détail important, cette version n’est plus supportée par RedGate et aucun support par leur forum ou autre sera rejeté automatiquement. Heureusement, on peut dire que la version 6.8 est aboutie et très stable (en plus d’être très complète)

J’en profite pour dire que JetBrains a sorti son décompileur gratuit nommé dotPeek. Celui-ci est clairement au dessus des autres alternatives gratuites, mais pas encore au niveau de Reflector et ses plug-ins. Cette version gratuite de Reflector arrive à point pour laisser la concurrence se développer et en espérant que le futur, aidé de plusieurs produits, nous garantisse de ne pas revivre un épisode de perte de non-gratuité fort désagréable.

Il y a peu, je crachais mon venin sur Red Gate suite à la suppression de la version gratuite de Reflector, cet outil magique qui sauva la vie de bien des développeurs. J’en profitais pour parler du projet ILSpy, un projet open-source pour refaire vivre une version gratuite de Reflector mais loin de Red Gate.

Et bien à côté de cela, probablement à cause de l’annonce de Red Gate, Telerik, le célèbre éditeur des suites de composants s’est lancé dans un projet gratuit, le décompileur JustDecompile.

Le projet n’est qu’en bêta et cela se sent puisqu’il a crashé au premier projet que j’ai chargé et quelques résultats bizarres mais le produit reste encourageant. J’encourage donc les gens à surveiller ce petit produit mais en gardant la priorité pour ILSpy qui ne tombera pas sous la coupe d’un éditeur qui pourrait un jour décider d’en faire un objet mercantile.

D’ailleurs, j’en profite pour dire qu’ILSpy a déjà atteinte le milestone 2 avec plein de nouveautés sympas dont :

• le support des query expression
• du mot clé yield
• du code unsafe
• plein d’autres petites choses

Le projet avance bien et ca fait plaisir!

Ce petit billet a pour objectif de mettre en avant un petit logiciel nommé ILSpy (et géré par la SharpDevelop Team) qui a pour objectif d’être le remplaçant gratuit du célèbre décompilateur .Net : Reflector.

Si ILSpy n’en est qu’à ses débuts et est encore bien loin de son prédécesseur, il peut déjà tirer parti de l’expérience de ce dernier et apporter on l’espère, rapidement de nouvelles fonctionnalités. Le produit n’en est qu’à la M1 de sa toute première version, mais permet déjà d’être utilisé au jour le jour pour décompiler des assemblies.

On est très loin du système de plug-ins que permet Reflector mais en tant que fonctionnalité principale, la décompilation est présente et cela devrait convenir à la plupart des utilisations. Ce dernier est téléchargeable sur le site officiel : http://www.ilspy.net/

Comme je l’expliquerai plus bas dans ce post, suite à l’annonce de rendre payant un logiciel qui était gratuit depuis 10 ans, j’encourage tous les développeurs à préférer ILSpy et aider à son développement et ne garder Reflector qu’en cas de réel besoin où ILSpy ne saurait aider.

Mais pourquoi tant de haine?

Un peu d’histoire:

• En 2000, Lutz Roeder créé Reflector. Rapidement ce petit outil évolue et devient le petit couteau suisse utilisé par un tiers des développeurs .Net.
• En aout 2008, il s’accorde avec Red Gate Software pour la reprise du développement du logiciel, où Red Gate (cf James Moore son responsable du développement) s’engage à sortir rapidement version 6 du logiciel et à le maintenir gratuitement pour tous.
• En 2010, ils proposent un reflector premium quasi identique à la version gratuite, mais permettant de faire rentrer un peu d’argent pour réduire les coûts de développement.
• En février 2011, la version gratuite de Reflector cessera d’exister à partir de juin 2011 et se retrouve payante pour 25€ (35$) pour sa version la plus simple et jusqu’à 69€ (95$) pour sa version la plus complète.

On obtient donc une société qui reprend un logiciel gratuit pour finalement le rendre payant sans même avoir tenté le mode donation. Pourtant, les donations peuvent faire vivre un projet et les exemples courent les rues (Wikipédia, Mozilla, etc.). Encore récemment, Xmarks (synchronisation de favoris inter-navigateurs) devait fermer ses portes, mais les gens ont dit être prêts à payer un peu (quelques dollars) pour faire vivre les serveurs. Et XMarks est encore là et pourtant cela ressemble comme deux gouttes d’eau à l’histoire de Reflector. J’en veux donc à Red Gate d’avoir tout de suite envisager de tirer des bénéfices de Reflector (même si je ne renie pas les coûts qu’ils ont enduré pour son support depuis trois ans - mais ils le savaient en s’engageant!) et apprécie fortement cette initiative de projet ILSpy. Je trouvais donc nécessaire de faire passer le message pour encourager ce nouveau projet.

Pourquoi absolument refuser d’utiliser une application sous prétexte qu’elle soit payante?
Le fait qu’elle soit payante n’est pas un problème, surtout que le prix n’est pas excessif, mais tout d’abord cette nouvelle version n’apporte pas grand chose et les gens semblent d’ailleurs s’en interroger sans obtenir de réponse, mais c’est surtout parce que Reg Gate revient sur sa parole lorsque la société disait avoir repris le bébé de Lutz uniquement pour l’améliorer mais surtout le garder gratuit pour tout développeur.

Pourquoi supporterai-je une société qui, dans un dessein mercantile, a profité du buzz autour d’un produit gratuit pour ensuite tuer son côté ouvert et dédié à la communauté comme le souhaitait son auteur originel?

Un petit détail, pour ceux qui pensent pouvoir utiliser les anciennes versions gratuitement, celui risque d’être difficile. En effet, les exécutables sont time-bombés pour une période de six mois. Passé ce délai la mise à jour est obligatoire et l’application ne se lance plus. Bien que ce time-bombing n’ait surement pas été mis là par Red Gate pour forcer l’achat de la nouvelle version, ces derniers tiennent deux discours quant à cette fonctionnalité:

• Première raison: le support était facilité. en forçant les personnes à utiliser une version récente, on évite la remontée de bugs déjà corrigés
• Seconde raison selon Greg Tillman, ce time-bombing était déjà implémenté par Lutz (le créateur) depuis les toutes premières versions. Ceci est en partie vrai, mais si l’update était proposé, il n’était pas obligatoire et l’on pouvait utiliser la version désuète. C’est donc bien Red Gate qui a implémenté cette fonctionnalité et refusé de la retirer depuis 2008.

A chacun de se faire son opinion, mais pour moi, Red Gate a fait le choix d’investir dans un produit gratuit et aurait dû le laisser gratuit ou bien le laisser se faire maintenir par la communauté. Il y avait un but mercantile derrière cet achat (ils ne le cachent pas => promotion d’Ants profiler / SQL Compare) mais c’est maintenant un retour en arrière sur leurs promesses et surtout un retour en arrière pour la communauté des développeurs.

Longue vie à ILSpy!

Le twitter d’ILSpy

Lorsqu’un client a un problème particulier ou même lorsque les employées (plus spécialement les consultants) ont un souci pointu avec un produit ou une technologie, ils font appel aux équipes support, ces personnes qui connaissent les produits aussi bien que ceux qui les ont créées. Ce sont ces mêmes personnes qui, observant qu’un certain nombre de requêtes revenaient encore et encore, ont eu l’idée de créer le All-in-One Code Framework, un regroupement d’exemples de code tentant de couvrir les cas d’usages les plus courants de chaque technologie. Par exemple, pour de l’ASP.Net, vous trouverez une cinquantaine d’exemples comme :

• Mettre en place un téléchargement de fichier avec ASP.Net MVC
• Mettre en place d’un cache
• Créer un flux RSS
• Handler HTTP personnalisé
• Ajouter l’AJAX AutoCompleteExtender
• Faire un chat Web en AJAX
• Avoir la liste des utilisateurs actuellement connectés (même sans MemberShip)
• Partager une session entre différents domaines
• Implémenter Bing Map
• Lancer des batchs/cmd depuis une page Web
• Gestion des thèmes
• etc.

Au total, c’est plus de 500 exemples, augmentant chaque semaine, et sur une vingtaine de technologies différentes :

• ASP.NET
• Silverlight
• Windows Azure
• WPF
• Windows Forms
• Windows 7
• Data Platform
• Office Development
• Windows Workflow
• Interop and Fusion
• Windows Base and .NET General
• Windows UI
• Security
• Windows Shell
• XML
• COM
• IPC and RPC
• Diagnostics
• Visual Studio Extensibility
• File System
• IIS
• Windows Service

Le tout, téléchargeable pour l’avoir à disposition. Une fois sur votre ordinateur, une interface vous permet de lister les projets d’exemples, de voir leur description puis de les lancer directement si vous le souhaitez.

 

Vous pouvez découvrir ce framework sur codeplexet je vous encourage très fortement à le faire!

L’autre jour, petit problème chez un client concernant un add-in VSTO pour Outlook. Celui-ci est composé de différent rubans personnalisés via des fichiers XML (donc sans designer) et étend les fonctionnalités de gestion de mail notamment en permettant un enregistrement en base de données.

La demande du jour était alors de rendre cet add-in plus facilement modifiable, et surtout localizable (gestion du multilangue).

Ma solution fut alors d’utiliser des fichiers de ressources et surtout au niveau de chaque contrôle du ruban, d’utiliser une méthodologie la plus générique possible pour pouvoir un code facilement maintenable : l’utilisation de callbacks communs.

Ainsi, nous obtenions un code xml simple :

<button id="AddMinute"
                  onAction="btnNewMinute_Click"
                  imageMso="QueryShowTable"
                  getLabel="GetLabel"
                  getDescription="GetDescription"
                  getScreentip="GetScreenTip"
                  getSupertip="GetSuperTip"
                  size="large"
                  />

 

Et un code-behind relativement simple

       /// <summary>
       /// Callback method to return the label of the control
       /// </summary>
       /// <param name="control">The control which launchs the callback</param>
       /// <returns>The label of the control</returns>
       public string GetLabel(IRibbonControl control)
       {
           return Ressources.UILabels.ResourceManager.GetString(control.Id);
       }
       /// <summary>
       /// Callback method to return the ScreenTip of the control
       /// </summary>
       /// <param name="control">The control which launchs the callback</param>
       /// <returns>The ScreenTip of the control</returns>
       public string GetScreenTip(IRibbonControl control)
       {
           return Ressources.UILabels.ResourceManager.GetString(control.Id + "ScreenTip");
       }
       /// <summary>
       /// Callback method to return the SuperTip of the control
       /// </summary>
       /// <param name="control">The control which launchs the callback</param>
       /// <returns>The SuperTip of the control</returns>
       public string GetSuperTip(IRibbonControl control)
       {
           return Ressources.UILabels.ResourceManager.GetString(control.Id + "SuperTip");
       }
       /// <summary>
       /// Callback method to return the description of the control
       /// </summary>
       /// <param name="control">The control which launchs the callback</param>
       /// <returns>The description of the control</returns>
       public string GetDescription(IRibbonControl control)
       {
           return Ressources.UILabels.ResourceManager.GetString(control.Id + "Description");
       }

 

Ce qui permet d’ajouter autant de contrôles que nécessaire et gérer leur affichage via des fichiers de ressources.

 

Seul problème, à partir du moment où l’on indique des qualified id (idQ), les callbacks sont désactivés et ne s’exécutent plus. Ainsi, le fait de passer de <button id="AddMinute"  à <button idQ="lgm:AddMinute" empêche la solution de fonctionner et si l’addin semble marcher parfaitement, les labels, ne sont eux, pas chargés.

Le problème vient en réalité du namespace déclaré dans le XML

 

<customUI onLoad="Ribbon_Load"  xmlns="http://schemas.microsoft.com/office/2006/01/customui"
 xmlns:lgm="RibbonAddin">

 

Celui-ci doit être déclaré mais surtout, correspondre au namespace de votre code-behind (normalement le namespace de votre projet d’addin). Ainsi le namespace suivant rend les callbacks inopérants

xmlns:lgm="any-other-namespace-is-a-bad-idea">

 

C’est un détail mais l’oublier peut simplement vous rendre fou et vous faire perdre plein de temps!

Pour la nouvelle version d’un site personnel, je me suis décider à implémenter le repository pattern avec Entity Framework 4.0 complété par l’utilisation des templates T4 pour me faciliter la tâche. Passer la tâche de déclarer mes interfaces de repository et mes services, je souhaite maintenant aller plus loin dans mon implémentation car je voudrais être en mesure d’utiliser les data annotations, ces data contracts qui permettent de définir au niveau de votre modèle vos règles de validation.

L’intérêt de l’utilisation des templates T4 est de générer ces attributs automatiquement, afin de pouvoir en tirer partie au sein de la validation automatique de mon projet Web, un portail ASP.Net MVC.

La tâche est un peu compliquée qu’elle n’en a l’air, il faut en effet :

• analyser le SSDL (Storage Schema Definition Langage) pour lire les metadonnées de chaque entité et de ses champs
• générer de façon dynamique ces attributs sans action de l’utilisateur
• être en mesure de prendre en compte les mises à jour du modèle sans perdre les modifications existantes

La première problématique consiste à créer des attributs de façon automatique. Cela signifie que certains attributs comme les Range ou les expressions régulières ne seront pas disponibles car non décrits dans le SSDL.

Il nous faut tout d’abord télécharger le template ADO.NET C# POCO Entity Generator pour générer nos classes POCO afin d’implémenter ce pattern permettant d’être indépendant de la source de données. Cette solution permet en plus de pouvoir faire de l’IoC (Inversion of Control) grâce au pattern, de regénérer, grâce aux T4,les classes modèles autant de fois que nécessaire si jamais le CSDL (Conceptual Schema Definition Langage) venait à changer. Malheureusement, du fait du fonctionnement des templates T4, cela signifie qu’à chaque fois que l’on regénèrerait les classes POCO, les fichiers contenant celles-ci seraient détruits puis recréés, supprimant au passage toutes les modifications manuelles que le développeur aurait pu ajouter pour étendre celles-ci.

Il est donc nécessaire de placer ces attributs dans un fichier différent des classes POCO mais comment alors faire en sorte que ces attributs soient liés aux membres de nos classes POCO? Les classes partielles? Impossible, il faudrait pour cela redéfinir un membre et une erreur de compilation apparaitrait. La solution passe alors par l’utilisation de MetaData, un mécanisme permettant de définir une classe contenant les metadata d’une seconde classe.

En voici un exemple simple :

[MetadataType(typeof(ArticleMetaData))]
public partial class Article
{
    string Auteur { get; set; }
    string Titre { get; set; }
}

public class ArticleMetaData
{
   [Required]
   [StringLength(255)]
   private string Auteur;
}

Nous avons notre classe POCO sur laquelle nous indiquons via l’attribut MetaDataType la classe qui contiendra les metadonnées. Celle-ci ne contient que les champs sur lesquels nous souhaitons ajouter des annotations et sur chaque membre peut se placer une ou plusieurs annotations.

Pour notre problématique de génération future des classes POCO, il est donc nécessaire de générer ces classes de metadata dans différents fichiers que ceux de la classe POCO et pour être plus précis, il sera même nécessaire de faire en sorte de posséder un template T4 pour générer les metadata et un autre pour générer les POCO, afin de pouvoir recréer les POCO autant que possible. Bien entendu, il n’existe pas de solution parfaite et il faudra créer les metadata futures à la main mais néanmoins, pour le début de projet c’est beaucoup de temps gagné.

Ainsi donc, la première modification à réaliser consiste à modifier le template T4 par défaut (celui qui génère les classes POCO) et d’y ajouter à la ligne 42 (juste avant la déclaration d’une classe), la ligne suivante

[MetadataType(typeof(<#=code.Escape(entity)#>MetaData))]

La seconde étape consiste à créer un second template T4, copie du premier (sans la ligne ajoutée juste avant), dans lequel vous enleverez tout le code servant à générer les propriétés de navigations et les fixup d’associations. Vous rajouterez ensuite dans la méthode WriteHeader la ligne suivante:

using System.ComponentModel.DataAnnotations;

Enfin, ligne 52, juste avant la création des propriétés, ajoutez le bloc de code suivant qui permet d’ajouter les attributs Required et StringLength lorsque nécessaire.

<# // begin max length attribute
if (code.Escape(edmProperty.TypeUsage) == "string")
{
  int maxLength = 0;
  if (edmProperty.TypeUsage.Facets["MaxLength"].Value != null && Int32.TryParse(
          edmProperty.TypeUsage.Facets["MaxLength"].Value.ToString(),
          out maxLength))
  {
#>    
    [StringLength(<#=code.CreateLiteral(maxLength)#>, 
       ErrorMessage="Ce champ ne peut depasser 
            <#=code.CreateLiteral(maxLength)#> caracteres")]
<#
   }
}
    // begin required attribute
  if (edmProperty.TypeUsage.Facets["Nullable"].Value.ToString() =="False")
  {
#>
    [Required]
<#
    }
#>

et c’est tout. Pour chaque entité, une classe de metadonnées sera créée et chaque fois que la propriété ne doit pas être nulle ou que sa longueur est définie en base alors l’attribut correspondant sera ajouté. Il ne reste alors qu’à ajouter les attributs complémentaires correspondant à notre logique métier (Range, etc).

Ci-joint, le fichier T4 complet

Il y a quelques jours est sortie la version RC2 d’ASP.Net MVC 3, cette troisième, et toujours plus aboutie, version

du modèle Modèle-Vue-Contrôleur appliqué au Web et utilisant la technologie ASP.Net.

Bien avant de travailler pour Microsoft, j’avais pour métier de développer des applications Web pour le milieu bancaire. Dans ce contexte, j’utilisais exclusivement ASP.Net standard et fut tout excité à la sorte de première version d’ASP.Net MVC. Malheureusement, je me suis rapidement confronté à des limitations qui m’empêchaient de faire facilement avec ce nouveau ASP.Net MVC ce que je faisais en ASP.Net standard.

Les choses ont bien changées car aujourd’hui, ASP MVC 3 est plus complet que jamais et améliore une version 2 qui faisait déjà partie du fleuron du développement Web. Ceux qui comme moi avaient parié sur ASP.Net MVC devraient être rassurés sur leur choix.

Voici donc une présentation des principales nouveautés d’ASP.Net MVC 3

Un nouveau moteur de rendu : Razor

Il est difficile de parler d’ASP.Net MVC 3 sans commencer par parler de son nouveau moteur de rendu nommé Razor. Ce moteur de rendu, ou plutot ce moteur de template, permet de simplifier le code XHTML de vos vues pour y insérer plus facilement du code inline. Et oui, le principe de tout mettre en code-behind n’étant pas le but du pattern MVC, il est nécessaire de mettre votre logique d’affichage au sein de la vue. Ce nouveau moteur va vous permettre de rendre le code plus lisible, moins verbeux et de mieux différencier le code “statique” XHTML du code C#.

le typage de vos pages

Là où le typage en ASP.Net MVC 1 était verbeux

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/OneColumn.master" Inherits="System.Web.Mvc.ViewPage<lgmorand.model.Book>" %>

Celui est devenu très simple avec Razor

@model lgmorand.model.Book

Plus d’héritage inutile ou encore de déclaration de masterpage, celle-ci étant devenue implicite.

Le code inline

Là encore, le code est épuré au maximum. Vous aviez

<table>
    <tr>
    <% foreach (var item in Model) { 
           if(count %3 == 0 && count !=0)    
           Response.Write("</tr><tr>");
     %>
    
    <td style="width:33%" align="center">
        <a href="../Books/Details/<%= Html.Encode(item.Id) %>" rel="#overlay2"> 
            <img src="../../HttpHandlers/Image.ashx?ID=<%=item.IMAGES.Id %>&thumb=1" alt="cover" class="bordered cover"  />
            <br /><%= Html.Encode(item.Title) %>
            
        </a>
        <br /><img src="../../Content/Images/note/kitstars-<%=item.Note %>.gif" alt="<%=item.Note %>" />
    </td>
    
    <%
    count++;
       } 
     %>
    </tr>
</table>

Pour devenir

<table>
    <tr>
    @foreach (var item in Model) 
    {
        if (count != 0 && count % 3 == 0)
        { 
            @:</tr><tr> 
        }
            
        
                <td style="width:33%" align="center">
                    <a href="../Books/Details/@(item.Id)" rel="#overlay2"> 
                        <img src="../../HttpHandlers/Image.ashx?ID=@item.Images.Id&thumb=1" alt="cover" class="bordered cover"  />
                        <br />@item.Title
            
                    </a>
                    <br /><img src="../../Content/Images/note/kitstars-@(item.Note).gif" alt="@item.Note" />
                </td> 
        
            count++;
        
       } 
     
    </tr>
</table>

Plus facile à lire, plus facile à éditer.

La mise en page

Là encore, sans rien changer au principe de mise en page d’ASP.Net (avec masterpages ou contentplaceholders)

La masterpage est devenue implicite et pas défaut, chacune de vos vues utilisera votre masterpage à moins que vous ne surchargiez les paramètres de la pages pour la supprimer ou en définir une autre :

@{
    Layout = "~/Views/Shared/_OneColumnLayout.cshtml";
}

Quant aux contentplaceholders, ceux-ci sont devenus des sections, qui plus est, peuvent être optionnels. Là où vous aviez:

<asp:Content ID="Content3" ContentPlaceHolderID="contentBodyCustomSub" runat="server">
class='sub'
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="contentHeaderCustomSub" runat="server">
class='sub'
</asp:Content>

<asp:Content ID="Content4" ContentPlaceHolderID="BlueTopSub" runat="server">
</asp:Content>

Vous aurez (en remarquant que BlueTopSub n’a pas besoin d’être défini)

@section contentBodyCustomSub
{
    class='sub'
}

@section contentHeaderCustomSub
{
    class='sub'
}

Pour finir, des améliorations sur l’intégration de Razor dans Visual Studio. Si des menus contextuels pour la création de vue ou de contrôleurs étaient déjà présents, c’est maintenant des fenêtres de création de projet ou de création de vue qui ont été revus et améliorés.

A noter que Razor supporte le CHTML pour le C# et le VBHTML pour le VB.Net, chacun ayant les mêmes fonctionnalités mais de légères différences quant aux directives.

Les nouveautés de l’UI

Comme vu précédemment, Razor s’intègre parfaitement aux différentes nouvelles fenêtres utilisées au sein de Visual Studio. Il en va de même pour l’intégration des moteurs de rendu car ASP.Net MVC 3 permet de définir soi-même son propre “view-engine”.

 

Nouveautés concernant la validation

Il est maintenant possible de désactiver la validation d’un champ notamment lorsque celui-ci va contenir du code HTML. Il suffit dorénavant d’appliquer l’attribut [SkipRequestValidation] sur la propriété correspondante du modèle validé.

La validation distante : grosse nouveauté, celle-ci permet de valider une partie du formulaire en faisant un appel serveur limité. Pour plus de clarté et surtout pour découvrir son implémentation, je vous renvoie vers un tutoriel online.

Nouveautés diverses

Le support des redirections permanentes : l’utilisation de HttpNotFoundResult, de HttpRedirectResult  et de HttpStatusCodeResult vont vous permettre de contrôler les redirections de vos applications Web.

public ActionResult NotFound()
{
    return HttpNotFoundResult();
}

De nouveaux helpers : des helpers pour inclure Twitter, Captcha, Bing, Gravatar, Analytics, inclure des vidéos player, etc

@Twitter.Profile("lgmorand");

Amélioration de l’injection de dépendance : quasiment tous les éléments peuvent être substitués par IoC (Controlleurs, Vues, Action Filters, Model Binders, Value Providers, Validation Providers, et Model metadata Providers )

Les propriétés de View dynamique : le principe est simple, la vue est devenue un objet dynamique sur lequel vous pouvez ajouter des objets directement. Ainsi au lieu de faire ViewData[“valeur”] = “ce que vous voulez”, vous aurez dorénavant ViewBag.Valeur=”ce que vous voulez”;

Pour un exemple plus parlant, je vous renvoie au blog d’Hajan.

Voici donc une liste des nouveautés qui m’ont le plus plu dans cette nouvelle version et si jamais vous n’avez pas encore sauté sur l’occasion d’aller tester cette release, il est temps de le faire!

Lors d'un bon cycle ALM, il est important de s'intéresser à la couverture de code pour voir si notre stratégie de tests est bien configurée et si l'on se protège d'éventuels bugs qui auraient pu être détéctés au plus tôt.

C'est donc cette optique que certains de mes projets persos ont été inclus au sein de mon serveur TFS pour passer en intégration continue. Si tout se passait merveillement bien sur le serveur TFS (compilation, testing, coverage), il n'en n'était pas la même chose en local sur mon poste de développement. En effet, l'onglet Code Coverage m'indiquait un magnifique "Cannot find any coverage data (.coverage or .coveragexml) files."

la première raison fut que je n'avais pas configuré le code coverage pour mon projet. Pour cela, quelques étapes sont nécessaires:

1- Double-cliquez sur le fichier Local.testsettings situé au niveau de votre solution. (ou créez-le s'il est manquant)

2- Dans la partie gauche, cliquez "Data and diagnostics"

3- Cochez la case "Code Coverage"

4- Cliquez une fois sur la ligne Code Coverage afin d'activer le bouton "Configure" situé au dessus de la liste

5- Cliquez alors sur le bouton "Configure" afin d'ouvrir la liste des assemblies à tester

6- Cochez les assemblies de votre choix. Fermer tout en sauvegardant votre projet

7- Lancez les tests unitaires via le menu Test > Run > Tests in Current Context

8- Les résultats apparaissent alors dans la fenêtre Test > Windows > Code Coverage Results

 

SAUF QUE, parfois cela ne suffit pas et le message indiquant qu'aucun fichier de coverage n'est présent est toujours affiché. Et c'est là le problème car Visual Studio n'est alors d'aucune aide pour trouver l'origine du problème. L'indice se trouve en effet dans le journal des événements. Au sein de ce dernier, plusieurs erreurs liées à Visual dont une avec un message intriguant "The web.config file for the site http://localhost:0/ contains information from a previous run" et une seconde indiquant que l'accès au fichier web.config est refusé. Pour ce dernier, rien de plus simple, il suffit d'enlever le mode read-only du fichier mais pour le second, il faut enquêter.

Il semblerait que lors de l'ajout du projet à TFS, certains attributs soient ajoutés au fichier de configuration et que ceux-ci dérangent Visual Studio. Solution simple: les retirer.

il s'agit des lignes suivantes:

<appSettings>
    <add key="microsoft.visualstudio.teamsystems.aspnetdevserver:/" value="3311;True;3204;1" />
    <add key="microsoft.visualstudio.teamsystems.backupinfo" value="1;web.config.backup" />
</appSettings>

 

Supprimez-les donc, sauvegardez et relancez les tests unitaires

 

Et voilà, le code coverage est pleinement fonctionnel!!!

 

 

Je vous en parlais il y a tout juste un mois, le challenge Azure que j'ai mis en place sur Developpez.com avec l'aide de Jérôme Lambert et Philippe Vialiatte, vient de se terminer.

 

Autant dire que cela fut un franc succès puis qu'alors que nous espérions à peine une centaine d'inscrits, ce ne fut pas moins de 700 personnes qui tentèrent l'aventure et sur ces 700 personnes, pratiquement 60 réussirent les 5 étapes. Si l'on veut être précis, sur les 700 inscrits, seuls 210 firent la première étape qui ne consistait qu'à uploader un fichier, soit 500 inscrits qui étaient venus en touristes. Donc au final, c'est quasiment 30% des inscrits qui finirent le challenge. Un concours avec 30% de gagnants, vous en connaissez beaucoup? :)

 

Comment cela se passe-t-il maintenant? Et bien, les gagnants vont chacun recevoir un t-shirt détecteur de Wifi

mais puisque celui-ci devrait mettre plusieurs semaines à arriver, chaque gagnant recevra également une Arc Mouse, la nouvelle souris supra design de Microsoft d'une valeur de 50€.

Au final, c'est environ 70€ de lot offert à chaque gagnant, ce qui, avec nos moyens qui sont environs de....zéro euros, n'est pas mal du tout je trouve :)

 

 

 

 

C'est donc fini pour ce PREMIER challenge car bien entendu, nous comptons bien réitérer l'opération car la plupart des personnes semble vraiment avoir apprécié ce petit défi technique tout en apprenant de nouvelles choses.

Cette dernière semaine (ouais car on adore faire ça à l'arrache), avec Thomas Lucchini (Microsoft), Pierre Couzy l'évangéliste (Microsoft), Jérome Lambert (Developpez) et Philippe Vialiatte (Developpez), nous avons pondu un petit portail à base de technos toutes fraiches (entity fx 4.0, ASP .Net MVC 2, etc) qui a pour but de gérer un challenge et pas n'importe quel challenge, le challenge Azure!!!

 

Qu'est-ce donc que cette bête?

C'est simple, au fil de 5 épreuves, vous allez prendre en main l'environnement Azure mais également l'environnement de développement Azure (Visual Studio), pour déployer différentes application Web sur Azure. Rien de bien compliqué et pourtant très instructif.

 

Le plus beau dans l'histoire c'est qu'il y a des cadeaux à gagner et notamment des t-shirts détecteurs de Wifi offerts généreusement par Microsoft. et ouais, on est pas des geeks pour rien :)

Courrez vite participer au challenge, les cadeaux sont en nombre limités!