[ Retour Accueil ]
Durée de réalisation estimée : 16H00
ce module s'adresse aux développeurs qui ont connaissance de la plate-forme .NET (module INT-CS ou niveau équivalent).
Ce module se compose de 4 chapitres :
[ Commander ]
Reprenant la syntaxe du langage C, rappelons que le langage C# est un langage moderne, comparable à Java, qui a été conçu dans l'optique d'offrir une plus grande sécurité et de tirer pleinement partir du Framework .NET. Etant basé sur la même infrastrucure, notamment sur un ensemble de types de données communs nommé CTS (Common Type System), il est entièrement compatible avec d'autres langage tels que Visual Basic .NET.
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 foreach 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, Le langage C# 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 les chapitres consacrés 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. Il en existe 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 chapitre 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 C#, 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.
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.
