Dot.Blog

C#, XAML, Xamarin, UWP/Android/iOS

Blend 2 n'appelle pas VS 2008 mais VS 2005 : la solution [edit]

Voilà un truc agaçant : vous possédez les derniers softs de la dernière technologie de la mort-qui-tue et voila que pour créer le gestionnaire du "click" d'un bouton dans Blend 2 ce dernier vous dit que vous n'avez pas Visual Studio et qu'il a copié le code dans le presse-papiers. Il va falloir lancer à la main VS 2008, ouvrir le fichier cs qui va bien et faire un "coller" à la mimine. Back to the préhistoire ? Non : bug.

En fait ce bug est de type "registry". Lorsque VS s'installe il renseigne une clé de la registry qui indique son CLSID. Ainsi, les autres produits MS peuvent savoir quelle version de VS appeler. C'est simple et c'est bien vu. ... sauf qu'il manque un petit test pour s'assurer qu'on ne "régresse" pas dans les versions par exemple. Et c'est le cas si vous avez installer SQL Server 2005 après VS 2008.

Je parle de la version complète, pas la version Express de SQL Server 2005, la version qui installe... VS 2005 pour BIDS notamment. Et dans ce cas, la dernière version installée de VS est bien 2005 qui joyeusement et sans rien tester colle son CLSID à la place de celui de VS 2008. Moralité, soit Blend 2 appelle VS 2005 (ce qui est dommage pour le support du framework 3.5 !), soit vous avez désinstallé VS 2005 et Blend 2 ne le voyant pas (et ne cherchant pas VS 2008) vous propose de coller vous même le code du gestionnaire d'événement qu'il vient de créer...

C'est un bel exemple qui illuste à quel point tout informaticien doit rester humble même lorsqu'il a créé une application extraordinaire... ça finira toujours par péter à la figure de quelqu'un, un jour, exhibant alors un odieux bug, le vilain petit grain de sable dans la belle mécanique...

C'est donc le cas ici, malgré la qualité fantastique de Visual Studio et de Blend, et pour un petit bug dans une séquence mineure (écrite par un stagiaire, allez savoir), c'est tout l'extraordinaire édifice créé par ces deux outils qui s'écroule en partie au moins, faisant régresser "l'expérience utilisateur" (la mienne en l'occurence!) à la préhistoire des OS fenêtrés où bien avant COM ou autre DDE encore plus primitif, la seule façon de faire "communiquer" deux applications était le copier/coller !

On notera que ce petit bug serait sans conséquence si Blend prévoyait dans ses réglages le choix de la version de VS à utiliser. Et ici nous avons une autre démonstration : une mauvaise analyse ou réalisation d'une partie accessoire du logiciel (le paramétrage dans ce cas) met en évidence un bug qui aurait pu être masqué. Leçon à retenir : tout logiciel qui doit en appeler d'autres ou faire référence à des "objets" (au sens le plus large) externes doit absolument posséder dans ses réglages un moyen de dire quels sont ces applications ou ces objets et à quel endroit les trouver. Pan sur le doigts des développeurs de Blend :-)

Un bug dans le setup de VS + Un manquement à cette dernière "best practice" et c'est le mariage entre deux outils complémentaires qui se transforme en un divorce !

En farfouinant, j'ai trouvé la solution. Elle consiste tout simplement à trouver cette fameuse entrée de la registry ou VS indique son CLSID, entrée qui est utilisée par Blend notamment pour savoir comment appeler VS. Ensuite il faut connaître le CLSID de VS 2008 pour le mettre à la place de celui de VS 2005. Une fois qu'on a ces deux informations et qu'on effectue la correction, Blend 2 lance à nouveau VS 2008 automatiquement lorsqu'il créé un gestionnaire d'événement. Ouf !

Et comme je ne suis pas vache, après vous avoir fait la morale sur les bugs et les dialogues de paramétrage des applications, je vais vous donner cette fameuse entrée de registry et ce fameux CLSID... Roulement de tambour... And the winner is.....

changer la valeur de HKEY_CLASSES_ROOT\VisualStudio.DTE\CLSID 
en {1A5AC6AE-7B95-478C-B422-0E994FD727D6}

