[ Retour Accueil ]
Durée de réalisation estimée : 16H00
ce module s'adresse aux développeurs VB qui ont connaissance de la plate-forme .NET (module INT-VB ou niveau équivalent).
Ce module se compose de 4 chapitres :
[ Commander ]
Après avoir été considérablement amélioré dans la version .NET, la version 8 du langage Visual Basic se voit de nouveau agrémenté de quelques nouveautés lui permettant de combler ses dernières lacunes et d’assurer une meilleure compatibilité avec les autres langages vis à vis de la CLI (Common Language Infrastructure).
Comparé à VB6, la syntaxe reste bien évidemment similaire, mais de nombreuses innovations, que nous passerons en revue au cours ce chapitre, ont été apportées. Comme nous venons de l’évoquer, la principale raison de cette évolution résulte du besoin d'interopérabilité avec les différents langages disponibles dans l'environnement .NET, avec par exemple, un ensemble de types de données communs nommé CTS (Common Type System). Il faut reconnaître, ensuite, que Visual Basic 6 héritait d'un long passé (la version 1 a fait son apparition en 1991 !) et donc d'un certain nombre de lourdeurs, qui ont été maintenues par souci de compatibilité ascendante. A partir de la version 7, baptisée .NET, le langage VB fait peau neuve en s'affranchissant non seulement de ces lourdeurs, mais en intégrant aussi les fonctionnalités qui lui faisaient défaut au regard des langages de programmation modernes, notamment en ce qui concerne la POO, avec le support de l’héritage.
Les différents aspects du langage seront tout d'abord présentés à l'aide de petits exemples indépendants, qui seront regroupés dans un premier projet, associés à une série de boutons de commande au sein d’une application de type Windows. Ils auraient tout aussi bien pu être présentés dans des applications de type Console, mais l’aspect visuel d’une application Windows nous facilitera les choses.
Un deuxième projet nous montrera, ensuite, comment exploiter les boucles For Each avec deux contrôles ListBox. Ce projet nous apprendra, d'une part, comment gérer les sélections multiples dans ce type de contrôle et, d'autre part, à implémenter des opérations de glisser-déplacer (drag and drop), spécifiques aux applications de type Windows.
Les variables individuelles sont certes utiles en programmation, mais elles sont néanmoins insuffisantes pour traiter efficacement la diversité des informations à traiter. Leur structure est, en effet, de plus en plus riche et de plus en plus complexe. S'étalant du simple tableau au DataSet en passant par les collections d'objets, Visual Basic et .NET offrent une riche palette de possibilités. Les structures de base vont être passées en revue dans ce chapitre, alors que le DataSet sera détaillé dans le module consacré aux ADO .NET.
Nous commencerons naturellement par étudier les techniques classiques telles que les structures et les tableaux, qui font partie de la panoplie des notions de base que tout programmeur doit bien connaître. Nous verrons, ensuite comment travailler plus spécifiquement avec les objets lorsqu'ils doivent être regroupés en collections. De très nombreux objets du Framework .NET sont eux-mêmes organisés en collections. Il est donc essentiel d'être familiarisé avec les opérations inhérentes à leur usage.
Nous poursuivrons ensuite en apprenant à concevoir nos propres collections. Cette possibilité était déjà offerte aux développeurs Visual Basic 6, mais il faut aborder les collections .NET d'un autre œil. Il en existe, en effet, plusieurs types qui ont pour objet de permettre de répondre à des usages plus spécifiques tels que la gestion d'une pile LIFO (Last In First Out, qui signifie "dernier entré, premier sorti") ou d’une pile FIFO (First In First Out, qui signifie "premier entré, premier sorti"). D'autres types de collections font également leur apparition au sein du Framework .NET 2.0 grâce à la nouvelle notion de génériques que nous découvrirons au module consacré à la POO.
Nous terminerons ce chapitre avec un projet exploitant le contrôle ListView, afin de recenser un ensemble de fichiers d'images stockées dans un dossier sur votre disque dur, dans l'optique de les afficher sous forme de diaporama. Ce contrôle, principalement constitué de collections, nous permettra de mettre en œuvre les notions précédemment apprises. Cet exemple nous montrera, de plus, comment configurer un contrôle complexe de manière dynamique et non pas en mode Design.
Disposant à présent de tous les éléments du langage VB8, nous sommes prêts à lancer des opérations, c'est-à-dire à tirer parti des objets créés à partir des classes proposées par le Framework .NET 2.0.
Dans ce chapitre, nous allons passer en revue les classes principales de la BCL (Base Class Library) qui parsèmeront la plupart de vos applications. Ce sont avec elles en effet que nous serons en mesure de manipuler les chaînes de caractères, les nombres, les dates ou encore le système de fichiers. Nous ferons ensuite connaissance avec le nouvel espace de noms My qui a été conçu pour faciliter bon nombre d'opérations courantes.
Même si elle tend à s'en rapprocher, la programmation n'est pas une science exacte dans le sens où il est encore très difficile de prouver qu'un programme produit bien les résultats escomptés en toutes circonstances. Les erreurs sont en effet quasiment inévitables, même pour les développeurs les plus expérimentés. Pour qu’une application puisse être considérée comme étant fiable, il est donc indispensable de prévoir une phase de tests et de mise au point. Pour nous faciliter les choses, Visual Studio intègre un débogueur assorti d'un ensemble d'outils très complet, qui font faire l’objet de ce chapitre. Mais avant cela, il est important de classifier ces erreurs en quatre grandes familles, car chacune d'entre elles se traite différemment :
Les deux premières sont faciles à localiser et à éliminer du fait qu'elles sont automatiquement détectées par Visual Studio. Nous savons en effet que les erreurs de syntaxe sont signalées par un soulignement d’un trait ondulé bleu dans la fenêtre de code, accompagné d’une description affichée en info-bulle.
Lors de la génération d’un projet, l'intégralité du code de a solution est ensuite analysé. Les éventuelles erreurs de compilation rencontrées sont alors centralisées dans la fenêtre Erreurs. Ce type d’erreur concerne notamment les conversions invalides entre deux types de données ou les listes d’arguments qui n'ont pas de correspondance avec les différentes signatures proposées par une méthode lors de son appel.
Viennent ensuite les erreurs de logique qui sont plus difficiles à détecter. Le code est en effet syntaxiquement correct, mais il ne réalise pas les opérations prévues. Dans le meilleur des cas, ce type d’erreur se détecte lors de la phase de tests. Si elles sont au contraire détectées alors que l'application est en production, elles sont toujours plus délicates et surtout plus coûteuses à éliminer.
Lorsque l'application fonctionne normalement, les exceptions surviennent, quant à elles, lorsque l’exécution d'une instruction échoue. Ce type d'erreur se produit, par exemple, en cas de tentative d'ouverture d'un fichier qui n'existe pas. Si elle n'est pas gérée, le déclenchement d’une exception affiche un message et provoque l'arrêt brutal de l'application. Il est donc impératif de prévoir une gestion des éventuelles erreurs d'exécution afin de fiabiliser le comportement de l'application.
Organisé en deux parties, les outils de débogage de Visual Studio visant à éliminer les erreurs de logique, sont présentés dans la première de ce chapitre. Dans la deuxième partie, nous nous intéresserons à la gestion des exceptions au moyen de blocs Try Catch.
