Catégorie : Développement

Migration de code VB3 vers VB.Net

Dans le cadre d’un de mes projets, j’ai eu à migrer du code VB3 (16 bits évidemment) vers du code VB.Net en framework 4.5.

Au final, cela ne s’est pas avéré très compliqué. Voici le processus suivi :

  1. Création d’un fichier projet VB6 (fichier .vbp)
  2. Migration du projet VB6 vers .Net 2.0
  3. Migration du projet .Net 2.0 vers un projet .Net 4.5
  4. Corrections des “quelques” bugs restants

1ère étape : Création d’un projet VB6 (fichier .vbp)

Visual Studio 2008 (dernière version à être capable de migrer du VB6) nécessite impérativement un fichier vbp décrivant l’ensemble des fichiers contenus dans le projet. Heureusement, VB3 fournit un fichier .Mak donnant des informations sur la compilation de l’exécutable. L’idée est donc de mixer un fichier vbp vide avec le fichier .mak de mon projet vb3.

Ainsi le fichier .mak suivant :

me donne le fichier .vbp suivant (tronqué : un exemple complet est disponible sur la MSDN ici) :

2ème étape : Migration du projet VB6 vers .Net 2.0

Cette étape est la plus simple de toutes : il suffit d’ouvrir Visual Studio 2008 (je me répète : dernière version de Visual Studio à migrer du code VB) et d’ouvrir le fichier vbp.

Un assistant développé par Artinsoft se lance et fait tout le boulot pour vous Sourire. Cette société fournit aussi un guide de migration très complet : http://migrationguide.artinsoft.com/

3ème étape : Migration du projet .Net 2.0 vers .Net 4.5

Cette étape n’est pas très compliquée non plus, il vous suffit de lancer votre dernière version de Visual Studio (2013 ou 2012 généralement) et de modifier les propriétés du projet comme suit :

image

4ème étape : Correction des bugs restants

On arrive ici à l’étape la plus laborieuse qui se fait en 2 grandes phases :

  1. Corrections dans le code jusqu’à que l’application compile : opération fastidieuse et dont la durée est directement liée au volume de code.
  2. Exécution du code migré jusqu’à cela fonctionne correctement.

Plusieurs points de vigilance lors de ces 2 phases :

  • La gestion des entiers : Short (VB3) = Byte (.Net), Integer (VB3) = Short (.Net) & Long (VB3) = Interger
  • Dans le cadre du projet, la migration avait été facilitée par l’absence de contrôles graphiques à migrer. Notamment dans le cas où l’application existante utilise des composants graphiques du marché, la migration peut être plus compliquée car il est peu probable que l’on puisse retrouver un composant équivalent présentant les mêmes signatures
  • La gestion des tableaux : en VB, ceux-ci commencent généralement à 1 (et non pas à 0)
  • L’outil de migration dans sa mansuétude vous laisse des indications sur les potentiels problèmes. Ex :

  • La 2ème phase a principalement consisté à
    • Exécuter le code
    • Corriger ce qui plantait
    • Corriger ce qui ne donnait pas de bons résultats

Sortie de Visual Studio 14 CTP 2

Je parlais hier de la sortie de l’Update 3 en RC de Visual Studio 2013 et j’apprends ce matin la sortie de la nouvelle version de Visual Studio en CTP 2 (Community Technology Preview).

Je n’ai pas encore eu le temps d’y jeter un oeil mais ca parait prometteur avec notamment :

  • La mise en place ASP.NET vNext : composant Open-Source permettant de construire des applications Web & Cloud simplement.
  • Des améliorations dans l’environnement de développement

Les « releases notes » sont disponibles sur la MSDN aux adresses suivantes :

Sortie de Visual Studio 2013 Update 3

Ca y est, l’update 3 de Visual Studio 2013 est disponible en Release Candidate (RC) à l’adresse suivante : http://www.microsoft.com/fr-fr/download/details.aspx?id=43398

Celle-ci sera disponible en version RTM (Release To Manufacturer) à la fin de l’été (je n’arrive pas à retrouver l’info exacte que j’ai lu sur un blog récemment …)