C'est tout. Bon, sauvegardez votre registry avant de faire la manip, je ne suis pas responsable si ça ne change rien chez vous, et je ne veux rien savoir si après la modif votre ordinateur ne boote plus ou que votre femme part vivre en Alaska avec votre soeur alors même que vous apprenez que votre père est le facteur et toutes ces considérations légales qu'on ajoute généralement dès qu'on donne un conseil qui demande à toucher à la registry. Vous êtes prévenu ! :-)

Et Stay Tuned !

[EDIT 20-9-08]
La solution fonctionnait mais quand j'ai refait la manip le lendemain, un double-click sur un .cs dans un projet sou Blend 2 m'ouvrait le fichier dans le bloc-notes... Et plus de liaison avec VS 2008. Grrrrr.

En (re)farfouillant, j'ai modifié deux autres petites choses qui semblent (en plus de la manip déjà décrite), cette fois-ci, apporter une réponse complète :

  1. Vérifier que les fichiers .cs sont bien associés à "Microsoft Visual Studio Version Selector", le double-click sous Blend semble utiliser les associations de fichier de Windows plutôt que le système de CLSID de la registry.
  2. Dans la clé HKEY_CLASSES_ROOT\VisualStudio.DTE évoquée plus haut, outre l'entrée CLSID il faut aussi mettre l'entré CurVer en conformité, elle doit contenir VisualStudio.DTE.9.0 et non pas la même chose avec 8.0 (VS 2005).

Voici le résultat final (exportation de branche depuis regedit) :

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\VisualStudio.DTE]
@="Microsoft Visual Studio DTE Object"

[HKEY_CLASSES_ROOT\VisualStudio.DTE\CLSID]
@="{1A5AC6AE-7B95-478C-B422-0E994FD727D6}"

[HKEY_CLASSES_ROOT\VisualStudio.DTE\CurVer]
@="VisualStudio.DTE.9.0"

Voilà... En espérant que cela aidera quelques âmes égarées sur la toile en quête d'une réponse à ce problème...
[/EDIT]

Déboguer simplement : les points d'arrêt par code

Voici une astuce toute simple comme je les aime mais qui rend bien des services !

Lorsqu'on débogue une application on utilise fréquemment les points d'arrêt notamment lorsqu'on soupçonne un problème dans une partie de code précise. Tous les développeurs connaissent les points d'arrêt et savent s'en servir. Il est déjà plus rare de voir un développeur se servir des points d'arrêt conditionnels, pourtant un simple clic-droit sur le rond rouge dans la marge (symbolisant le point d'arrêt) permet de fixer une condition liée au code ou au nombre de passages par exemple. Il existe d'autres possibilités d'une grande richesse et si vous ne les connaissez pas, au moins une fois pour voir, faites un clic droit sur un point d'arrêt et jouez un peu avec les options, vous comprendrez alors comment vous auriez pu gagner des minutes ou des heures précieuses si vous aviez connu cette astuce plus tôt !

Mais ce n'est pas des points d'arrêt conditionnels que je voulais vous parler aujourd'hui mais d'une autre astuce encore moins connue / utilisée : les points d'arrêt par code.

En effet, le debugger de Visual Studio peut, en partie, être contrôlé par le code lui-même en utilisant la classe Debugger de l'espace de noms System.Diagnostics.

Les méthodes statiques de cette classe permettent par exemple de savoir si le debugger est lancé ou non, voire de lancer s'il n'est pas actif. La méthode Break() quant à elle permet simplement de faire un point d'arrêt et c'est elle qui nous intéresse ici.

Plutôt que d'attendre qu'une exception soit levée, de revenir dans le code, de placer un point d'arrêt et de relancer l'application en espérant que "ça plante" de la même façon, il est plus facile de prévoir d'emblée le point d'arrêt là où il existe un risque d'y avoir un problème, notamment en phase de mise au point d'un code. Un simple Debugger.Break(), dès qu'il sera rencontré lors de l'exécution, aura le même effet qu'un point d'arrêt inconditionnel placé dans Visual Studio. Bien entendu, le break peut être programmer selon un test (valeur non valide d'une propriété par exemple). Dans un tel cas dès que l'application rencontrera le break elle déclenchera le passage en mode debug sur le "point d'arrêt" ainsi défini. Le développeur peut se dégager l'esprit pour d'autres tâches de test, dès que le break sera rencontré VS passera en debug immédiatement sans risque de "louper" le problème ou de le voir trop tard et de ne plus avoir accès à certaines variables.

un petit exemple :

class Program
{
   static void Main(string[] args)
   { 
       var list = new List<Book>
       {   new Book {Title = "Livre 1", Year = 1981},
           new Book {Title = "Livre 2", Year = 2007},
           new Book {Title = "Livre 3", Year = 2040} };

foreach (var book in list) { Console.WriteLine(book.Title+" "+book.Year); }
}

class Book
{
   private int year;

   public string Title { get; set; }
   public int Year
  { get { return year; }
     set {
              if (value > 1980 && value < DateTime.Now.Year) year = value;
              else Debugger.Break();
                   // throw new Exception("L'année " + value + " n'est pas autorisée");
           }
   }
}

Lors de l'initialisation de la collection "list" dans le Main(), l'année du troisième livre (2040) déclenchera le break. On pourra alors directement inspecter le code et savoir pourquoi ce "logiciel" plante dès son lancement...  On voit qu'ici j'ai mis en commentaire l'exception qui sera lancée par la version "finale" du code. A sa place j'ai introduit l'appel à Break(). Rien à surveiller. Si le problème vient de là (ce qui est le cas ici) VS passera tout seul en debug...

C'est pas chouette ça ?

Alors Stay Tuned !

 

 

 

LINQ to {tapez ce que vous voulez ici}. Des providers à foison !

Vous connaissez LINQ to Object, LINQ to Dataset, LINQ to XML, etc... Microsoft livre déjà une large palette de fournisseurs de données (providers) pour LINQ. Dans sa grande sagesse Microsoft a aussi publié les spécifications (et des exemples) permettant à tous de développer des fournisseurs de données pouvant fonctionner avec LINQ. Cette ouverture extraordinaire permet d'interroger avec LINQ des données de toute sorte sans avoir besoin de les transformer au préalable.

Mais savez-vous qu'à ce jour il existe déjà plus d'une trentaine de providers LINQ ? Et que forcément certains vous rendrons des services inestimables, à condition d'en connaître l'existence... Vous pouvez même écrire vos propres providers LINQ ! Je vous conseille d'ailleurs cette page du Wayward blog qui propose une série de billets expliquant comment créer un tel provider.

Un exemple parmi tant d'autres pour illustrer le propos : LINQ To Amazon. Il permet tout simplement d'interroger directement Amazon pour sélectionner des livres selon autant de critères que nécessaire, et sans autre programmation qu'une requête LINQ. Fantastique non ? Un petit exemple pour concrétiser la chose :

var query =
  from book in new Amazon.BookSearch()
  where
    book.Title.Contains("ajax") &&
    (book.Publisher == "Manning") &&
    (book.Price <= 25) &&
    (book.Condition == BookCondition.New)
  select book;

 

Cool non ? LINQ to Amazon est présenté dans le livre LINQ in Action (que je vous conseille au passage) et vous pouvez accéder au blog de Fabrice qui le présente.

Mais cela n'est qu'un exemple, et il existe bien d'autres fournisseurs de données LINQ, en voici une liste (avec liens - shift clic pour les ouvrir dans une nouvelle fenêtre) :

Charlie Calvert, que les delphistes connaissent bien, et qui comme bon nombre des meilleurs a depuis longtemps choisi la voie .NET avec Microsoft, met à jour régulièrement cette liste qui est issue de son blog. Si vous lisez l'anglais, bookmarquez la page Links to LINQ de son blog qui, en plus de la liste des providers, fournit de nombreux liens en rapport avec cette technologie.

Conclusion

LINQ est une technologie fantastique dont je ne cesse de dire du bien (et d'utiliser avec bonheur dans la totalité des applications que j'écris), je ne peux imaginer utiliser demain ou dans 10 ans un langage qui n'implémentera pas une feature de même type. LINQ to "n'importe quoi" est la preuve que cette technologie est en plus ouverte et que seule notre imagination est la limite. Borland utilisait le slogan "the sky is the limit" durant ses grandes années de gloire. Microsoft ne le dit pas, mais la firme de Redmond rend ce rêve possible aujourd'hui...

 

Des outils simples et gratuits pour faire du XAML

Xaml est le langage de description utilisé par WPF et Silverlight. On peut créer du code Xaml en utilisant Expression Blend, Expression Design ou même Adobe Illustrator (à l'aide d'un petit plugin gratuit XamlExport). Bien entendu le code Xaml peut aussi être manipulé sous VS 2008 mais de façon sommaire.

Pour tester du code Xaml il s'avère souvent nécessaire, qu'on soit en phase d'apprentissage ou qu'on soit un expert, de pouvoir saisir ou modifier quelques lignes pour visualiser le résultat.

Pour cela il existe des "notepad" (bloc-notes).

XamlPad.exe

C'est le plus simple. Rudimentaire même. Il est fourni avec le SDK Windows. Pour info sur ma machine il se trouve dans "C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin". Il dispose d'une page sur MSDN expliquant comment s'en servir. Il ne fait pas grand chose et il est préférable de se tourner vers des versions améliorées. 

XamlPadX

Cet outil est déjà plus évolué. On peut le télécharger sur le blog de Lester. La version actuelle est la 4.0 qui sait gérer les add-ins et possède quelques exemples "hard codés" qui permettent de rapidement tester l'outil. Le setup peut être téléchargé depuis le billet du blog de Lester.
Un petit détail : Avast détecte un Trojan générique lors du téléchargement et refuse d'enregistrer le fichier... Pour l'installer il faut couper Avast, télécharger l'exe, le lancer (c'est un setup) et un fois l'install terminée rétablir Avast. L'exécutable lui-même ne pose aucun problème, je suppose que c'est Avast qui doit prendre pour un Trojan une séquence du module d'installation.

 

Kaxaml

Cet autre outil offre des services similaires mais avec une philosophie légèrement différente. Difficile de dire s'il est meilleur que le précédent c'est à chacun de voir celui qui est le mieux adapté à ses besoins et à sa façon de travailler. Kaxaml dispose de sa propre page web d'où l'on peut télécharger soit la version 1.0 soit la bêta qui supporte Silverlight 2 b2.

 

Conclusion

Ces petits outils n'ont pas la sophistication d'un Blend ou d'un Expression Design, ils ne remplacent pas non plus la partie code-behind de VS 2008. En revanche ils permettent de tester rapidement des idées ou des snippets récupérés ici ou là. Ils ne remplacent donc rien mais viennent compléter agréablement la boîte à outil du développeur WPF qu'il soit expert ou en phase d'apprentissage.

Bon Dev

Et Stay Tuned !

Astuce du jour : déboguer du code sans écrire de code de test

Il arrive souvent (ou il devrait souvent arriver...) qu'on veuille tester rapidement du code. Par exemple vérifier qu'une méthode retourne bien le bon résultat selon deux ou trois variantes des paramètres d'entrée. Mais écrire du code de test à chaque fois, même si "on devrait" le faire tout le temps, n'est pas totalement conforme à la réalité. On a plus souvent la pression que la bride sur le collier et cela impose de travailler bien, mais vite !

Alors une petite astuce rapide pour aujourd'hui. La fenêtre Immediate de VS 2008 offre un moyen simple d'invoquer du code et de tester rapidement une méthode. Peut-être connaissez-vous cette fonction de VS dans ce cas j'espère juste vous avoir rafraichi la mémoire pour vous en servir plus souvent !

Je ne connais pas le nom en français de cette fenêtre car j'utilise un VS en US. Mais vous trouverez facilement.

Une des façons rapides de l'appeler est d'utiliser le raccourci vers la fenêtre Command et de taper "immed" ce qui ouvre la fenêtre Immediate. La fenêtre Command s'appelle par Ctrl-Alt-A (vérifiez si en français le raccourci est le même).

Bien entendu pour invoquer du code il faut être en debug. Soit vous avez un point d'arrêt quelque part et vous attendez d'y être arrivé, soit vous pouvez lancer l'application par F10 (step over) au lieu de F5, cela s'arrêtera tout de suite sur le Main. Là, tapez Ctrl-Alt-A puis "immed" si la fenêtre Immediate n'est pas déjà affichée. Et il ne reste plus qu'à taper votre code de test... Vous disposez de Intellisence et de toute l'aide, c'est pas merveilleux ? !

En image pour voir de quoi il s'agit (la qualité de la capture est mauvaise en raison de la réduction à 80% et de la compression jpeg, j'essaye de ne pas trop grossir les flux RSS des abonnés au blog...) :

La fenêtre Immediate, c'est facile, rapide, puissant. Autant s'en servir !

Bon Dev

...Et Stay Tuned !

Un outil gratuit pour tester les requêtes LINQ

Qu'il s'agisse de LINQ to Object ou LINQ to SQL il serait bien agréable de pouvoir disposer d'une sorte de bloc-note pour tester ou mettre au point des requêtes, voire pour s'entraîner tout simplement. Pouvoir gérer les connexions aux bases de données, éventuellement envoyer et tester du SQL "de base" sur celles-ci serait la cerise sur la gâteau. Et bien cet outil existe, et en plus il est gratuit !

 

LINQPad, puisque c'est de lui qu'il s'agit, n'est pas vraiment une nouveauté absolue mais il y a fort à parier que nombre d'entre vous n'en ont jamais entendu parlé.

Cet outil a été développé conjointement à l'excellent ouvrage "C# 3.0 in a nutshell" de Joseph Albahari, un australien, qui par la diffusion gratuite de LINQPad tente une promo plutôt positive de son livre et de ses services de consulting (si on habite au pays des kangourous, of course).

J'aime personnellement cette idée de "pub positive" qui consiste à offrir de son temps et de son travail pour faire sa pub plutôt que de gaver les gens de bandeaux agaçants. C'est de la pub dans un esprit totalement anti-google (de la pub pour de la pub, partout, sans rien apporter à ceux qui la subissent), et il faut encourager ceux qui adoptent cette façon respectueuse de faire leur promotion. Achetez le livre de Joseph ! Fin de la paranthèse :-)