Cette version apporte comme d’habitude des corrections ainsi que des évolutions sur les outils suivants :

  • Application insights : Cette application de monitoring de site Web, et d’applications Windows 8 ou Windows Phone est maintenant inclus dans Visual Studio 2013
  • Visual Studio Graphics Analyzer : Comme son nom l’indique, cet outil permet d’analyser les performances graphiques d’une application en DirectX. Plus d’infos, ici
  • .Net Memory Analysis : Il est maintenant possible d’utiliser directement les fonctions “Atteindre la définition” (F12) et “Rechercher toutes les références” (Shift-F12) depuis l’outil d’analyse de mémoire fourni dans Visual Studio. Plus d’infos, ici.
  • Utilisation de la CPU et de la mémoire : Il est maintenant possible de naviguer directement dans le code depuis l’arborescence des appels. Le support pour les applications Win32 et WPF a aussi été amélioré (avec notamment la possibilité de forcer le déclenchement du Garbage Collector (Ramasse-miettes pour les anglophobes Sourire). Plus d’infos, ici et ici.
  • CodeLens (ou affichage tête haute) uniquement disponible dans la version Ultimate : L’outil permet maintenant de montrer les auteurs ainsi que les changements dans un référentiel Git.

ASCII, UTF8, UTF16 : l’encodage de chaîne en général

Récemment sur 2 projets différents à quelques jours d’intervalle, j’ai eu à me replonger dans l’encodage de chaînes de caractères que je pensais maîtriser …

Voyons si vous serez plus à l’aise que moi et prenez quelques instants pour “deviner” ce qu’affiche le code suivant :

.

.

.

.

.

.

.

.

.

La réponse est :

Si vous avez répondu 11 & 11, vous avez besoin d’un petit rappel sur les différents codage possibles :

  • ASCII : Codage définissant 128 caractères numérotés de 0 à 127 (et donc codables sur 7 bits). Ex : A = 65
  • Unicode : C’est un standard informatique qui permet d’échanger du texte au niveau mondial. De manière simplifiée, tout caractère est défini par une page de code (1252 étant par exemple l’alphabet latin) et un point de code (définissant un caractère à l’intérieur de cette page de code)

ASCII définit aussi bien la valeur d’un caractère (65 pour le “A” que son codage en binaire 1000001) alors que Unicode n’est qu’une définition d’un caractère. Son codage peut se faire ensuite selon plusieurs formats tels que UTF-8, UTF-16, UTF-32. (UTF signifiant “Universal Character Set Transformation Format”)

Le chiffre à la suite d’UTF ne signifie pas, contrairement à ce que j’avais en tête, le nombre de bits nécessaire au codage d’un caractère mais le nombre de bits minimal nécessaire au codage d’un caractère.

Ainsi, un codage en UTF-8 signifie que le caractère sera codé sur au moins 8 bits mais potentiellement plus. Une des spécificités d’UTF-8 est que ses 127 premiers caractères sont codés de la même manière qu’en ASCII, ce qui explique pourquoi UTF-8 est l’encodage de base utilisé pour la plupart des sites Web)

Pour en revenir au bout de code présenté, la première ligne de code présentée  effectuant une double conversion d’entiers inférieurs à 127 (donc “compatibles” ASCII), on reste sur une bijection 1 octet => 1 octet. Par contre, dans la deuxième, on effectue une conversion d’entiers supérieurs à 127 et donc 1 octet peut donner plus qu’un 1 octet.

Utilisation de Xml en C#

Aujourd’hui, voici quelques liens relatifs à l’utilisation de Xml en C#

Correspondance des instructions XPath vers Linq To Xml

Vous trouverez ici : http://msdn.microsoft.com/fr-fr/library/bb675178.aspx une correspondance relativement exhaustive de la correspondance entre XPath & Linq To Xml.

Quelques exemples (où po est un XDocument)

Instruction XPath Equivalent Linq To Xml
//Name po.Root.Descendants(« Name »);
//Address[@Type=’Shipping’] from el in po.Descendants(« Address ») where (string)el.Attribute(« Type ») == « Shipping » select el

Comment apprendre Linq To Xml :

Le plus simple reste d’installer LinqPad 4. C’est un outil gratuit (tant que vous n’avez pas besoin de la complétion automatique) fourni avec un grand nombre d’exemples pour Linq To Objects et Linq To Xml.

Sa simplicité en fait aussi un outil idéal pour tester rapidement des petits bouts de code sans avoir besoin de lancer Visual Studio.

Ma référence pour les instructions XPath :

Linq to Xml c’est bien mais parfois on n’a pas le choix et on doit faire du XPath. Voici le site que j’utilise pour trouver les requêtes à utiliser : http://zvon.org/comp/r/tut-XPath_1.html

Rechercher / remplacer avec des expressions régulières dans Visual Studio

Dans le cadre d’un de mes projets, j’ai récemment eu à remplacer dans tout un projet décompilé (généré par ILSpy sur du Compact Framework 3.5 …) le type de code suivant :

[sourcecode language= »csharp » padlinenumbers= »true » htmlscript= »false » toolbar= »true »]
int i = 17;
List<string> l = new List<string>();
l.get_Item(12) = "une chaine";
l.get_Item(i) = "une autre chaine";
[/sourcecode]

par celui-ci :