LINQPad est ainsi un super utilitaire. Il interprète du code C# ou VB et les requêtes LINQ to Object ou LINQ to SQL. Il autorise la connexion à des bases de données, offre un éditeur purement SQL en supplément, bien pratique, et il permet même d'ajouter ses propres DLL et ses propres espaces de noms pour qu'ils soient reconnus dans le code C# qu'on tape !

On peut dès lors utiliser LINQPad pour requêter des objets métiers complexes, un framework maison, un modèle LINQ to SQL, etc.. Il suffit d'ajouter les références.

Pour terminer, LINQPad est fourni avec de nombreux exemples qui sont autant de moyens de tester ses connaissances et d'apprendre les subtilités de LINQ. Utilisé conjointement à ma version des "101 exemples LINQ" de Microsoft, LINQPad devient un fantastique outil d'auto-formation.

Pour télécharger le produit et avoir accès aussi aux forums, aux vidéos de démo, et plein d'autres choses, aller sur la page de LINQPad !

Bon Dev...

Et Stay Tuned !

 

Simplifier les gestionnaires d'événement grâce aux expressions Lambda

Les expressions Lambda ont été introduites dans C# 3.0. Utilisées correctement, tout comme LINQ to Object, elles permettent une grande simplification du code entraînant dans un cercle vertueux une meilleure lisibilité de ce dernier favorisant maintenabilité et fiabilité de ce même code. Il n'y a donc aucune raison de rester "frileux" vis à vis de cette nouveauté syntaxique comme encore trop de développeurs que je rencontre dans mes formations ou ailleurs.

Pour démontrer cette souplesse, voici un petit exemple qui valide un document XML en fonction d'un schéma.

La méthode Validate() de la classe XDocument attend en paramètre un delegate de type ValidationEventHandler. Dans un code très court il n'est pas forcément judicieux de déclarer une méthode juste pour passer son nom en paramètre à Validate(). Les "sous procédures" ou procédures imbriquées de Pascal n'existent pas en C# et l'obligation de déclarer à chaque fois des méthodes private pour décomposer la moindre action est une lourdeur syntaxique de ce langage dont on aimerait se passer parfois (une méthode même private est visible par toutes les autres méthodes de la classe ce qui n'est pas toujours souhaitable. Seules les méthodes imbriquées de Pascal sont des "méthodes privées de méthodes").

En fin de billet vous trouverez d'ailleurs le lien vers un autre billet dans lequel j'explique comment utiliser les expressions Lambda en les nommant pour retrouver la souplesse des procédures imbriquées. Même si "l'astuce" présentée ici peut y ressembler dans l'esprit, dans la pratique les choses sont assez différentes puisque nous n'utiliserons pas une expression nommée.

Revenons à l'exemple, il s'agit de valider un document XML à partir d'un schéma. Et de le faire de la façon la plus simple possible, c'est à dire en évitant l'écriture d'un delegate, donc en utilisant directement une expression Lambda en paramètre de Validate().