[sourcecode language= »csharp »]
int i = 17;
List<string> l = new List<string>();
l[12] = "une chaine";
l[i] = "une autre chaine";
[/sourcecode]

Aparté : J’en suis arrivé à ce code, car Il semble qu’ILSpy ne gère pas très bien le code compilé pour le Compact Framework, d’où la récupération de ces get_Item au lieu de l’indexeur classique. J’ai eu le même problème avec les propriétés qui étaient toutes de la forme .get_NomPropriete() ou .set_NomPropriete().

Je me suis naturellement tourné vers le remplacement dans Visual Studio par des expressions régulières (Je n’aborderai pas ici leur utilisation, pour plus d’informations je vous invite à consulter le site du zéro : http://fr.openclassrooms.com/informatique/cours/concevez-votre-site-web-avec-php-et-mysql/les-expressions-regulieres-partie-1-2 ou ce site (en anglais) http://www.regular-expressions.info/)

Il se trouve en fait que le comportement des expressions régulières a changé dans Visual Studio 2012 comme décrit succinctement dans la MSDN :

Pour plus d’informations sur les expressions régulières utilisées dans les modèles de remplacement, consultez Substitutions dans les expressions régulières.  Pour utiliser un groupe de captures numérotées, la syntaxe est $1 pour spécifier le groupe numéroté et (x) pour spécifier le groupe en question. Par exemple, l’expression régulière groupée (d)([a-z]) recherche quatre correspondances dans la chaîne suivante : 1a 2b 3c 4d. La chaîne de remplacement z$1 convertit cette chaîne en z1 z2 z3 z4> La syntaxe équivalente dans Visual Studio 2010 est {:z}([a-z]) pour l’expression régulière groupée et z1 pour la chaîne de remplacement.

L’expression régulière “officielle” pour effectuer une rechercher est la suivante : .get_Item((w+))où ((w+) représente le groupe à conserver et à réinsérer.

 Sous Visual Studio 2012 et supérieur, le remplacement se fait de la manière suivante :

VS2012regexp

  • $1 correspond au 1er groupe de l’expression régulière (dans notre exemple : “12” puis “i”)
  • image représentant la recherche par expressions régulières

Sous Visual Studio 2008 ou 2010, le mécanisme est légèrement différent :

image

  • L’expression régulière utilisée est : .get_Item({:a+}) où
    • “:a” correspondà un caractère alphanumérique
    • “{}” la définition d’un groupe
  • La récupération du groupe se fait par la syntaxe “1”

La touche F4 dans Excel (Répéter la dernière action)

La touche F4, bien que peu connue, est particulièrement utile dans Excel (toutes les versions à ma connaissance). Celle-ci sert à répéter la dernière action unitaire effectuée par l’utilisateur, ce qui correspond soit à un clic sur une fonction du ruban, soit au passage par un écran permettant de positionner plusieurs attributs.

Ainsi il est possible de répéter une mise en gras, la définition d’une couleur de remplissage, l’ensemble des propriétés de format d’une cellule ou même l’insertion ou la suppression de lignes.

Passons à quelques exemples pour illustrer son utilité :

Exemple 1 : Répéter un formatage de cellule

Je souhaite ici colorier rapidement en rose, entourer de bordure et mettre en gras l’ensemble des cellules qui sont barrées.

La méthode habituelle consisterait à effectuer une multi-sélection (Control+clic) de toutes les cellules qui nous intéressent puis de faire les modifications souhaitées. L’inconvénient de cette méthode est que l’on risque fort d’oublier une cellule et d’avoir à repositionner les propriétés une par une.

La méthode astucieuse consiste à sélectionner une seule cellule (B15) par exemple, de faire « bouton droit » – « Format de cellule » et de définir l’ensemble des propriétés souhaitées. Une fois cela effectué, il ne reste plus qu’à se positionner sur les cellules une par une (ou en multi-sélection) et de taper F4 pour que la dernière action soit répétée.

Voici le résultat :

Exemple de touche F4 dans Excel

 Exemple 2 : répéter la suppression de lignes

J’aime aussi beaucoup utiliser cette fonction dans des tableaux ou je souhaite supprimer des lignes complètes un peu partout.

Dans ce cas, il suffit de sélectionner une ligne, de la supprimer (Bouton Droit, Supprimer). Tant qu’aucune autre action n’est effectuée, la sélection d’une ou plusieurs lignes et l’appui sur F4 supprimera directement ces lignes, ce qui est autrement plus rapide qu’un autre raccourci clavier ou qu’un clic droit puis Supprimer

 Voici le résultat :

La touche F4 lors de la suppression de lignes

Et pour finir, il faut noter que cette touche F4 est aussi disponible dans Word avec évidemment le même usage.