Supposons que nous ayons déjà le schéma (variable schema) et le document XML (variable doc), l'appel à Validate pourra donc s'écrire :

doc.Validate(schema,(obj, e) => errors += e.Message + Environment.NewLine);

"errors" est déclarée comme une chaîne de caractères. A chaque éventuelle erreur détectée par la validation l'expression concatène le message d'erreur à cette dernière. En fin de validation il suffit d'afficher errors pour avoir la liste des erreurs. Mais cela n'est qu'un exemple d'utilisation de l'expression Lambda. Ce qui compte c'est bien entendu de comprendre l'utilisation de cette dernière en place et lieu d'un delegate de tout type, ici ValidationEventHandler d'où les paramètres (obj,e) puisque ce delegate est déclaré de cette façon (un objet et un argument spécifique à cet handler).

C'est simple, nul besoin de déclarer un gestionnaire d'événement donc une méthode avec un nom et une visibilité. On évite que cette méthode soit réutilisée dans le code de la classe considérée (si elle existe on est tenté de la réutiliser mais sa stratégie d'écriture n'est pas forcément adaptée à une telle utilisation d'où possible bug), etc. Que des avantages donc.

Pour plus d'information vous pouvez lire mon article sur les nouveautés syntaxiques de C# 3.0 ainsi que mon billet montrant comment retrouver en C# le bénéfice des procédures imbriquées de Pascal grâce aux expressions Lambda.

Si vous voulez jouez avec l'exemple, vous pouvez télécharger le projet VS 2008 qui montre tout cela : lambda.zip (21,71 kb)

How Do I ? - Les vidéos Microsoft pour bien se lancer / complément

Pour ceux qui lisent ce blog par flux RSS (et ils sont très nombreux) il a de fortes chances pour que vous ne puissiez voir l'edit que j'ai fait du billet précédent "How Do I ? - Les vidéos Microsoft pour bien se lancer". J'ai fait une mise à jour des liens concernant les vidéos de la série "How Do I". Donc si cela vous intéresse, rafraichissez le message si votre lecteur de flux le permet, sinon tapez sur le lien en début de paragraphe pour ouvrir la dernière version du billet dans votre brower...

How Do I ? - Les vidéos Microsoft pour bien se lancer

Dans la jungle épaisse de MSDN on trouve des milliers de choses passionnantes, souvent par hasard car par définition une jungle est inextricable et MSDN n'échappe pas à la règle... Il est d'ailleurs parfois plus rapide et plus sûr de chercher une info dans Google pour trouver le lien dans MSDN que de chercher directement dans ce dernier ! Et pourtant... Cette jungle cache de nombreux trésors qui ne s'offrent qu'aux intrépides aventuriers osant s'enfoncer dans la moiteur tiède de l'information, sautant de lien-lianne en lien tel un Tarzan numérique...

Bon trève de plaisanterie, j'en reviens à l'essentiel : "Comment je fais ?".

Comment je fais "quoi" ? Allez-vous rétorquer. Tout. Plein de choses. Par exemple, Comment j'utilise l'Entity Framework, Comment je commence avec ADO.NET Data Service, Comment j'utilise le control LinqDataSource, Comment j'utilise le DataSet en multi-tiers ? Etc, etc.

Pour toutes ces questions il existe en réponse une vidéo, claire, expliquant par l'image et la parole ce qu'il faut savoir.

Bien entendu tout cela est en anglais et en concernera donc que les lecteurs capables de suivre une démo dans cette langue sans en perdre les trois quarts.

Si vous faites partie des heureux anglophones à qui ce genre de média ne fait pas peur, rendez vous sur la page des "How Do I?"...

[EDIT]
Le lien que je donne concerne les "How Do I" des données. Sylvain dans son commentaire à ce billet donne un autre lien concernant la série "How Do I" pour ASP.NET.
En fouillant sur MSDN on peut aussi trouver une série pour le "Native Coding" (C++ Win32), une autre pour Visual Studio, ou pour les Devices (Compact Framework), ou encore Office et les XML API, etc.

Toutes les séries "How Do I" ne sont pas forcément dotées de vidéos, en revanche, à la page suivante vous trouverez la liste de toutes les vidéos "How Do I" quel que soit le sujet abordé (à ce jour : ASP.NET, Ajax, Devices, Native Coding, Security, Silverlight, VB, VS, VS tools for Office, VSTS, Windows Forms, WPF).
[/EDIT]

 

Bonne vidéos

et Stay Tuned !

La guerre des clones n'aura pas lieu ! ... Si vous possédez Clone Detective !

Clone Detective pour Visual Studio est un outil de debug un peu particulier puisqu'il ne cherche pas les bugs mais les redondances de code.

La redondance de code est un ennemi sournois... Le code dupliqué est bien souvent la porte ouverte aux inconsistances et aux regressions lors de mises à jour correctives ou évolutives. En effet, si un bug apparaît un jour dans une séquence mais qu'il n'a pas encore été repéré dans une autre fonction qui utilise pourtant un code similaire, la mise à jour ne concernera que la séquence incriminée. Un jour où l'autre la partie codée de façon similaire plantera aussi pour les mêmes raisons. Elle ne sera d'ailleurs peut être pas corrigée de la même façon ni par la même personne... Inconsistance. Coûts de maintenance inutiles. Les défauts de la redondance de code ne manque donc pas.

D'ailleurs un outil capable de retrouver ces fameux clones est un excellent assistant pour un auditeur... La présence des clones trahit non pas celle de Palpatine ou du comte Doku mais bien d'un code for mal refactoré, donc pauvre et qui laissera par force voir d'autres faiblesses !

Précisons que Clone Detective cherche les "clones", pas seulement le code purement redondant de type copier/coller. Il analyse le code en supprimant les commentaires, les espaces, les noms de variables etc, afin d'obtenir un code de référence le plus générique possible avant d'y chercher les clones. Les clones formes des classes de code équivalent, l'un pourrait remplacer l'autre sans problème, à la présentation et aux noms de variables près.

Il s'agit donc bien d'une recherche intelligente et non simplement d'une recherche de "doublons". Mais la lecture de la documentation de CD vous en dira bien plus que ces quelques lignes.

Donc pour se prémunir des dommages causés par les clones, et si on ne connait pas le numéro de portable de Yoda, le mieux est encore de télécharger Clone Detective. Bonne nouvelle il n'habite pas une galaxie lointaire, il est sur CodePlex et donc gratuit avec le code source pour les curieux ! Mieux, C.D. s'insère dans VS 2008 (voir / autres fenêtres, pour afficher celles de C.D. une fois installé). Vraiment un bel add-in dont il serait bête de se priver !

Pour accéder à la page de chargement, cliquez simplement sur le logo de Clone Detective inséré plus haut dans le corps de ce billet.

Que la force soit avec vous !

(et Stay Tuned !)