M06-Programmation Evénementielle Vb.Net TIC-TSDI_2

Réf. n° : X09-02944

Cours n° : 2560A

Édité le : 09/2002

Guide pédagogique

Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaine, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs et toute ressemblance avec des sociétés, produits, noms de domaine, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l'objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d'autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d�un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Cours n° : 2560A Réf. n° : X09-02944 Édité le : 09/2002

Introduction à la programmation en Visual Basic .NET avec Microsoft .NET iii

Table des matières Introduction Introduction .............................................................................................................1 Documents de cours.................................................................................................2 Conditions préalables ..............................................................................................3 Plan du cours ...........................................................................................................4 Programme MOC ....................................................................................................7 Programme MCP .....................................................................................................9 Logistique ..............................................................................................................12 Module 1 : Mise en route Vue d'ensemble........................................................................................................1 Présentation multimédia : Vue d'ensemble de Visual Studio .NET.........................2 Leçon : Concepts de base de l'environnement .NET ...............................................3 Leçon : Exploration de l'environnement de développement..................................19 Leçon : Création d'un projet Visual Basic .NET ...................................................33 Contrôle des acquis................................................................................................40 Atelier 1.1 : Création de votre première application .............................................42 Module 2 : Utilisation de formulaires et de contrôles Vue d'ensemble........................................................................................................1 Présentation multimédia : Présentation des objets, propriétés, méthodes et événements ..........................................................................................2 Leçon : Compréhension des concepts de programmation .......................................3 Leçon : Utilisation de Windows Forms ...................................................................9 Leçon : Utilisation des contrôles ...........................................................................25 Leçon : Présentation de votre code........................................................................40 Contrôle des acquis................................................................................................46 Atelier 2.1 : Création de l'interface utilisateur.......................................................49 Module 3 : Utilisation de variables et de tableaux Vue d'ensemble........................................................................................................1 Présentation multimédia : Présentation des variables..............................................2 Leçon : Introduction aux types de données .............................................................4 Leçon : Utilisation de variables .............................................................................10 Leçon : Portée des variables ..................................................................................21 Leçon : Conversion des types de données .............................................................32 Atelier 3.1 : Création et utilisation de variables ....................................................38 Leçon : Création et utilisation de structures ..........................................................45 Leçon : Stockage de données dans des tableaux....................................................54 Contrôle des acquis................................................................................................62 Atelier 3.2 : Utilisation de structures et de tableaux..............................................65 Module 4 : Utilisation de procédures Vue d'ensemble........................................................................................................1 Leçon : Création de procédures ...............................................................................2 Leçon : Utilisation de procédures ..........................................................................21 Leçon : Utilisation de fonctions prédéfinies..........................................................37 Contrôle des acquis................................................................................................52 Atelier 4.1 : Création et utilisation de procédures .................................................54

iv Introduction à la programmation en Visual Basic .NET avec Microsoft .NET

Module 5 : Structures de décision et boucles Vue d'ensemble........................................................................................................1 Leçon : Utilisation d'expressions conditionnelles....................................................2 Leçon : Utilisation de structures de décision .........................................................14 Atelier 5.1 : Utilisation de structures de décision..................................................21 Leçon : Utilisation de structures de boucles conditionnelles.................................26 Contrôle des acquis................................................................................................39 Module 6 : Validation des entrées de l'utilisateur Vue d'ensemble........................................................................................................1 Présentation multimédia : Validation des entrées de l'utilisateur ............................2 Leçon : Limitation des entrées de l'utilisateur .........................................................4 Leçon : Validation des données de champs ...........................................................17 Leçon : Validation des données de formulaires.....................................................30 Contrôle des acquis................................................................................................38 Atelier 6.1 : Validation des entrées de l'utilisateur ................................................40 Module 7 : Programmation orientée objet en Visual Basic .NET Vue d'ensemble........................................................................................................1 Présentation multimédia : Présentation des objets et des classes et mode d'utilisation.................................................................................................2 Leçon : Compréhension des classes.........................................................................3 Leçon : Utilisation des classes.................................................................................8 Leçon : Utilisation des membres partagés .............................................................22 Leçon : Héritage, polymorphisme et espaces de noms ..........................................28 Contrôle des acquis................................................................................................36 Atelier 7.1 : Création d'une classe dérivée.............................................................38 Module 8 : Gestion des erreurs et des exceptions Vue d'ensemble........................................................................................................1 Leçon : Types d'erreurs............................................................................................2 Leçon : Utilisation du débogueur.............................................................................8 Leçon : Gestion des exceptions .............................................................................33 Contrôle des acquis................................................................................................47 Atelier 8.1 : Mise en �uvre de la gestion structurée des exceptions .....................49 Module 9 : Amélioration de l'interface utilisateur Vue d'ensemble........................................................................................................1 Leçon : Création de menus ......................................................................................2 Leçon : Création de barres d'état ...........................................................................14 Leçon : Création de barres d'outils ........................................................................22 Contrôle des acquis................................................................................................34 Module 10 : Formulaires Web et services Web XML Vue d'ensemble........................................................................................................1 Leçon : Utilisation des formulaires Web .................................................................2 Leçon : Utilisation des services Web XML...........................................................18 Contrôle des acquis................................................................................................29 Atelier 10.1 : Création d'une application Web.......................................................31

Introduction à la programmation en Visual Basic .NET avec Microsoft .NET v

Module 11 : Utilisation d'ADO.NET Vue d'ensemble........................................................................................................1 Leçon : Concepts des bases de données ..................................................................2 Leçon : Présentation d'ADO.NET .........................................................................14 Leçon : Utilisation des données.............................................................................27 Contrôle des acquis................................................................................................42 Atelier 11.1 : Accès aux données à l'aide d'ADO.NET .........................................44 Module 12 : Déploiement d'applications Vue d'ensemble........................................................................................................1 Leçon : Introduction au déploiement .......................................................................2 Leçon : Déploiement d'une application Windows .................................................10 Contrôle des acquis................................................................................................23 Atelier 12.1 : Déploiement d'une application ........................................................25

Introduction à la programmation en Visual Basic .NET avec Microsoft .NET vii

À propos de ce cours Cette section décrit brièvement le cours et ses objectifs, le profil des stagiaires ainsi que les connaissances préalables requises.

L'objectif de ce cours est de permettre aux développeurs possédant des connaissances en programmation dans un environnement non graphique, ainsi qu'aux développeurs débutant en programmation dans un environnement graphique, d'acquérir les compétences requises pour concevoir et développer une application d'interface utilisateur graphique (GUI, graphical user interface) simple, à l'aide de Microsoft® Visual Basic® .NET et de l'environnement de développement Microsoft Visual Studio® .NET

Ce cours s'adresse aux développeurs répondant aux critères suivants :

! Maîtrise des notions élémentaires en programmation structurée, notamment les concepts tels que le contrôle de flux, les variables, les paramètres et les appels de fonction

! Expérience (trois mois minimum) dans le domaine du développement d'applications dans un environnement graphique ou non graphique

! Connaissance ou non des concepts liés à la programmation orientée objet

Pour suivre ce cours, les stagiaires doivent disposer des connaissances suivantes :

! Maîtriser la programmation structurée ou justifier d'une expérience dans ce domaine. Le cours de formation Microsoft MSDN® n°2667, Introduction to Programming, peut aider les stagiaires à acquérir des connaissances de base liées aux techniques de programmation. Néanmoins, une expérience supplémentaire en écriture de code est nécessaire s'ils souhaitent tirer le meilleur parti du cours n°2560A, Introduction à la programmation en Visual Basic .NET avec Microsoft .NET.

! Maîtriser l'utilisation de la souris et du clavier et savoir les manipuler avec aisance pour la réalisation de tâches courantes (par exemple, navigation dans le système de fichiers, ouverture et enregistrement de fichiers dans un environnement applicatif GUI, tel que Microsoft Word ou Microsoft Internet Explorer).

Description

Profil des stagiaires

Connaissances préalables

viii Introduction à la programmation en Visual Basic .NET avec Microsoft .NET

À la fin de ce cours, les stagiaires seront à même d'effectuer les tâches suivantes :

! créer une application Visual Basic .NET simple, fondée sur le modèle Application Microsoft Windows® ;

! utiliser les formulaires et les contrôles pour créer une interface utilisateur ; ! créer et utiliser des variables et des tableaux ; ! créer et utiliser les procédures Sub et Function, y compris les fonctions

prédéfinies ; ! mettre en �uvre des structures de décision et des boucles à l'aide

d'expressions conditionnelles ; ! valider les entrées utilisateur dans les champs, les contrôles et les

formulaires ; ! appliquer des techniques de programmation orientée objet pour créer des

classes, et ajouter des méthodes et des propriétés ; ! gérer des erreurs de syntaxe, d'exécution et de logique à l'aide du débogueur

et de la gestion structurée des exceptions ; ! améliorer l'interface utilisateur en lui ajoutant des menus, des barres d'état et

des barres d'outils ; ! créer, à partir de Visual Basic .NET, une application Web Forms simple qui

utilise un service Web XML ; ! accéder aux données d'une base de données Microsoft Access ou Microsoft

SQL Server� et les manipuler avec Microsoft ADO.NET ; ! générer, intégrer et déployer une application.

Objectifs

Introduction à la programmation en Visual Basic .NET avec Microsoft .NET ix

Calendrier du cours Voici une estimation horaire du déroulement du cours. Il est possible que vos horaires soient différents de ceux indiqués dans le tableau suivant :

Premier jour Début Fin Module

9:00 9:30 Introduction

9:30 10:30 Module 1 : Mise en route

10:30 10:45 Pause

10:45 11:15 Module 1 : Mise en route (suite)

11:15 11:45 Atelier 1.1 : Création de votre première application

11:45 12:45 Déjeuner

12:45 14:00 Module 2 : Utilisation de formulaires et de contrôles

14:00 14:45 Atelier 2.1 : Création de l'interface utilisateur

14:45 15:00 Pause

15:00 16:45 Module 3 : Utilisation de variables et de tableaux

Deuxième jour Début Fin Module

9:00 9:30 Contrôle des acquis du premier jour

9:30 10:15 Atelier 3.1 : Création et utilisation de variables

10:15 10:30 Pause

10:30 11:15 Module 3 : Utilisation de variables et de tableaux (suite)

11:15 11:45 Atelier 3.2 : Utilisation de structures et de tableaux


12:45 14:30 Module 4 : Utilisation de procédures

14:30 14:45 Pause

14:45 15:45 Atelier 4.1 : Création et utilisation de procédures

15:45 16:45 Module 5 : Structures de décision et boucles

x Introduction à la programmation en Visual Basic .NET avec Microsoft .NET

Troisième jour Début Fin Module

9:00 9:30 Contrôle des acquis du deuxième jour

9:30 10:15 Atelier 5.1 : Utilisation de structures de décision

10:15 10:30 Pause

10:30 11:15 Module 5 : Structures de décision et boucles (suite)

11:15 12:00 Module 6 : Validation des entrées de l'utilisateur


13:00 13:45 Module 6 : Validation des entrées de l'utilisateur (suite)

13:45 14:30 Atelier 6.1 : Validation des entrées de l'utilisateur

14:30 14:45 Pause

14:45 17:00 Module 7 : Programmation orientée objet en Visual Basic .NET

Quatrième jour Début Fin Module

9:00 9:30 Contrôle des acquis du troisième jour

9:30 10:00 Atelier 7.1 : Création d'une classe dérivée

10:00 10:30 Module 8 : Gestion des erreurs et des exceptions

10:30 10:45 Pause

10:45 12:00 Module 8 : Gestion des erreurs et des exceptions (suite)


13:00 13:45 Atelier 8.1 : Mise en �uvre de la gestion structurée des exceptions

13:45 14:30 Module 9 : Amélioration de l'interface utilisateur

14:30 14:45 Pause

14:45 15:15 Module 9 : Amélioration de l'interface utilisateur (suite)

15:15 17:00 Module 10 : Formulaires Web et services Web XML

Cinquième jour Début Fin Module

9:00 9:30 Contrôle des acquis du quatrième jour

9:30 10:00 Atelier 10.1 : Création d'une application Web

10:00 10:45 Module 11 : Utilisation d'ADO.NET

10:45 11:00 Pause

11:00 12:15 Module 11 : Utilisation d'ADO.NET (suite)


13:15 13:45 Atelier 11.1 : Accès aux données à l'aide d'ADO.NET

13:45 14:30 Module 12 : Déploiement d'applications

14:30 14:45 Pause

14:45 15:15 Atelier 12.1 : Déploiement d'une application

Introduction à la programmation en Visual Basic .NET avec Microsoft .NET xi

Contenu du CD-ROM de l'instructeur Le CD-ROM de l'instructeur contient les fichiers et dossiers décrits ci-dessous :

! Autorun.exe. Lorsque le CD-ROM est inséré dans le lecteur, ou lorsque vous double-cliquez sur le fichier Autorun.exe, ce fichier lance le CD-ROM et vous permet de parcourir le CD-ROM du stagiaire ou de l'instructeur.

! Autorun.inf. Lorsque le CD-ROM est inséré dans le lecteur, ce fichier lance Autorun.exe.

! Default.htm. Ce fichier ouvre les pages Web destinées à l'instructeur. ! Readme.txt. Ce fichier explique comment installer le logiciel permettant

d'afficher le CD-ROM de l'instructeur et son contenu, et comment ouvrir les pages Web destinées à l'instructeur.

! 2560A_ms.doc. Ce fichier contient le Guide de configuration manuelle de la classe. Il contient les étapes à exécuter pour configurer manuellement les ordinateurs de la classe.

! 2560A_sg.doc. Ce fichier contient le Guide de configuration automatisée de la classe. Il fournit une description de la configuration de la classe et des conditions requises, des instructions relatives à l'utilisation des scripts de configuration automatisée de la classe et la liste de vérification de la configuration de la classe.

! Powerpnt. Ce dossier contient les diapositives Microsoft PowerPoint® utilisées durant ce cours.

! Pptview. Ce dossier contient la visionneuse Microsoft PowerPoint 97 que vous pouvez utiliser pour afficher les diapositives PowerPoint si Microsoft PowerPoint 2002 n'est pas disponible. N'utilisez pas cette version en classe.

! Setup. Ce dossier contient les fichiers nécessaires pour installer le cours et les logiciels associés sur les ordinateurs de la classe.

! StudentCD. Ce dossier contient les pages Web destinées aux stagiaires. Ces pages comportent des liens renvoyant à des ressources ayant un rapport avec ce cours, notamment des lectures complémentaires, les réponses aux questions du contrôle des acquis et des ateliers, les fichiers des ateliers, les présentations multimédias et les sites Web se rapportant au cours.

! Tools. Ce dossier contient les fichiers et les utilitaires employés pour achever la configuration de l'ordinateur de l'instructeur.

! Webfiles. Ce dossier contient les fichiers requis pour afficher les pages Web du cours. Pour accéder à la page Web, ouvrez l'Explorateur Windows, puis double-cliquez sur Default.htm ou Autorun.exe dans le répertoire racine du CD-ROM.

xii Introduction à la programmation en Visual Basic .NET avec Microsoft .NET

Contenu du CD-ROM du stagiaire Le CD-ROM du stagiaire contient les fichiers et dossiers décrits ci-dessous :

! Autorun.exe. Lorsque le CD-ROM est inséré dans le lecteur, ou lorsque vous double-cliquez sur le fichier Autorun.exe, ce fichier lance le CD-ROM du stagiaire et vous permet de le parcourir.

! Autorun.inf. Lorsque le CD-ROM est inséré dans le lecteur, ce fichier lance Autorun.exe.

! Default.htm. Ce fichier ouvre la page Web destinée aux stagiaires. Ces pages comportent des liens renvoyant à des ressources ayant un rapport avec ce cours, notamment des lectures complémentaires, les réponses aux questions de contrôle des acquis et des ateliers, les fichiers des ateliers, des présentations multimédias et des sites Web se rapportant au cours.

! Readme.txt. Ce fichier explique comment installer le logiciel permettant d'afficher le CD-ROM du stagiaire et son contenu, et comment ouvrir la page Web destinée au stagiaire.

! 2560A_ms.doc. Ce fichier contient le Guide de configuration manuelle de la classe. Ce guide décrit la configuration de la classe, avec les conditions requises et des instructions de préparation spécifiques.

! Addread. Ce dossier contient des lectures complémentaires ayant un rapport avec ce cours.

! Democode. Ce dossier contient le code des démonstrations. ! Flash. Ce dossier contient le programme d'installation du plug-in

Macromedia Flash 5.0. ! Fonts. Ce dossier contient les polices requises pour afficher les

présentations PowerPoint et les documents de type Web. ! Labfiles. Ce dossier contient les fichiers utilisés lors des ateliers. Certains de

ces fichiers peuvent aussi être employés pour préparer les ordinateurs des stagiaires en vue des ateliers.

! Media. Ce dossier contient les fichiers utilisés dans les présentations multimédias de ce cours.

! Mplayer. Ce dossier contient le fichier d'installation du lecteur multimédia Microsoft Windows Media� Player.

! Practices. Ce dossier contient les fichiers utilisés lors des applications pratiques.

! Webfiles. Ce dossier contient les fichiers requis pour afficher les pages Web du cours. Pour accéder à la page Web, ouvrez l'Explorateur Windows, puis double-cliquez sur Default.htm ou Autorun.exe dans le répertoire racine du CD-ROM.

! Wordview. Ce dossier contient la visionneuse Word, utilisée pour afficher tous les fichiers Word (.doc) situés sur le CD-ROM.

Introduction à la programmation en Visual Basic .NET avec Microsoft .NET xiii

Conventions typographiques Les conventions suivantes sont utilisées dans les documents du cours afin de distinguer les différents éléments de texte :

Convention Valeur Gras Représente les commandes, options de commande et éléments

de syntaxe qui doivent être tapés tels qu'ils sont présentés. Cette mise en forme de caractères désigne également les commandes de menu et les boutons, les titres et options de boîte de dialogue ainsi que les noms de menu.

Italique Dans les syntaxes ou le texte descriptif, l'italique représente les noms d'argument ou les espaces réservés aux variables. Cette mise en forme de caractères est également utilisée pour introduire des termes nouveaux, citer des titres d'ouvrage et mettre en valeur des éléments du texte.

Majuscules initiales Représentent les noms de domaine, d'utilisateur, d'ordinateur, de répertoire, de dossier et de fichier (sauf lorsqu'il s'agit de noms avec respect de la casse). Sauf indication contraire, vous pouvez taper les noms de répertoire ou de fichier en minuscules dans les boîtes de dialogue ou à l'invite.

MAJUSCULES Représentent les noms de touche ainsi que les séquences et les combinaisons de touches, par exemple, ALT+ESPACE.

espacement fixe

Représente les exemples de code ou les exemples de texte affiché à l'écran.

[ ] Dans les syntaxes, délimitent les éléments facultatifs. Par exemple, [fichier] dans la syntaxe d'une commande indique que vous pouvez taper un nom de fichier dans la commande. Tapez uniquement les informations indiquées entre crochets, et non les crochets proprement dits.

{ } Dans les syntaxes, délimitent les éléments obligatoires. Tapez uniquement les informations indiquées entre accolades, et non les accolades proprement dites.

| Dans les syntaxes, sépare les éléments mutuellement exclusifs d'un choix.

! Représente une procédure composée d'étapes séquentielles.

... Dans les syntaxes, indiquent que l'élément précédent peut être répété.

.

.

.

Représente une partie omise dans un exemple de code.

THIS PAGE INTENTIONALLY LEFT BLANK.

Table des matières

Introduction 1

Documents de cours 2

Conditions préalables 3

Plan du cours 4

Programme MOC 7

Programme MCP 9

Logistique 12

Introduction

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaines, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs et toute ressemblance avec des sociétés, produits, noms de domaines, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l'objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d'autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d'un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Introduction iii

Notes de l'instructeur Ce module d'introduction donne aux stagiaires une vue d'ensemble du contenu, des documents et de l'organisation du cours 2560A, « Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET ».

Pour animer ce cours, vous devez disposer des éléments suivants :

! Guide pédagogique ! CD-ROM de l'instructeur

Pour préparer ce cours, vous devez réaliser les différentes étapes décrites dans la Liste de préparation au cours, fournie avec les documents de cours de l'instructeur.

Présentation : 30 minutes

Documents de cours

Préparation

iv Introduction

Comment animer ce module Cette section contient des informations qui ont pour but de vous aider à animer ce module.

Accueillez les stagiaires et présentez-vous. Donnez un bref aperçu de vos acquis afin d'établir votre crédibilité en tant qu'instructeur.

Invitez les stagiaires à se présenter en indiquant leur expérience, leur connaissance du produit et leurs attentes concernant ce cours.

Notez sur un tableau blanc ou à feuilles mobiles les attentes des stagiaires afin de pouvoir vous y référer pendant le cours.

Signalez aux stagiaires que tout ce dont ils ont besoin pour ce cours leur est fourni à leur arrivée.

Demandez aux stagiaires d'inscrire leur nom de chaque côté de la fiche.

Décrivez le contenu du manuel de travail et du CD-ROM du stagiaire.

Indiquez aux stagiaires où ils peuvent envoyer leurs commentaires et impressions sur le cours.

Montrez comment ouvrir la page Web fournie sur le CD-ROM du stagiaire en double-cliquant sur Autorun.exe ou Default.htm dans le dossier StudentCD du CD-ROM de l'instructeur.

Décrivez les connaissances préalables requises pour suivre ce cours. De cette façon, vous pourrez identifier ceux qui n'ont pas l'expérience ou les acquis suffisants pour assister à ce cours.

Décrivez brièvement chacun des modules en soulignant ce que les stagiaires apprendront. Veillez à ne pas trop entrer dans les détails à ce stade, le Module 1 étant prévu à cet effet.

Montrez de quelle manière ce cours répondra aux attentes des stagiaires, en faisant le lien avec le contenu des différents modules.

Expliquez ce qu'est le programme MOC (Microsoft Official Curriculum) et présentez la liste des cours supplémentaires recommandés.

Renvoyez les stagiaires à la page Web Microsoft Official Curriculum à l'adresse http://www.eu.microsoft.com/france/formation pour plus d'informations sur les cours.

Donnez aux stagiaires des informations sur le programme MCP (Microsoft Certified Professional), sur les examens de certification relatifs à ce cours et sur les différentes certifications possibles.

Décrivez l'organisation du cours : heures de cours, prolongation des horaires d'ouverture des locaux pour les ateliers, stationnement, toilettes, repas, téléphone, boîte aux lettres ou messagerie et zones fumeurs.

Indiquez aux stagiaires si l'établissement est équipé d'un accès Internet qu'ils pourront utiliser pendant les pauses.

Assurez-vous également que les stagiaires sont informés des éventuelles dispositions concernant le recyclage des déchets.

Introduction

Documents de cours

Conditions préalables

Plan du cours

Programme MOC

Programme MCP

Logistique

Introduction 1

Introduction

! Nom

! Société

! Titre/fonction

! Position

! Expérience en programmation, réseaux et bases de données

! Connaissance du produit

! Attentes concernant le cours

********************DOCUMENT A L'USAGE EXCLUSIF DE L'INSTRUCTEUR********************

Votre instructeur va vous demander de vous présenter et de fournir un bref aperçu de votre expérience, en suivant les éléments de la liste à puce de la diapositive.

2 Introduction

Documents de cours

! Fiche

! Manuel de travail du stagiaire

! CD-ROM du stagiaire

! Évaluation du cours


Votre kit de cours contient les documents détaillés ci-dessous.

! Fiche. Inscrivez votre nom des deux côtés de la fiche. ! Manuel de travail du stagiaire. Ce manuel expose les sujets traités dans le

cadre du cours, ainsi que les exercices réalisés pendant les ateliers. ! CD-ROM du stagiaire. Ce CD-ROM contient la page Web destinée aux

stagiaires. Cette page comporte des liens renvoyant à des ressources ayant un rapport avec ce cours, notamment des lectures complémentaires, les réponses aux questions de contrôle des acquis et des ateliers, les fichiers des ateliers, les présentations multimédias et les sites Web se rapportant au cours.

Pour ouvrir la page Web du stagiaire, insérez le CD-ROM du stagiaire dans le lecteur, puis double-cliquez à la racine sur Autorun.exe ou Default.htm.

! Évaluation du cours. Pour envoyer vos commentaires et impressions sur l'instructeur, le cours et le produit logiciel exploité, envoyez un courrier électronique à l'adresse de messagerie [email protected] ; veillez à taper Cours 2650 dans la zone Objet de votre message. Cette adresse correspondant à un service américain de Microsoft®, pensez à rédiger votre message en anglais. Vos commentaires nous aideront à améliorer nos prochains cours. Pour faire des commentaires complémentaires ou obtenir des renseignements sur le programme MCP, vous pouvez envoyer un courrier électronique à l'adresse [email protected]. Cette adresse correspondant à un service américain de Microsoft, pensez à rédiger votre message en anglais.

Remarque

Introduction 3


! Expérience de la navigation dans Microsoft Windows

! Expérience de minimum 3 mois dans la programmation

! Compréhension des concepts de base de la programmation structurée, notamment :

" le contrôle de flux

" les variables

" les paramètres

" les appels de fonction


Pour suivre ce cours, les stagiaires doivent disposer des connaissances suivantes :

! Expérience de la navigation dans Microsoft Windows. ! Expérience de minimum 3 mois dans le développement d'applications en

environnement graphique ou non graphique. � Et �

! Réussite du cours Microsoft MSDN® Training 2667, « Introduction to Programming » (en anglais). � Ou �

! Compréhension des concepts de base de la programmation structurée, notamment les concepts de contrôle de flux, de variables et paramètres, et d'appels de fonction.

4 Introduction

Plan du cours

! Module 1 : Mise en route

! Module 2 : Utilisation de formulaires et de contrôles

! Module 3 : Utilisation de variables et de tableaux

! Module 4 : Utilisation de procédures

! Module 5 : Structures de décision et boucles

! Module 6 : Validation des entrées de l�utilisateur


Le Module 1, « Mise en route », présente Visual Basic .NET et explique son intégration dans la plate-forme Microsoft .NET. Il explique comment utiliser les outils de programmation inclus dans Microsoft Visual Studio® .NET et fournit des exercices permettant aux stagiaires de créer leur première application dans Visual Basic .NET.

Le Module 2, « Utilisation de formulaires et de contrôles », expose les concepts fondamentaux de la programmation, comme la programmation événementielle, les classes, les objets, les propriétés, les méthodes et les événements. Ce module explique également comment utiliser les formulaires et les contrôles pour créer une interface utilisateur, par exemple : comment créer un formulaire, définir des propriétés, appeler des méthodes, écrire du code pour des événements, ajouter des contrôles à un formulaire, gérer plusieurs formulaires, utiliser les messages, utiliser les conventions d'affectation de noms, et comment formater et documenter du code.

Le Module 3, « Utilisation de variables et de tableaux », explique comment nommer, déclarer et utiliser des variables et des constantes, et comment leur affecter des valeurs. Il explique comment déclarer des variables avec différents niveaux de portée, comment créer vos propres structures de données et comment convertir des valeurs de variables d'un type de donnée à un autre. Il décrit également le stockage des données dans un tableau.

Le Module 4, « Utilisation de procédures », explique comment créer et utiliser les procédures Sub et Function, notamment les fonctions prédéfinies, et comment structurer du code afin d'améliorer sa réutilisation.

Introduction 5

Le Module 5, « Structures de décision et boucles », explique comment implémenter des structures de décision et des boucles afin de contrôler la sortie et l'exécution du programme.

Le Module 6, « Validation des entrées de l'utilisateur », explique comment valider les entrées de l'utilisateur à la fois au niveau des champs et des formulaires dans les applications. Il décrit également comment gérer les entrées non valides à l'aide de messages d'erreur et en guidant les utilisateurs dans le processus de détection et de correction des erreurs. Enfin, il explique comment utiliser les propriétés et les méthodes des contrôles en vue de limiter et de valider les entrées de données.

6 Introduction

Plan du cours (suite)

! Module 7 : Programmation orientée objet en Visual Basic .NET

! Module 8 : Gestion des erreurs et des exceptions

! Module 9 : Amélioration de l�interface utilisateur

! Module 10 : Formulaires Web et services Web XML

! Module 11 : Utilisation d�ADO.NET

! Module 12 : Déploiement d�applications


Le Module 7, « Programmation orientée objet en Visual Basic .NET », explique comment créer et utiliser les classes. Ce module présente les concepts d'abstraction, d'encapsulation, d'instanciation, d'initialisation, de constructeurs et de destructeurs. Il décrit également les notions d'héritage, de polymorphisme et d'espace de noms.

Le Module 8, « Gestion des erreurs et des exceptions », présente les différents types d'erreur susceptibles de se produire dans un programme, et explique comment utiliser les outils de débogage fournis avec Visual Basic .NET pour le diagnostic et la correction de ces erreurs. Ces outils incluent le débogueur Visual Studio .NET, les fenêtres de débogage et la gestion structurée des exceptions.

Le Module 9, « Amélioration de l'interface utilisateur », explique comment créer des menus, des barres d'état et des barres d'outils afin d'améliorer la convivialité d'une application.

Le Module 10, « Formulaires Web et services Web XML », explique comment utiliser les Web Forms pour créer une application Web, et comment invoquer un service Web XML simple depuis une application Web.

Le Module 11, « Utilisation d'ADO.NET », explique comment utiliser Microsoft ADO.NET avec une application Windows Forms pour créer, lire, mettre à jour et supprimer des enregistrements dans des bases de données Microsoft Access et Microsoft SQL Server�.

Le Module 12, « Déploiement d'applications », présente diverses options de déploiement disponibles dans Visual Basic .NET, et explique comment déployer des applications Windows.

Introduction 7

Programme MOC

2560, Introduction à la programmation en Visual Basic

.NET avec Microsoft .NET2565, Developing Microsoft .NET

Applications for Windows (Visual Basic .NET)

2333, Développement d'applications Web Microsoft ASP.NET à l'aide

de Visual Studio .NET

2415, Programming with the Microsoft .NET Framework

(Microsoft Visual Basic .NET)

http://www.eu.microsoft.com/france/formation


Microsoft Formations et Certifications développe le programme MOC (Microsoft Official Curriculum), y compris MSDN Training, pour les professionnels de l'informatique qui conçoivent, développent, prennent en charge, implémentent ou gèrent des solutions à l'aide de produits et de technologies Microsoft. Ces cours, animés par un instructeur, offrent une formation basée sur les compétences et bénéficient de formats en ligne.

Chaque cours se réfère d'une certaine manière à un autre cours. Celui-ci peut être une compétence requise, un cours complémentaire d'une série recommandée ou un cours permettant d'acquérir une formation supplémentaire.

Pour en savoir plus sur le développement d'applications Windows à l'aide de Visual Basic .NET, nous vous recommandons de suivre les cours suivants dans l'ordre indiqué :

Cours Titre et description 2565 « Developing Microsoft .NET Applications for Windows

(Visual Basic .NET) » (en anglais) Ce cours animé par un instructeur et réparti sur trois journées fait partie du curriculum Visual Basic .NET et couvre les principaux points de la programmation d'application clientes Windows sur le Microsoft .NET Framework. Il aborde notamment les sujets suivants : Windows Forms, GDI+, accès simple de données, interopérabilité avec code non géré, threading et programmation asynchrone, accès distant simple, accès Web, consommation de services Web XML, débogage, sécurité et problèmes de déploiement pour les applications de bureau.

Introduction

Autres cours recommandés

8 Introduction

(suite) Cours Titre et description 2415 « Programming with the Microsoft .NET Framework

(Microsoft Visual Basic .NET) » (en anglais) Ce cours animé par un instructeur et réparti sur cinq journées aide les développeurs d'applications à comprendre le .NET Framework. En plus d'une introduction aux concepts principaux et à la terminologie, ce cours comporte également une série d'ateliers, expliquant les fonctionnalités du concept .NET Framework qui sont utilisées pour coder, déboguer, régler et déployer des applications. Les sujets abordés incluent l'utilisation des assemblys, le versioning, le système de type commun, la gestion de la mémoire, les E/S de fichier et réseau, la sérialisation, l'accès distant et les services Web XML.

Après le cours 2560A, « Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET », vous pouvez également suivre le cours suivant si vous souhaitez en savoir plus sur le développement d'applications Web :

Cours Titre et description 2333 « Développement d'applications Web Microsoft ASP.NET à l'aide de

Visual Studio .NET » Ce cours animé par un instructeur et réparti sur cinq journées enseigne aux programmeurs en Visual Basic et aux développeurs Web débutants les bases de l'implémentation d'applications Web avec ASP.NET et Visual Basic .NET. Ce cours se concentre sur l'utilisation de l'environnement Visual Studio .NET et de la plate-forme .NET en vue de créer une application Web ASP.NET capable de fournir du contenu dynamique sur le Web.

Il se peut que d'autres cours traitant de ce sujet soient disponibles à l'avenir. Par conséquent, si vous souhaitez des informations mises à jour à propos des formations recommandées, consultez le site Web Formations et Certifications.

Pour plus d'informations, consultez le site Web Microsoft Formations et Certifications à l'adresse http://www.eu.microsoft.com/france/formation.

Informations Microsoft Formations et Certifications

Introduction 9

Programme MCP

http://www.microsoft.com/france/formation/cert/mcp/default.asp


Microsoft Formations et Certifications offre diverses certifications pour les développeurs et les professionnels de l'informatique. Le programme MCP (Microsoft Certified Professional) est un programme de certification renommé qui valide votre expérience et vos connaissances pour assurer votre compétitivité sur un marché de l'emploi en pleine évolution.

Le programme MCP comprend les certifications ci-dessous.

! MCSA sur Microsoft Windows 2000 La certification MCSA (Microsoft Certified Systems Administrator) est destinée aux professionnels qui implémentent, gèrent et dépannent des environnements réseau et système existants fondés sur des plates-formes Microsoft Windows 2000, dont la famille Windows .NET Server. Leurs tâches d'implémentation comprennent l'installation et la configuration d'au moins une partie de ces systèmes. En matière de gestion, leurs responsabilités englobent l'administration et le support technique de ces systèmes.

! MCSE sur Microsoft Windows 2000 La certification MCSE (Microsoft Certified Systems Engineer) est la principale certification pour les professionnels dont le rôle consiste à analyser les besoins des entreprises, pour ensuite concevoir et implémenter des infrastructures de solutions d'entreprise fondées sur la plate-forme Microsoft Windows 2000 et les logiciels serveurs de Microsoft, dont la famille Windows .NET Server. Leurs tâches d'implémentation comprennent l'installation, la configuration et le dépannage de systèmes réseau.

Introduction

Certifications MCP

10 Introduction

! MCAD La certification MCAD (Microsoft Certified Application Developer) pour Microsoft .NET est destinée aux professionnels qui utilisent les technologies Microsoft pour développer et maintenir des applications au niveau de leur département, des composants, des clients Web ou de bureau, ou des services principaux de données, et pour ceux qui travaillent dans des équipes de développement d'applications d'entreprise. Cette certification couvre des tâches allant du développement et du déploiement à la maintenance de la solution.

! MCSD La certification MCSD (Microsoft Certified Solution Developer) est la principale certification pour les professionnels qui conçoivent et développent des solutions d'entreprise de pointe à l'aide d'outils de développement, de technologies et de plates-formes Microsoft, de même qu'avec l'architecture Microsoft Windows DNA. Parmi les types d'applications que les titulaires d'une certification MCSD sont susceptibles de développer, citons les applications de bureau et multi-utilisateurs, les applications Web, les applications multiniveaux et les applications transactionnelles. Les tâches qu'ils assument vont de l'analyse des besoins de l'entreprise à la maintenance des solutions mises en �uvre.

! MCDBA sur Microsoft SQL Server 2000 La certification MCDBA (Microsoft Certified Database Administrator) est la principale certification à l'intention des professionnels chargés de l'implémentation et de l'administration de bases de données Microsoft SQL Server. Cette certification valide les compétences dans les domaines suivants : mise à jour d'anciens modèles de bases de données physiques, développement de modèles de données logiques, création de bases de données physiques, création de services de données au moyen de Transact-SQL, gestion et maintenance des bases de données, configuration et gestion de la sécurité, surveillance et optimisation des bases de données, et installation et configuration de SQL Server.

! MCP La certification MCP (Microsoft Certified Professional) valide les compétences dans le domaine de l'implémentation d'un produit ou d'une technologie Microsoft intégrés à une solution d'entreprise au sein d'une organisation. Il est nécessaire de bénéficier d'une expérience pratique du produit pour obtenir cette certification.

! MCT La certification MCT (Microsoft Certified Trainers) valide les compétences pédagogiques et techniques des personnes qui dispensent des cours MOC (Microsoft Official Curriculum) dans des centres de formation technique agréés Microsoft CTEC (Certified Technical Education Center).

Introduction 11

Les critères retenus varient en fonction des certifications. Ils dépendent des produits et des responsabilités professionnelles auxquels répond chacune de ces certifications. Pour devenir MCP, vous devez être reçu à des examens de certification rigoureux qui permettent d'évaluer de manière valide et fiable vos compétences et connaissances techniques.

Consultez le site Web Formations et Certifications de Microsoft France à l'adresse http://www.microsoft.com/france/formation/cert/mcp/default.asp.

Vous pouvez aussi envoyer un courrier électronique à l'adresse [email protected] pour toute question concernant la certification.

Les cours MOC (Microsoft Official Curriculum) et la formation MSDN® peuvent vous permettre d'acquérir les compétences nécessaires pour votre travail. Ils renforcent également l'expérience que vous avez acquise lors de l'utilisation des produits et technologies Microsoft. Cependant, il n'existe pas de correspondance directe entre les cours MOC et MSDN et les examens MCP. Le seul suivi des cours ne garantit pas forcément la réussite aux examens MCP : de l'expérience et des connaissances pratiques sont également nécessaires.

Pour préparer les examens MCP, vous pouvez utiliser les guides de préparation disponibles pour chaque examen. Chaque Guide de préparation contient des informations spécifiques à un examen, telles que la liste des sujets sur lesquels vous serez interrogé. Ces guides sont disponibles sur le site Web Formations et Certifications de Microsoft France à l'adresse http://www.microsoft.com/france/formation/cert/mcp/default.asp.

Conditions requises pour l'obtention des certifications

Pour plus d'informations

Acquisition des compétences validées par un examen MCP

12 Introduction

Logistique

! Heures de cours! Horaires d'ouverture des locaux! Stationnement! Toilettes! Repas! Téléphone! Messages! Zones fumeurs! Recyclage des déchets


THIS PAGE INTENTIONALLY LEFT BLANK

Table des matières

Vue d'ensemble 1

Présentation multimédia : Vue d'ensemble de Visual Studio .NET 2

Leçon : Concepts de base de l'environnement .NET 3

Leçon : Exploration de l'environnement de développement 19

Leçon : Création d'un projet Visual Basic .NET 33

Contrôle des acquis 40

Atelier 1.1 : Création de votre première application 42

Module 1 : Mise en route

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaines, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs et toute ressemblance avec des sociétés, produits, noms de domaines, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l�objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d�autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d'un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Module 1 : Mise en route iii

Notes de l'instructeur Ce module présente Microsoft® Visual Basic® .NET et explique de quelle façon il s'intègre à la plate-forme Microsoft .NET. Il explique également comment utiliser les outils de programmation dans Microsoft Visual Studio® .NET et propose des exercices pour aider les stagiaires à créer leur première application dans Visual Basic .NET.

À la fin de ce module, les stagiaires seront à même d'effectuer les tâches suivantes :

! démarrer un projet Visual Basic .NET basé sur le modèle d'application Microsoft Windows® ;

! utiliser la barre d'outils standard, les outils de programmation et les fenêtres de programmation dans l'environnement de développement afin d'utiliser les applications ;

! créer une application Visual Basic .NET simple.

Pour animer ce module, vous devez disposer des éléments suivants :

! Fichier Microsoft PowerPoint® 2560A_01.ppt ! Présentation multimédia 2560A_01d005.wmv

Pour préparer ce module, vous devez effectuer les tâches suivantes :

! lire tous les documents de cours relatifs à ce module ; ! visualiser la présentation multimédia ; ! effectuer les exercices et réaliser l'atelier de ce module.

Présentation et exercices : 90 minutes Atelier : 30 minutes

Documents de cours

Préparation

iv Module 1 : Mise en route


Présentation multimédia : Vue d'ensemble de Visual Studio .NET Ce module commence par une présentation multimédia dans laquelle sont décrits les concepts et les tâches clés enseignés dans ce module. Dans cette présentation, les stagiaires découvrent Visual Studio .NET et apprennent à travailler dans cet environnement de développement.

Pour la lancer, cliquez sur l'icône située au centre de la diapositive. Si vous le souhaitez, vous pouvez vous référer aux informations destinées à l'instructeur concernant la présentation du fichier multimédia. Elles se trouvent dans la section Démonstrations des notes de l'instructeur.

Pour plus d'informations sur les paramètres d'affichage à choisir pour la présentation multimédia, reportez-vous à la Liste de préparation au cours fournie avec le kit de l'instructeur.

Vous pouvez vous référer à la présentation pendant que vous dispensez la formation sur ce module. Vous pouvez vous reporter aux diapositives de PowerPoint et revenir à la présentation multimédia ou inversement pour présenter le contenu de chaque section.

Leçon : Concepts de base de l'environnement .NET Cette section décrit les méthodes pédagogiques appliquées pour la présentation des sections de cette leçon. Pour chaque section, ouvrez Visual Studio .NET et expliquez comment effectuer les tâches que le stagiaire devra réaliser lui-même pendant les exercices.

Cette section présente les éléments clés de la plate-forme .NET et explique comment ils se combinent pour autoriser une pratique de l'informatique sans précédent. La plupart des informations fournies dans cette section le sont à titre de référence. Pendant la leçon, mettez l'accent sur le rôle de Visual Studio .NET en tant qu'outil spécifiquement conçu pour la création de solutions destinées à la plate-forme .NET. Suscitez l'intérêt des stagiaires en leur expliquant qu'ils peuvent devenir des acteurs importants dans la création d'une nouvelle génération de logiciels s'ils apprennent à créer des applications dans Visual Basic .NET.

Présentez l'étude de cas comme un exemple de la façon dont l'environnement .NET aide les entreprises à résoudre leurs problèmes. N'accordez pas plus de cinq minutes à cette section. À la fin du cours, vous pouvez aborder à nouveau cette section ainsi que la suivante afin de résumer ce que les stagiaires ont appris.

Remarque

Présentation de la plate-forme .NET

Module 1 : Mise en route v

Cette section explique comment les applications créées dans Visual Basic .NET interagissent avec Microsoft .NET Framework. Axez la leçon sur la façon dont la bibliothèque de classes fournit des fonctionnalités standard aux applications basées sur l'environnement .NET, quelle que soit la langue dans lesquelles ces applications sont écrites, et sur la façon dont le CLR (Common Language Runtime) permet au code écrit en Visual Basic .NET de fonctionner dans n'importe quel service ou système basé sur l'environnement .NET. Les informations contenues dans cette section doivent être transmises aux programmeurs débutants à titre de référence uniquement. N'accordez pas plus de 10 minutes aux deux sections de cette leçon.

Le message important que cette section contient et que vous devez transmettre est que l'environnement de développement est le point central de la création de toutes les parties d'une solution, y compris des composants, des applications Windows Forms, Web Forms et des services Web XML. Ce cours se concentre sur les applications Windows Forms.

Présentez cette section succinctement. Assurez-vous que les stagiaires ont bien compris qu'ils pouvaient utiliser les liens de la page de démarrage de Visual Studio pour effectuer des recherches. Le volet Communauté en ligne a soulevé l'intérêt des testeurs de la version bêta. Aussi, si vous en avez le temps, montrez comment participer à un newsgroup au sein de cette Communauté en ligne.

Le principal objectif de cette section est d'expliquer clairement aux stagiaires ce qu'est un modèle et quel intérêt il présente pour le développeur. Indiquez que ce cours aborde principalement la création des applications Windows Forms, bien qu'il contienne une brève introduction sur les applications Web Forms que les services Web XML utilisent. Si cela intéresse les stagiaires, renvoyez-les aux autres cours qui traitent des autres types d'applications.

Montrez comment démarrer un nouveau projet Visual Basic .NET et parlez brièvement des nombreux types de projets et de modèles lorsque vous présentez la boîte de dialogue Nouveau projet.

Montrez comment ouvrir et fermer l'Explorateur de solutions et penchez-vous rapidement sur les fichiers qui constituent chaque solution Visual Basic .NET. Il se peut que les stagiaires soient surpris par la présence d'onglets différents dans le coin supérieur de la fenêtre. Expliquez qu'ils permettent d'accéder à des vues différentes des fichiers et qu'ils feront l'objet d'une présentation plus détaillée ultérieurement. Vous pouvez préciser que les fenêtres Index, Sommaire et Recherche de la documentation produit apparaissent parfois dans la zone de l'Explorateur de solutions et qu'elles seront traitées plus en détail à la leçon suivante.

Avant que les stagiaires ne commencent l'exercice, expliquez la différence entre la version déboguée et la version de diffusion. Vous pouvez également montrer aux stagiaires comment trouver le fichier exécutable. Précisez quels sont les noms de fichier qui sont modifiés lorsque vous renommez et enregistrez un projet. Cet exercice doit normalement durer 10 minutes environ.

Fonctionnement de Microsoft .NET Framework

Présentation de Microsoft Visual Studio® .NET

Utilisation de la page de démarrage

Présentation d'un modèle d'application

Utilisation de l'Explorateur de solutions

Application pratique : Utilisation d'un projet Visual Basic .NET

vi Module 1 : Mise en route

Leçon : Exploration de l'environnement de développement Cette section décrit les méthodes pédagogiques appliquées pour la présentation des sections de cette leçon. Cette leçon présente les fonctionnalités principales de l'environnement de développement qui permettent de créer et d'utiliser des applications Windows Forms. Pour chaque section de la leçon, ouvrez Visual Studio .NET et expliquez comment effectuer les tâches que le stagiaire devra réaliser lui-même pendant l'exercice.

Montrez comment accéder aux commandes courantes comme Ouvrir, Enregistrer, Démarrer, Arrêter et Fin à partir de la barre de menus et des barres d'outils. Expliquez comment utiliser le menu Afficher pour ouvrir et fermer les différentes barres d'outils. Enfin, montrez comment déplacer, ancrer ou non les barres d'outils en général.

Le fonctionnement de la boîte à outils peut sembler déroutant et il est donc conseillé de présenter aux stagiaires la façon d'ouvrir, de fermer, de masquer et de réafficher la boîte à outils. Présentez la fonctionnalité de l'épingle et assurez-vous que les stagiaires ont bien compris que la boîte à outils ne s'affiche pas tant qu'une application nouvelle ou existante n'est pas ouverte.

Présentez les éléments que contient un formulaire : la barre de titre, la zone de contrôles et les boutons Agrandir, Réduire et Fermer. Placez un contrôle de la boîte à outils sur le formulaire pour montrer comment fonctionne la surface de dessin, mais n'expliquez pas l'utilisation des contrôles car ce point fait l'objet d'explications plus détaillées à la leçon et au module suivants.

Ouvrez l'éditeur de code pour un nouveau formulaire et montrez comment passer du mode Design à l'éditeur de code. Vous pouvez indiquer que le code généré automatiquement crée des fonctionnalités applicatives Windows standard, mais n'entrez pas dans le détail des espaces de noms et de classes. Ce sujet sera abordé ultérieurement. Les stagiaires risquent de s'y perdre s'il est traité à ce stade.

Recherchez et modifiez la propriété Text d'un nouveau formulaire. Expliquez que l'utilisation de la fenêtre Propriétés représente un moyen simple de définir les caractéristiques du formulaire et de l'interface utilisateur.

Montrez comment ouvrir et fermer les fenêtres Liste des tâches, Sortie, Affichage de classes, Commande et Explorateur d'objets. Exécutez une application de démonstration afin de montrer des exemples de données dans la fenêtre Liste des tâches et Sortie. Précisez que les fenêtres Affichage de classes et Commande feront l'objet d'une présentation plus détaillée plus tard dans ce cours.

Les stagiaires doivent savoir utiliser l'aide en ligne pour pouvoir suivre certains ateliers et effectuer certains exercices du cours. Pour que l'exercice d'apprentissage de l'aide en ligne soit interactif, demandez aux stagiaires de nommer les sujets relatifs à l'environnement .NET sur lesquels ils souhaiteraient obtenir plus d'informations et montrez-leur toutes les façons possibles de rechercher ces informations. L'utilisation de la fenêtre Aide dynamique de l'aide en ligne est particulièrement intéressante. Assurez-vous donc que les stagiaires ont bien compris son fonctionnement.

Menus et barres d'outils

La boîte à outils

Concepteur Windows Forms

Éditeur de code

Fenêtre Propriétés

Autres fenêtres de programmation

Système d'aide en ligne

Module 1 : Mise en route vii

Cet exercice est très simple mais les stagiaires y apprendront plusieurs fonctionnalités de Visual Studio .NET. Vous devez donc vous assurer qu'ils ne font pas juste suivre les étapes, mais qu'ils comprennent bien l'utilité de ce qu'ils sont en train de faire. Montrez comment effectuer certaines procédures si vous constatez, pendant que les stagiaires réalisent l'exercice, que certains d'entre eux ont besoin d'aide avant de passer à la leçon suivante. Cet exercice doit normalement durer 20 minutes environ.

Leçon : Création d'un projet Visual Basic .NET Cette section décrit les méthodes pédagogiques appliquées pour la présentation des sections de cette leçon. Cette leçon explique comment créer une application simple dans Visual Basic .NET. Son objectif est de présenter aux stagiaires le processus de programmation dans son ensemble. Il ne s'agit pas ici d'entrer dans le détail de la syntaxe du langage ou de son implémentation. Les stagiaires se familiariseront avec les concepts et les procédures abordés dans cette leçon en suivant l'atelier.

Cette section présente le processus de développement dans son ensemble. Ce processus s'articule autour de sept étapes distinctes. La plupart de ces étapes sont abordées plus en détail ultérieurement dans ce cours. Le processus est décrit d'une façon qui permet aux stagiaires de savoir où ils se situent dans le processus à mesure qu'ils progressent dans le cours. Chaque diapositive de présentation du module illustre par un graphique la partie du processus qui est traitée. La terminologie employée dans les diapositives et cette section est identique.

Mettez l'accent sur le fait que la façon dont l'application est conçue et l'identification des besoins de l'entreprise sont deux points critiques et déterminants dans le succès d'un projet. Ce sujet n'est pas traité dans ce cours et vous pouvez donc orienter les stagiaires vers d'autres cours et d'autres sources de documentation où ils pourront trouver plus d'informations.

Cette section présente brièvement aux stagiaires l'une des principales étapes du processus de développement : la création de l'interface utilisateur. N'entrez pas trop dans le détail à l'occasion de cette section car le module suivant contient des sections similaires qui traitent plus amplement la fonctionnalité de contrôle et expliquent plus en détail comment utiliser les contrôles. Montrez comment ajouter un contrôle dans un formulaire en double-cliquant dessus, puis utilisez les fonctionnalités standard de Windows pour déplacer et redimensionner le contrôle ajouté.

Dans cette section, utilisez le contrôle que vous avez ajouté à la section précédente et consultez rapidement ses propriétés. Dans le cadre de cette leçon, traitez uniquement la propriété Text de façon que les stagiaires restent concentrés sur le processus de développement des applications et que leur attention ne soit pas détournée vers les contrôles et les paramétrages des propriétés.

Cette section a pour principal objectif de mettre l'accent sur l'importance de l'écriture de code dans le processus global de développement d'une application. Montrez comment ouvrir l'éditeur de code et accéder à l'événement Click du contrôle que vous avez utilisé dans les deux sections précédentes. N'écrivez pas de code à ce stade, mais expliquez où le code du gestionnaire d'événements va se placer.

Application pratique : Utilisation de l'environnement de développement

Processus de développement

Création de l'interface utilisateur

Définition des propriétés des contrôles

Ajout de code pour les contrôles

viii Module 1 : Mise en route

Insistez sur le fait que l'enregistrement et le test font partie intégrante du processus de développement. Mentionnez les meilleures pratiques de programmation et parlez du rôle que joue la phase de test dans un processus de développement et de conception itératif. Expliquez encore la différence qu'il existe entre la version déboguée et la version de diffusion d'une application et insistez sur le fait que ces deux versions nécessitent la mise en place d'une phase de test.

Contrôle des acquis Les questions posées à ce stade portent essentiellement sur les concepts de base et les procédures présentées dans le module. Vous pouvez choisir la forme de la discussion pour répondre aux questions et ainsi faire bénéficier l'ensemble des stagiaires de vos réponses.

1. Si les stagiaires ne sont pas certains de devoir utiliser l'éditeur de code, expliquez-leur qu'ils doivent écrire du code pour les événements du contrôle qui ne font pas partie du contrôle par défaut.

2. Si les stagiaires ont des difficultés à comprendre, étudiez à nouveau la façon dont le code est traité dans l'environnement Visual Studio .NET. Visual Studio .NET compile le code compatible avec l'environnement .NET en tant que code MSIL (Microsoft Intermediate Language) et ainsi, lorsque le runtime exécute le code, le langage dans lequel il a été écrit importe peu.

3. Plusieurs réponses sont possibles pour cette question, mais celle que les stagiaires sont le plus susceptibles de fournir s'ils se basent sur le contenu du module est celle indiquée comme étant la réponse juste. Si certains stagiaires répondent que la première étape est la spécification d'un design, saisissez l'occasion qui vous est présentée et insistez sur l'importance de la phase de design, particulièrement lorsque les programmeurs sont des programmeurs avertis.

4. Cette question conduira vraisemblablement aux questions concernant la façon de déboguer des applications. Expliquez à ce stade qu'il existe de très bons outils de débogage et de très bons systèmes de gestion des erreurs, mais qu'ils seront présentés ultérieurement.

5. Deux réponses correctes sont possibles, mais la plupart des stagiaires choisiront de paramétrer les propriétés dans la fenêtre Propriétés et non dans l'éditeur de code. Si les stagiaires ne trouvent pas ce concept très clair, expliquez que la fenêtre Propriétés est un moyen simple de créer le code qui permet de définir les propriétés.

6. Utilisez cette question pour lancer la discussion sur les meilleures pratiques de programmation, y compris pour le design et le testing.

Enregistrement, génération et exécution de l'application

Module 1 : Mise en route ix

Atelier 1.1 : Création de votre première application Avant de commencer cet atelier, les stagiaires doivent avoir effectué tous les exercices et répondu à toutes les questions de la section Contrôle des acquis. Les stagiaires doivent pouvoir effectuer la plupart des tâches qu'ils ont apprises dans les leçons et les exercices. L'atelier est simple mais complet. Il conduit les stagiaires à travers tout le processus de création d'une application, tel que décrit dans la dernière leçon de ce module.

Démonstrations Vous pouvez montrer la présentation multimédia en exécutant le fichier multimédia fourni avec ce module ou bien effectuer la démonstration vous-même en suivant ces instructions.


Présentation multimédia : Vue d'ensemble de Visual Studio .NET Cette démonstration montre comment créer une application simple basée sur Visual Basic .NET en utilisant l'environnement Visual Basic .NET. Elle présente également de nombreuses fonctionnalités de l'environnement de développement qui sont utilisées couramment.

! Ouverture de Visual Studio .NET et utilisation de la page de démarrage 1. Démarrez Visual Studio .NET.

Expliquez que le volet Profil permet aux développeurs familiers des versions précédentes de Visual Basic ou de Microsoft Visual C++® de personnaliser l'environnement de développement pour que son fonctionnement ressemble le plus à celui des versions précédentes. Pour cette démonstration, ne modifiez pas les paramètres par défaut. Précisez que ce volet s'affiche au premier démarrage de Visual Studio .NET et qu'il est ensuite possible d'y accéder à partir de la page de démarrage.

2. Cliquez sur Communauté en ligne. Expliquez que ce volet permet d'accéder facilement aux newsgroups de l'environnement .NET.

3. Cliquez sur Recherche en ligne. Expliquez que ce volet permet d'accéder facilement à Microsoft MSDN® Online Library.

4. Cliquez sur Commencer.

Remarque

x Module 1 : Mise en route

! Création d'un projet 1. Dans l'onglet Projets, cliquez sur Nouveau projet. 2. Dans le volet Modèles de la boîte de dialogue qui s'affiche, cliquez sur

Application Windows. 3. Dans la zone Nom, tapez ApplicationToExplore 4. Pour définir l'emplacement, cliquez sur Parcourir et rendez-vous jusqu'au

dossier_installation\Democode\Mod01\Demo1, cliquez sur Ouvrir, puis sur OK.

Précisez qu'un modèle Application Windows Visual Basic .NET fournit un seul formulaire Windows. Ce formulaire porte le nom Form1.vb et s'ouvre en mode Design.

! Examen de l'Explorateur de solutions 1. Dans l'Explorateur de solutions, cliquez sur Form1.vb, si ce n'est déjà fait.

Indiquez que le fichier Form1.vb est fourni par le modèle Application Windows qui a été utilisé pour créer le projet.

2. Cliquez avec le bouton droit sur Solution �ApplicationToExplore� (1 projet). Précisez que ce menu contextuel permet non seulement d'ajouter d'autres projets à la solution mais aussi de générer et de déboguer la solution.

3. Cliquez avec le bouton droit sur ApplicationToExplore sous le n�ud Solution. Expliquez que le menu contextuel associé au projet contient des options qui permettent d'ajouter des références et d'autres fichiers au projet.

! Modification des propriétés du formulaire 1. Pour obtenir un formulaire rectangulaire, faites glisser la poignée de

redimensionnement vers le bas et la droite. 2. Dans la fenêtre Propriétés, cliquez sur BackgroundImage, puis sur le

bouton Sélection. 3. Dans la boîte de dialogue Ouvrir, recherchez dossier_installation\

Democode\Mod01\Demo1, sélectionnez le fichier Blue hills.jpg, puis cliquez sur Ouvrir.

! Ajout de boutons au formulaire 1. Cliquez sur le contrôle Button dans la boîte à outils et faites-le glisser sur le

formulaire. 2. Faites glisser un second bouton sur le formulaire.

Remarque

Module 1 : Mise en route xi

! Ajout de code à un bouton 1. Double-cliquez Button1 dans le formulaire.

Précisez que l'éditeur de code s'ouvre. L'onglet de la fenêtre contient le nom Form1.vb*.

2. Dans l'éditeur de code, entre Private Sub Button1_Click et End Sub (à l'emplacement où doit normalement se trouver le curseur), tapez le code suivant : MessageBox.Show("Prêt....Partez.... Écrivez le code !!!")

3. Ouvrez le formulaire Form1.vb en mode Design. 4. Double-cliquez sur Button2 dans le formulaire. 5. Dans l'éditeur de code, entre Private Sub Button2_Click et End Sub (à

l'emplacement où doit normalement se trouver le curseur), tapez le code suivant : MessageBox.Show("Web....Windows...." & _ "Visual Studio .NET se charge de tout !")

! Exécution et test de l'application

1. Dans la barre d'outils standard, cliquez sur le bouton Démarrer. 2. Dans la boîte de dialogue Form1, cliquez sur Button1. 3. Dans le message qui s'affiche, cliquez sur OK. 4. Dans la boîte de dialogue Form1, cliquez sur Button2. 5. Dans le message qui s'affiche, cliquez sur OK. 6. Fermez Form1.

! Utilisation de la fonction Masquer automatiquement • Dans la barre de titre de la fenêtre Sortie, cliquez sur l'icône qui représente

une épingle.

Montrez comment la fenêtre Sortie est masquée lorsque le curseur est déplacé en dehors de la fenêtre et comment elle s'affiche de nouveau lorsque le curseur est ramené au-dessus de l'onglet Sortie.

! Annulation de l'ancrage d'une fenêtre 1. Cliquez sur l'icône qui représente une épingle dans la barre de titre de la

boîte à outils. 2. Cliquez sur le titre de la boîte à outils et faites glisser la fenêtre au milieu de

l'écran.

Remarque

Remarque

xii Module 1 : Mise en route

! Ancrage d'une fenêtre 1. Cliquez sur la barre de titre de la boîte à outils et faites glisser la fenêtre vers

la gauche de la fenêtre de l'application Visual Studio .NET jusqu'à ce que le curseur atteigne le bord gauche de l'écran.

2. Cliquez sur l'icône qui représente une épingle dans la barre de titre de la boîte à outils pour activer la fonction Masquer automatiquement.

! Enregistrement d'un projet • Dans la barre d'outils standard, cliquez sur le bouton Enregistrer tout.

L'emplacement de la solution est défini au moment de la création de la solution.

! Fermeture d'une solution • Dans le menu Fichier, cliquez sur Fermer la solution.

L'onglet Projets de la page de démarrage affiche ApplicationToExplore dans la liste des derniers projets lorsque l'écran est actualisé ou au prochain démarrage de Visual Studio .NET.

! Fermeture de Visual Studio .NET • Dans le menu Fichier, cliquez sur Quitter.

Ces fichiers sont situés dans le dossier dossier_installation\Democode\Mod01\ DemoSolution.

Remarque

Remarque

Fichiers solution

Module 1 : Mise en route 1

Vue d'ensemble

! Concepts de base de l'environnement .NET

! Exploration de l�environnement de développement

! Création d'un projetVisual Basic .NET

Use Visual Studio .NET

Accèsaux données

Débogageet déploiement

Écriture decode

Créationd'une

interface

Utilisation deVisual

Studio .NET


Ce module présente Microsoft® Visual Basic® .NET et explique de quelle façon il s'intègre à la plate-forme Microsoft .NET. Il explique comment utiliser les outils de programmation dans Microsoft Visual Studio® .NET et propose des exercices pour créer une application dans Visual Basic .NET.

À la fin de ce module, vous serez à même d'effectuer les tâches suivantes :

! démarrer un projet Visual Basic .NET basé sur le modèle d'application Microsoft Windows® ;

! utiliser la barre d'outils standard, les outils de programmation et les fenêtres de programmation dans l'environnement de développement afin d'utiliser les applications ;

! créer une application Visual Basic .NET simple.

Introduction

Objectifs

2 Module 1 : Mise en route

Présentation multimédia : Vue d'ensemble de Visual Studio .NET


Cette présentation multimédia vous guide à travers Visual Studio .NET. Elle montre comment créer une application simple basée sur Visual Basic .NET en utilisant l'environnement Visual Basic .NET. Elle présente de nombreuses fonctionnalités de l'environnement de développement qui sont utilisées couramment.

Introduction


Leçon : Concepts de base de l'environnement .NET

Plate-forme.NET ?

Visual Studio .NET ?

Visual Basic.NET ?.NET

Framework ?

AIDE !

.NET


Visual Basic .NET est la nouvelle version du système de développement Visual Basic. Avant de commencer à créer des applications dans Visual Basic .NET, penchez-vous sur quelques concepts de base propres à l'environnement .NET.

Cette leçon s'articule autour des sections et des activités suivantes :

! Présentation de la plate-forme .NET ! Fonctionnement de Microsoft .NET Framework ! Présentation de Microsoft Visual Studio® .NET ! Utilisation de la page de démarrage ! Présentation d'un modèle d'application ! Utilisation de l'Explorateur de solutions ! Application pratique : Utilisation d'un projet Visual Basic .NET

Cette leçon offre une vue d'ensemble de la plate-forme .NET et présente les avantages que les développeurs peuvent tirer de son utilisation. Elle explique comment utiliser les outils de programmation dans l'environnement de développement Visual Studio .NET pour créer des applications dans Visual Basic .NET.

À la fin de cette leçon, vous serez à même d'effectuer les tâches suivantes :

! décrire les principaux éléments de la plate-forme .NET ; ! expliquer les avantages de Microsoft .NET Framework pour les

développeurs ; ! décrire le rôle de Visual Studio .NET dans la plate-forme .NET ;

Introduction

Contenu de la leçon

Objectifs de la leçon


! utiliser la page de démarrage de Visual Studio pour accéder aux informations de développement les plus récentes et définir les préférences des utilisateurs ;

! démarrer un projet Visual Basic .NET basé sur le modèle d'application Windows ;

! utiliser l'Explorateur de solutions pour étudier les fichiers solution et le code.


Présentation de la plate-forme .NET

Outils pour les développeurs

Services Web XML

Serveurs

Clients

Expériencesutilisateur


La plate-forme .NET est la base sur laquelle sera développée la prochaine génération de logiciels permettant de relier des systèmes, des données, des périphériques et des utilisateurs au moyen d'une méthode unifiée et personnalisée. Elle contient des services Web XML qui autorisent l'interaction entre différentes technologies. Elle offre aux développeurs de logiciels les outils et la technologie qui permettent de créer rapidement et efficacement des solutions d'entreprise qui s'articulent autour de plusieurs applications et de plusieurs dispositifs clients et qui sont implémentées dans plusieurs organisations. Elle permet aux utilisateurs de déterminer la nature des informations qui leurs sont transmises ainsi que le mode et le moment de la transmission.

Le scénario qui suit illustre la façon dont la plate-forme .NET aide les entreprises à intégrer des solutions et à partager des données pour améliorer les conditions d'utilisation des solutions.

Une compagnie aérienne présente à l'une des plus grandes sociétés du secteur de la location de voitures, une proposition visant à lier son système de réservation sur Internet à celui de cette société. Le défi pour la société de location de véhicules consiste à trouver le moyen de transférer facilement les demandes de réservation et les données qui y sont liées entre ses systèmes basés sur les technologies Windows et les systèmes UNIX de la compagnie aérienne.

La société de location de véhicules choisit de créer une solution basée sur les technologies .NET et les services Web XML. Ce choix permet à l'entreprise de créer rapidement un système de transfert entre le système UNIX de la compagnie aérienne et son propre système VMS. La solution est développée par deux personnes en seulement deux mois, soit deux à trois fois plus vite que prévu par l'entreprise.

Introduction

Étude de cas


Il aurait été certainement envisageable de recourir à des méthodes plus traditionnelles pour créer une solution spécifique à la compagnie aérienne. Cependant, en choisissant de créer un système au moyen des services Web XML, la société de location de voitures s'est donné la possibilité d'étendre son service à d'autres compagnies aériennes et à d'autres partenaires. Si d'autres partenaires ou d'autres entreprises clientes souhaitent se connecter directement aux systèmes de réservation de l'entreprise, tout ce qui lui reste à faire, c'est de leur fournir le schéma XML.

La plate-forme .NET contient un ensemble complet de produits créés par souci de conformité aux standards XML et Internet. Ces produits fournissent les composants suivants pour utiliser des solutions XML :

! Outils pour développer des solutions ! Serveurs pour gérer, générer et déployer des solutions ! Services pour intégrer, connecter et réutiliser des solutions ! Clients matériels et logiciels pour autoriser la meilleure utilisation possible

Le tableau suivant présente les définitions des principaux éléments de la plate-forme .NET et cite des exemples.

Élément Définition Exemples

Outils pour les développeurs

Interfaces et outils de programmation pour le design, la création, l'exécution et le déploiement des solutions basées sur la plate-forme .NET.

.NET Framework

Visual Studio .NET

Serveurs Infrastructure pour la génération, le déploiement et le fonctionnement des solutions basées sur la plate-forme .NET.

Microsoft Windows 2000 Server

Microsoft .NET Enterprise Servers

Services Web XML

Ensemble de services prédéfinis qui effectuent des tâches courantes et qui permettent aux développeurs de développer leurs propres services.

Microsoft .NET My Services

Clients Périphériques qui fonctionnent sur les systèmes d'exploitation qui intègrent tous les autres éléments .NET et qui interagissent avec eux.

Microsoft Windows CE pour périphérique portable

Microsoft Windows XP pour ordinateur

Expériences utilisateur

Logiciel client classique intégré aux services Web XML qui présente aux utilisateurs tous les éléments dont ils ont besoin et d'une façon logique pour eux.

Versions futures de Microsoft bCentral�

Microsoft MSN®

Famille de produits .NET

Éléments principaux


Fonctionnement de Microsoft .NET Framework

Applications Visual Basic

Applications Visual C#

Applications Visual C++

Code de la plate-forme.NET

.NET FrameworkBibliothèque de classes

Windows

ServicesWeb XM

L

ADO.NET

Typesde données

Common Language RuntimeCompilation du code source en MSILCompilation du code source en MSIL

Services de programmationServices de programmation

Le compilateur JIT génèredu langage machine

Le compilateur JIT génèredu langage machine


.NET Framework est un ensemble de services de programmation conçu pour simplifier le développement d'applications dans l'environnement particulièrement distribué qu'est Internet. Le .NET Framework comprend deux composants principaux qui sont les suivants : le CLR (Common language runtime) et la bibliothèque de classes.

Lorsque vous créez une application basée sur Windows dans Visual Basic .NET, vous disposez d'un code de démarrage qui inclut l'espace de noms System.Windows.Forms et la classe Form. Avec cette classe, vous pouvez créer facilement des fenêtres, des boutons, des menus, des barres d'outils et d'autres éléments d'écran. Lorsque vous compilez l'application, elle est convertie en Common Language Runtime ou code MSIL (Microsoft Intermediate Language). Une fois l'application compilée, le runtime gère l'exécution de l'application.

Le runtime inclut une fonction de compilation juste-à-temps qui traduit le code MSIL dans le langage machine du système sur lequel l'application est destinée à fonctionner. Lorsqu'un périphérique client sur la plate-forme .NET lance l'application Visual Basic .NET, il s'exécute dans le langage machine du système client et peut s'intégrer complètement aux autres applications .NET et interagir avec elles ainsi qu'avec des services, quel que soit le langage dans lequel il a été développé.

Introduction

Interactions entre les applications et .NET Framework


Pour bien comprendre comment l'environnement .NET Framework fonctionne vous devez maîtriser la terminologie suivante :

! Classe Une classe est une entité de programmation nommée qui comprend un ensemble commun de méthodes, de propriétés et d'attributs. Par exemple, Form est l'une des classes de l'espace de noms System.Windows.Forms qui est utilisée pour créer des applications Windows Forms.

! Espace de noms Un espace de noms identifie une collection de classes et/ou d'autres espaces de noms apparentés dans .NET Framework. Voici quelques exemples :

• System

• System.Windows.Forms ! Bibliothèque de classes

Une bibliothèque de classes est une collection complète orientée objet de classes réutilisables organisées en fonction de leurs fonctionnalités dans des espaces de noms hiérarchiques. Elles sont utilisées pour développer des applications qui vont de l'application cliente classique à l'application basée sur les toutes dernières innovations offertes par Microsoft ASP.NET et les services Web XML.

! Common Language Runtime Le common language runtime est la base de .NET Framework. Dans l'environnement .NET, les programmeurs développent des applications dans le langage de leur choix compatible toutefois avec l'environnement .NET. Le code est compilé pour obtenir un code MSIL que le runtime gère et exécute.

En plus des langages Microsoft comme Visual Basic, Microsoft Visual C#�, Microsoft Visual C++® et Microsoft JScript®, d'autres langages y compris Perl, Smalltalk et Eiffel sont en cours de modification pour être rendus compatibles avec la plate-forme .NET.

Termes et définitions

Remarque


Présentation de Microsoft Visual Studio .NET

Visual Studio .NET

Design Développement DéploiementDébogage

Outils pour WebForms

Outils pour WebForms

Outils pour WindowsForms

Outils pour WindowsForms

Gestion deserreurs

Gestion deserreurs

Prise en chargede plusieurslangages de

programmation

Prise en chargede plusieurslangages de

programmation

Outils pour lesservices Web XML

Outils pour lesservices Web XML Accès aux donnéesAccès aux données


Visual Studio .NET est un environnement de développement qui permet le design, le développement, le débogage et le déploiement rapide des solutions basées sur .NET Framework. Il est possible d'accéder à tout un ensemble communs d'outils, de concepteurs et d'éditeurs à partir de n'importe quel langage de programmation Visual Studio .NET. Vous pouvez créer des applications Windows Forms et Web Forms qui intègrent des données et une logique applicative.

Visual Studio .NET inclut les fonctionnalités du Common Language Runtime. Ces fonctionnalités sont décrites dans le tableau ci-dessous.

Fonctionnalité Description


Zone de dessin graphique qui permet de créer rapidement l'interface utilisateur d'une application. Il est possible de faire glisser ou de dessiner des contrôles sur cette surface.

Outils pour Windows Forms

Un concepteur Windows Forms, un modèle d'application Windows, des références de projet et un code de démarrage sont fournis pour permettre la création d'applications Windows Forms standard.

Outils pour Web Forms Un concepteur Web Forms, un modèle d'application Web ASP.NET, des références de projet et un code de démarrage sont fournis pour permettre la création d'applications Web Forms dans lesquelles l'interface utilisateur principale est un navigateur.

Outils pour les services Web XML

Un modèle de service Web ASP.NET est fourni. Ce modèle permet de construire la structure d'un projet d'application Web sur un serveur de développement Web et de créer un fichier solution Visual Studio .NET sur un ordinateur local.

Prise en charge de plusieurs langages de programmation

Tous les langages de programmation de la plate-forme .NET, y compris Visual Basic .NET et Visual C#, sont intégrés à l'environnement de développement.

Accès aux données Des composants pour la création d'applications qui doivent partager des données, des outils de base de données visuels pour l'accès aux données et un ensemble complet de classes Microsoft ADO.NET facilitent l'utilisation de tous les types de données.

Introduction

Définitions


(suite) Fonctionnalité Description

Gestion des erreurs Outils de débogage avec prise en charge de plusieurs langages qui aident à rechercher et à déboguer les erreurs trouvées dans le code. Vous pouvez utiliser des classes d'exceptions structurées pour créer et intégrer à votre application une fonction de gestion des erreurs.

Assistants Les Assistants aident à effectuer rapidement des tâches courantes et parfois complexes. Dans les Assistants, chaque page vous aide à définir des options, à configurer des paramètres et à personnaliser les projets.


Utilisation de la page de démarrage

CommencerNouveautésCommunauté en ligneActualitésRecherche en ligneTéléchargementsServices Web XMLHébergement WebMon profil


La page de démarrage de Visual Studio .NET permet d'ouvrir des projets, de créer votre propre profil et de définir vos préférences. Vous pouvez également l'utiliser pour lire les derniers échanges entre les développeurs Microsoft, rejoindre les communautés en ligne .NET, faire des recherches dans Microsoft MSDN® Library et télécharger des mises à jour de logiciels.

La page de démarrage permet de démarrer un nouveau projet ou d'en ouvrir un existant.

! Pour ouvrir un nouveau projet • Cliquez sur Commencer dans la liste située dans la partie gauche de la page

(si ce n'est déjà fait), puis cliquez sur Nouveau projet.

! Pour ouvrir un projet existant • Sélectionnez Commencer dans la liste située dans la partie gauche de la

page, puis cliquez sur Ouvrir un projet.

Vous pouvez sélectionner un profil préexistant (Développeur Visual Basic, par exemple) ou modifier manuellement chaque élément d'un profil.

! Pour définir les préférences de la page de démarrage 1. Dans la page de démarrage, sélectionnez Profil dans la liste située dans la

partie gauche de la page. 2. Dans la première liste déroulante sous Profil, sélectionnez Développeur

Visual Basic (si ce n'est déjà fait).

Les raccourcis utilisés dans ce cours sont basés sur le profil par défaut. Si vous sélectionnez le profil Développeur Visual Basic comme indiqué à l'étape 2, il se peut que vous deviez le réinitialiser ultérieurement pour que les raccourcis fonctionnent.

Introduction

Ouverture de projets

Paramétrage des préférences Visual Studio .NET

Remarque


3. Sous Afficher l'aide, choisissez d'afficher l'aide dans une fenêtre du navigateur Web à l'intérieur de l'environnement de développement ou dans une fenêtre externe.

4. Dans la liste Au démarrage, choisissez les éléments à afficher au démarrage de Visual Studio .NET.

Vous pouvez choisir d'afficher la page de démarrage à tout moment lorsque vous travaillez dans l'environnement de développement.

! Pour afficher la page de démarrage • Dans le menu ? (Aide), cliquez sur Afficher la page de démarrage.

Affichage de la page de démarrage


Présentation d'un modèle d'application

Fournit les fichiers de démarrage, la structure de projet et les

paramètres d'environnement

Fournit les fichiers de démarrage, la structure de projet et les

paramètres d'environnement


Visual Studio .NET fournit plusieurs modèles d'applications pour permettre le développement de différentes sortes d'applications et de composants. Avant de commencer un nouveau projet, choisissez le type de modèle à utiliser.

Un modèle d'application contient des fichiers de démarrage et une structure de projet. Il contient les objets de projet de base et les paramètres d'environnement dont vous aurez besoin pour créer le type d'application souhaité.

Deux des modèles les plus couramment utilisés sont les modèles Application Windows et Application Web ASP.NET.

! Modèle Application Windows Ce modèle contient les outils, la structure et le code de démarrage pour une application standard basée sur Windows. Il permet d'ajouter automatiquement les principales références et fichiers de projet à utiliser comme point de départ à la création d'une application.

! Modèle Application Web ASP.NET Ce modèle permet de créer une application Web ASP.NET sur un ordinateur équipé de la version 5.0 ou ultérieure de Internet Information Services (IIS). Afin de vous aider à commencer la conception de votre application, le modèle crée les fichiers de base nécessaires sur le serveur.

Introduction

Définition

Exemples de modèles d'applications


Lorsque vous démarrez un projet Visual Basic .NET, l'une des premières étapes consiste à choisir un modèle d'application. Dans ce module, vous n'aurez à utiliser que le modèle Application Windows pour effectuer les exercices et suivre les ateliers.

! Pour créer un projet d'application Windows dans Visual Basic .NET 1. Démarrez Visual Studio .NET. 2. Dans le volet Commencer, cliquez sur Nouveau projet.

- ou - Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.

3. Dans le volet Types de projets, cliquez sur Projets Visual Basic. Dans le volet Modèles, cliquez sur Application Windows.

4. Dans la zone Nom, tapez un nom de projet unique qui évoque l'utilisation de l'application.

5. Dans la zone Emplacement, tapez le répertoire dans lequel enregistrer le projet ou cliquez sur le bouton Parcourir pour atteindre le répertoire voulu.

6. Cliquez sur OK. Le Concepteur Windows Forms s'ouvre et affiche le formulaire Form1 pour le projet créé.

Choix d'un modèle


Utilisation de l'Explorateur de solutions


L'Explorateur de solutions permet de visualiser des fichiers et d'effectuer des tâches de gestion de fichiers à partir d'une solution ou d'un projet. Une solution .NET basée sur Visual Basic apparaît accompagnée de ses projets dans une liste hiérarchique qui contient des informations à jour sur l'état de la solution, des projets et des fichiers.

Une solution est un conteneur de projets et d'éléments de solutions qu'il est possible de compiler pour générer une application. Une solution contient habituellement un ou plusieurs projets apparentés.

Un projet est un conteneur au sein d'une solution. Il est utilisé pour gérer, créer et déboguer de façon logique les éléments de projet qui constituent une application.

Visual Studio .NET prend en charge de nombreux types de fichiers et extensions associées. Le tableau qui suit décrit les types de fichiers les plus courants, spécifiques aux solutions basées sur Visual Basic .NET.

Extension Nom Description

.sln Visual Studio solution

Organise les projets, les éléments de projets et les éléments de solutions dans la solutionen fournissant à l'environnement les références à leurs emplacements sur le disque.

.suo Solution user options

Contient toutes les options à éventuellement associer à votre solution pour qu'à chaque fois que vous ouvrez la solution elle contienne les paramétrages que vous avez choisis.

.vb Projet Visual Basic

Représente les formulaires, les contrôles utilisateur, les classes et les fichiers de module qui appartiennent à une solution d'un seul projet. Les fichiers qui ne sont pas basés sur un langage de programmation ont une extension qui leur est propre. Par exemple, un fichier Crystal Report a l'extension .rpt et un fichier texte, l'extension .txt.

Introduction

Termes et définitions

Fichiers de projet et solution


(suite) Extension Nom Description

.vbproj Projets Visual Basic

Représente les formulaires, les contrôles utilisateur, les classes et les fichiers de module qui appartiennent à une solution de plusieurs projets. Cette extension permet de différencier les fichiers écrits en Visual Basic .NET des fichiers écrits dans les autres langages compatibles avec l'environnement .NET. (Les fichiers écrits en Visual C# ont l'extension .csproj.)

.aspx

.asmx

.asax

Éléments de projet Web

Les éléments de projet Web incluent des fichiers spécifiques à l'environnement Web, tels que des fichiers .aspx pour les formulaires Web, .asmx pour les services Web XML et .asax pour les classes d'applications globales. Les projets Web utilisent également l'extension de fichier .vb pour les classes et les modules.

! Pour ouvrir l'Explorateur de solutions • Dans le menu Affichage, cliquez sur Explorateur de solutions.

La fenêtre qui le contient s'affiche dans le coin supérieur droit de la zone de développement. Vous pouvez la déplacer et la redimensionner en utilisant la fonctionnalité glisser-déplacer standard.

Par défaut, l'Explorateur de solutions affiche uniquement certains des fichiers stockés dans le projet. Vous pouvez modifier l'affichage de façon à voir tous les fichiers de la solution.

! Pour afficher tous les fichiers dans l'Explorateur de solutions

• Dans la barre d'outils Explorateur de solutions, cliquez sur Afficher tous

les fichiers. Cette option permet de visualiser les fichiers qui ont été créés manuellement ou au cours de la compilation.

Il est possible de supprimer de façon définitive les projets qui ne sont plus utiles.

! Pour supprimer des projets définitivement • Dans l'Explorateur Windows, cliquez avec le bouton droit sur le dossier qui

contient la solution à supprimer et choisissez Supprimer.

Ouverture de l'Explorateur de solutions

Affichage de tous les fichiers

Suppression de projets


Application pratique : Utilisation d'un projet Visual Basic .NET

Démarrez un projet Visual Basic .NET à partir d�un modèle d'application Windows

Exécutez le projet dans l'environnement de développement

Visualisez les fichiers dans l�Explorateur de solutions

Générez un fichier exécutable

Enregistrez le projet et quittezVisual Studio .NET

Exécutez l�application en dehors de l�environnement de développement


Dans cet exercice, vous allez démarrer un nouveau projet Visual Basic .NET et l'utiliser dans l'environnement de développement.

! Démarrage d'un projet Visual Basic .NET 1. Démarrez Visual Studio .NET. 2. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 3. Dans le volet Types de projets, cliquez sur Projets Visual Basic. Dans le

volet Modèles, cliquez sur Application Windows. 4. Dans la zone Nom, tapez NouvProjWindows 5. Cliquez sur Parcourir, recherchez le dossier dossier_installation\Practices\

Mod01, puis cliquez sur Ouvrir. Cliquez sur OK.

! Exécution du projet dans l'environnement de développement

1. Cliquez sur le bouton Démarrer dans la barre d'outils standard. Vous pouvez également appuyer sur F5. Comme vous n'avez apporté aucune modification au code de démarrage du projet, un formulaire vierge apparaît lorsque le projet est exécuté.

2. Fermez le formulaire vierge et retournez dans l'environnement de programmation.

Introduction

Démarrage du projet

Exécution du projet dans l'environnement IDE


! Génération d'un fichier exécutable pour le projet • Dans le menu Générer, cliquez sur Générer NouvProjWindows.

Lorsque vous générez un projet ou une solution, un fichier exécutable (.exe) est créé automatiquement dans le dossier du projet, dans un sous-dossier appelé bin.

! Exécution de l'application en dehors de l'environnement de développement

• Dans le menu Démarrer, cliquez sur Exécuter et recherchez le fichier .exe. Ce fichier se trouve dans le dossier dossier_installation\Practices\Mod01\ NouvProjWindows\bin. En exécutant l'application en dehors de l'environnement de développement Visual Studio .NET, vous pouvez tester l'utilisation de l'application.

! Visualisation des fichiers dans l'Explorateur de solutions 1. Si l'Explorateur de solutions n'est pas déjà ouvert, dans le menu Affichage,

cliquez sur Explorateur de solutions. 2. Développez les n�uds de fichiers pour visualiser les fichiers.

Notez la présence des fichiers AssemblyInfo.vb et Form1.vb. Ces fichiers font partie de tous les projets Windows Forms.

! Fermeture du projet et fermeture de Visual Studio .NET 1. Dans le menu Fichier, cliquez sur Quitter. 2. Lorsque vous êtes invité à enregistrer les modifications, cliquez sur Oui.

Génération du projet

Exécution de l'application

Affichage des fichiers

Enregistrement et fermeture du projet


Leçon : Exploration de l'environnement de développement

Menu principalMenu principal

Barre d�outilsBarre d�outils

Boîte à outilsBoîte à outilsConcepteur Windows FormsConcepteur Windows Forms

FenêtrePropriétésFenêtrePropriétés


Cette leçon présente les fonctionnalités principales de l'environnement de développement qui permettent de créer et de modifier des applications comme le Concepteur Windows Forms et les contrôles de la boîte à outils.


! Menus et barres d'outils ! La boîte à outils ! Concepteur Windows Forms ! Éditeur de code ! Fenêtre Propriétés ! Autres fenêtres de programmation ! Système d'aide en ligne ! Application pratique : Utilisation de l'environnement de développement


! utiliser le menu principal et la barre d'outils standard pour ouvrir, générer (en mode débogage et diffusion), exécuter, enregistrer et fermer une application existante basée sur Visual Basic .NET ;

! visualiser les formulaires d'interface utilisateur dans le Concepteur Windows Forms ou l'éditeur de code ;

! utiliser la boîte à outils pour ajouter un bouton et un intitulé à un formulaire ;

! utiliser la fenêtre Propriétés pour afficher et définir des propriétés ; ! ouvrir, fermer et rouvrir des outils et des fenêtres de programmation ; ! utiliser le système d'aide en ligne pour obtenir plus d'informations.

Introduction




Menus et barres d'outils

Menu principalMenu principal

Barre d�outils standardBarre d�outils standard

Nouveau projetNouveau projet

Enregistrer Form1.vbEnregistrer Form1.vb

AnnulerAnnuler


Lorsque vous démarrez un projet Visual Basic .NET et que vous sélectionnez un modèle d'application, l'environnement de développement apparaît. Le menu principal et la barre d'outils standard permettent d'accéder à la plupart des commandes qui pilotent l'environnement de programmation Visual Studio .NET.

Les commandes du menu principal fonctionnent de la même façon que dans toutes les applications basées sur Windows et vous pouvez y accéder au moyen du clavier ou de la souris.

La barre d'outils standard contient des boutons qui sont des raccourcis des commandes courantes, par exemple des commandes Ouvrir, Enregistrer, Démarrer, Ajouter un nouvel élément, Naviguer vers l'arrière et Naviguer vers l'avant. Elle contient également des boutons qui permettent d'ouvrir l'Explorateur de solutions, la fenêtre Propriétés, la boîte à outils et d'autres éléments de l'environnement de développement.

La barre d'outils de débogage contient les raccourcis des fonctions de débogage comme la fonction d'exécution en pas à pas dans le code et de définition de points d'arrêt.

Les barres d'outils peuvent être ancrées (attachées) ou non (flottantes). Par défaut, la plupart des barres d'outils sont ancrées, mais il est possible d'annuler leur ancrage ou de les ancrer à nouveau à tout moment.

! Pour annuler l'ancrage d'une barre d'outils • Cliquez dans une zone de la barre d'outils qui ne contient pas de boutons et

faites glisser la barre vers un autre emplacement.

! Pour ancrer une barre d'outils • Faites glisser la barre d'outils vers l'un des bords de la fenêtre principale.

Introduction

Menu principal

Barre d'outils standard

Barre d'outils de débogage

Fonctions d'ancrage


La boîte à outils

Contrôles permettantde créer l'interface

utilisateur

Contrôles permettantde créer l'interface

utilisateur


Les objets de l'interface utilisateur créés pour votre application le sont par l'ajout dans un formulaire de contrôles qui se trouvent dans la boîte à outils. La boîte à outils est à l'origine située dans la partie gauche de l'environnement de développement. Plusieurs onglets contiennent différentes catégories de contrôles telles que les catégories Windows Forms et Données.

La boîte à outils contient plusieurs contrôles que vous pouvez utiliser pour ajouter des images, des étiquettes, des boutons, des zones de liste, des barres de défilement, des menus et des formes géométriques dans l'interface utilisateur. Chaque contrôle ajouté à un formulaire devient un objet d'interface utilisateur programmable dans votre application. Ces objets sont visibles aux utilisateurs lorsque l'application est exécutée et ils fonctionnent comme des objets standard d'applications Windows.

! Pour fermer et ouvrir la boîte à outils 1. Pour fermer la boîte à outils, cliquez sur le bouton Fermer (x) dans l'angle

supérieur droit de la boîte à outils. 2. Pour ouvrir la boîte à outils, dans le menu Affichage, cliquez sur Boîte à

outils. 3. Pour que la boîte à outils reste ouverte, cliquez sur l'épingle dans la barre

de titre de la boîte à outils.

! Pour masquer et réafficher la boîte à outils 1. Pour masquer la boîte à outils, cliquez sur l'épingle dans la barre de titre

de la boîte à outils. 2. Pour réafficher la boîte à outils qui a été masquée, dans le menu Affichage,

cliquez sur Boîte à outils.

Introduction

Fonctionnement de la boîte à outils

Fermeture et ouverture de la boîte à outils

Masquage et réouverture de la boîte à outils


! Pour déplacer la boîte à outils 1. Cliquez avec le bouton droit sur la barre de titre de la boîte à outils, puis

cliquez sur Flottante. 2. Faites glisser la boîte à outils vers l'emplacement de votre choix.

Déplacement de la boîte à outils




Lorsque vous démarrez un projet dans Visual Basic .NET, le Concepteur Windows Forms s'ouvre en mode Design et contient le formulaire Form1 pour le projet. Vous devez placer des contrôles depuis la boîte à outils sur le formulaire pour créer l'interface utilisateur d'une fenêtre utilisée dans votre application.

Le formulaire par défaut contient le nombre minimal d'éléments utilisés par la plupart des formulaires : une barre de titre, une zone de contrôles et les boutons Agrandir, Réduire et Fermer.

! Pour afficher un formulaire en mode Design • Dans l'Explorateur de solutions, double-cliquez sur le formulaire.

- ou - Dans l'Explorateur de solutions, sélectionnez le formulaire et cliquez sur le bouton Concepteur de vues dans la barre d'outils.

Introduction

Éléments d'un formulaire

Affichage d'un formulaire


Éditeur de code

Liste Nom de la classeListe Nom de la classe Liste Nom de la méthodeListe Nom de la méthode


Visual Studio .NET fournit un éditeur de code dans lequel vous pouvez écrire et gérer du code pour votre projet. Vous pouvez associer du code directement à un formulaire dans votre projet ou le placer dans un module de code séparé. Un éditeur de code distinct s'affiche pour chaque formulaire ou module du projet, ce qui facilite l'organisation, l'affichage et le déplacement dans le code.

L'éditeur de code contient deux listes déroulantes situées en haut de la fenêtre : la liste Nom de la classe sur la gauche et la liste Nom de la méthode sur la droite. La liste Nom de la classe contient tous les contrôles du formulaire correspondant. Si vous sélectionnez un nom de contrôle dans cette liste, la liste Nom de la méthode affiche tous les événements qui existent pour ce contrôle. (Les événements sont les actions que le contrôle effectue et qui sont interprétées par l'application.) En utilisant parallèlement les listes Nom de la classe et Nom de la méthode, vous pouvez localiser et éditer rapidement du code dans votre application.

! Pour ouvrir l'éditeur de code pour un formulaire 1. Dans l'Explorateur de solutions, cliquez sur le formulaire dont vous voulez

visualiser le code. 2. Dans la barre d'outils Explorateur de solutions, cliquez sur le bouton

Afficher le code . - ou - Dans le menu Affichage, cliquez sur Code.

Introduction

Fonctionnement de l'éditeur de code

Ouverture de l'éditeur de code


Fenêtre Propriétés

Définit les propriétéscomme la taille,

la légende ou la couleur

Définit les propriétéscomme la taille,

la légende ou la couleur


La fenêtre Propriétés contient les paramètres du formulaire ou du contrôle sélectionné. Vous pouvez les modifier pendant la création ou la modification d'une application. Une propriété décrit une caractéristique d'un objet comme la taille, la légende ou la couleur.

! Pour ouvrir la fenêtre Propriétés • Si la fenêtre Propriétés n'est pas visible, cliquez sur Fenêtre Propriétés

dans le menu Affichage ou appuyez sur F4.

Certains contrôles, documents et formulaires affichent un grand nombre de propriétés dans la fenêtre Propriétés. Il peut donc être difficile de retrouver facilement la propriété que vous souhaitez définir. La fenêtre Propriétés permet d'afficher les propriétés d'un formulaire ou d'un contrôle dans une vue dans laquelle elles sont classées par catégorie et non par ordre alphabétique.

! Pour afficher les propriétés 1. Pour afficher les propriétés par catégorie, cliquez sur le bouton

Par catégorie dans la fenêtre Propriétés. Les propriétés du formulaire ou du contrôle sélectionné sont classées en fonction des catégories définies par le contrôle.

2. Pour afficher les propriétés dans une catégorie, développez le n�ud de la catégorie. Pour masquer les propriétés dans une catégorie, réduisez le n�ud de la catégorie.

3. Pour afficher les propriétés par ordre alphabétique, cliquez sur le bouton

Alphabétique dans la fenêtre Propriétés.

Introduction

Ouverture de la fenêtre Propriétés

Affichage des propriétés


Autres fenêtres de programmation

Fenêtre deprogrammation

FenêtreFenêtre dedeprogrammationprogrammation ObjectifObjectifObjectif

Liste des tâchesListe des tâches Permet d'organiser et de gérer les tâches liées à lacréation d'une applicationPermet d'organiser et de gérer les tâches liées à lacréation d'une application

SortieSortie Affiche des messages d'état pour diversesfonctionnalités de l'environnement de développementAffiche des messages d'état pour diversesfonctionnalités de l'environnement de développement

Affichage de classesAffichage de classesPermet d'analyser du code et de retrouver lessymboles qui représentent des éléments deprogrammation dans votre solution

Permet d'analyser du code et de retrouver lessymboles qui représentent des éléments deprogrammation dans votre solution

CommandeCommandePermet d'exécuter des commandes ou de débogueret de tester des expressions dans l'environnement dedéveloppement

Permet d'exécuter des commandes ou de débogueret de tester des expressions dans l'environnement dedéveloppement

Explorateur d'objetsExplorateur d'objets Permet d'afficher des objets et leurs membresPermet d'afficher des objets et leurs membres


Il existe plusieurs autres fenêtres de programmation dans l'environnement de développement qui peuvent vous être utiles.

Cette fenêtre permet d'organiser et de gérer les tâches liées à la création d'une application.

! Pour afficher la fenêtre Liste des tâches • Dans le menu Affichage, pointez sur Autres fenêtres, puis cliquez sur Liste

des tâches.

Cette fenêtre affiche des messages d'état pour diverses fonctionnalités de l'environnement de développement.

! Pour accéder à la fenêtre Sortie • Dans le menu Affichage, pointez sur Autres fenêtres, puis cliquez sur

Sortie.

Cette fenêtre permet d'analyser du code et de retrouver les symboles qui représentent des éléments de programmation dans votre solution. Les symboles qui sont classés par projet, apparaissent dans une arborescence hiérarchique qui indique les relations qui les lient en termes de relation contenant-contenu.

! Pour ouvrir la fenêtre Affichage de classes • Dans le menu Affichage, cliquez sur Affichage de classes.

Introduction

Fenêtre Liste des tâches

Fenêtre Sortie

Fenêtre Affichage de classes


Cette fenêtre permet d'exécuter des commandes ou de déboguer et de tester des expressions dans l'environnement de développement.

! Pour ouvrir la fenêtre Commande • Dans le menu Affichage, pointez sur Autres fenêtres, puis cliquez sur

Commande.

Cette fenêtre permet de rechercher et d'étudier des objets, comme les espaces de noms et les classes, qui font partie de votre solution.

! Pour ouvrir la fenêtre Explorateur d'objets • Dans le menu Affichage, pointez sur Autres fenêtres, puis cliquez sur

Explorateur d'objets.

Fenêtre Commande

Fenêtre Explorateur d'objets


Système d'aide en ligne

Menu ? (Aide)Menu ? (Aide) Aide dynamiqueAide dynamique


Dans Visual Studio .NET le système d'aide est bien intégré à l'environnement de développement. Il fournit les informations nécessaires sur les tâches en cours. Pour que l'environnement de développement soit utilisé de façon efficace, le système d'aide a été conçu de façon à apporter de l'aide dans le cadre de situations générales et de l'aide dans le cadre de situations plus spécifiques.

Il existe deux façons principales d'accéder à l'aide dans l'environnement de développement : par la fenêtre Aide dynamique et par le menu ? (Aide).

Cette fenêtre contient des pointeurs vers des informations spécifiques à la zone utilisée ou à la tâche en cours dans l'environnement de développement. L'environnement de développement suit les sélections que vous effectuez, la position du pointeur et les éléments activés, au fil de vos interactions avec le produit. La fenêtre Aide dynamique filtre ensuite les rubriques disponibles dans Microsoft Developer Network (MSDN) pour afficher les informations qui conviennent. Si aucune information appropriée n'est trouvée, la fenêtre affiche un message indiquant qu'aucun lien n'existe pour la sélection.

! Pour ouvrir la fenêtre Aide dynamique • Dans le menu ? (Aide), cliquez sur Aide dynamique.

Introduction

Stratégies pour l'utilisation de l'aide

La fenêtre Aide dynamique


Vous pouvez utiliser ce menu pour accéder aux documents d'aide et notamment aux catégories suivantes :

! Sommaire Affiche la fenêtre Sommaire dans laquelle vous pouvez parcourir les rubriques du sommaire de MSDN Library.

! Index Affiche la fenêtre Index dans laquelle vous pouvez entrer des mots clés pour rechercher des rubriques dans MSDN Library.

! Rechercher Affiche la fenêtre Rechercher dans laquelle vous pouvez entrer un texte à rechercher dans MSDN Library.

Vous pouvez également accéder à ces catégories en cliquant sur les boutons de la barre d'outils dans la fenêtre Aide dynamique.

Menu ? (Aide)


Application pratique : Utilisation de l'environnement de développement

Ouvrez et exécutez une application existante

Examinez un formulaire dans le Concepteur Windows Forms et l'éditeur de code

Examinez les paramètres des propriétés des contrôles

Ouvrez, fermez, rouvrez et masquez la boîte à outils

Utilisez l'Aide dynamique


Dans cet exercice, vous allez apprendre à utiliser les outils de programmation de l'environnement de développement Visual Studio .NET.

! Ouverture et exécution d'une application existante dans Visual Basic .NET

1. Démarrez Visual Studio .NET. Si Visual Studio.NET est déjà ouvert, cliquez sur le menu Fichier et sélectionnez l'option Fermer la solution pour fermer les solutions ouvertes.

2. Dans le menu Fichier, pointez sur Ouvrir, puis cliquez sur Projet. 3. Ouvrez la solution ApplicationToExplore.sln qui se trouve dans le dossier

dossier_installation\Practices\Mod01. 4. Dans la barre d'outils standard, cliquez sur le bouton ou appuyez sur F5. 5. Cliquez sur les boutons du formulaire pour tester le fonctionnement de

l'application. 6. Quittez l'application.

Introduction

Ouverture d'un projet


! Examen d'un formulaire dans le Concepteur Windows Forms et l'éditeur de code

1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Form1.vb, puis cliquez sur Concepteur de vues. Répondez aux questions ci-dessous : a. Que se passe-t-il ?

La vue [Design] Form1.vb s'ouvre. _________________________________________________________

_________________________________________________________

b. La page de démarrage est-elle encore disponible ? Oui, parce que l'onglet Page de démarrage est encore visible. _________________________________________________________

_________________________________________________________

2. Cliquez avec le bouton droit sur le formulaire (n'importe où excepté dans la barre de titre), puis choisissez Afficher le code pour activer l'éditeur de code. (Notez que l'option Afficher le code se trouve également dans le menu contextuel qui s'affiche en cliquant avec le bouton droit sur le formulaire Form1.vb sélectionné dans l'Explorateur de solutions.)

3. Notez dans les espaces ci-dessous, les noms des gestionnaires d'événements affichés dans l'éditeur de code. Private Sub ___________________ & Private Sub ___________________ Button1_Click & Button2_Click ____________________________________________________________

____________________________________________________________

4. Cliquez sur l'onglet [Design] Form1.vb pour revenir au mode Design.

! Ouverture, fermeture, réouverture et masquage de la boîte à outils

1. Cliquez sur l'icône de la boîte à outils dans la partie gauche de l'environnement de développement. La boîte à outils s'ouvre.

2. Cliquez sur l'icône qui représente une épingle dans la barre de titre de la boîte à outils. Que se passe-t-il ? La boîte à outils s'ancre et reste ouverte. ____________________________________________________________

____________________________________________________________

Examen des vues du formulaire

Utilisation de la boîte à outils


3. Fermez la boîte à outils. 4. Pour rouvrir la boîte à outils, dans le menu Affichage, cliquez sur Boîte à

outils. Notez que l'épingle a changé de position. Cliquez à nouveau sur l'épingle

dans la barre de titre de la boîte à outils. Que se passe-t-il ? La fonction qui permet de masquer automatiquement la boîte à outils est activée. ____________________________________________________________

____________________________________________________________

Si vous cliquez par erreur sur un contrôle, appuyez simplement deux fois sur la touche Échap.

! Examen des paramètres des propriétés des contrôles 1. En mode Design, cliquez sur Button1. Examinez les paramètres des

propriétés Name et TabIndex. 2. Cliquez n'importe où dans le formulaire excepté sur un contrôle. Que se

passe-t-il dans la fenêtre Propriétés ? La fenêtre Propriétés affiche les propriétés du formulaire. ____________________________________________________________

____________________________________________________________

3. Examinez les propriétés Name et BackgroundImage du formulaire.

! Utilisation de l'Aide dynamique 1. Vérifiez que le formulaire Form1.vb est affiché dans la fenêtre de design.

Sélectionnez le formulaire, cliquez sur Button1, puis cliquez sur la propriété BackColor de Button1.

2. Cliquez sur l'onglet Aide dynamique au bas de la fenêtre Propriétés. Si l'onglet n'est pas visible, dans le menu ? (Aide), cliquez sur Aide dynamique. Notez que les articles proposés correspondent aux éléments sélectionnés dans la fenêtre Propriétés.

3. Dans la liste d'articles sous le titre Aide, cliquez sur Fenêtre Propriétés et affichez la rubrique d'aide correspondante.

4. Dans le menu ? (Aide), cliquez sur Sommaire. 5. Dans la fenêtre Sommaire, cliquez sur Visual Basic et associé dans la zone

Filtre.

6. Cliquez sur le bouton Synchroniser la table des matières dans la barre d'outils pour afficher l'emplacement de la rubrique dans le sommaire de l'aide.

7. Quittez Visual Studio .NET.

Conseil

Examen des propriétés

Utilisation de l'Aide


Leçon : Création d'un projet Visual Basic .NET

Création de l'interfaceutilisateur

Écriture de code

Test et débogage

Génération et déploiement

Création d'unespécification de

design


Cette leçon explique comment créer une application simple dans Visual Basic .NET. Son objectif est de présenter le processus de programmation dans son ensemble. Il ne s'agit pas ici d'entrer dans le détail de la syntaxe du langage ou de l'implémentation.


! Processus de développement ! Création de l'interface utilisateur ! Définition des propriétés des contrôles ! Ajout de code pour les contrôles ! Enregistrement, génération et exécution de l'application


! décrire le processus de création d'une application dans Visual Basic .NET ; ! démarrer un nouveau projet et créer les objets de l'interface utilisateur ; ! définir les propriétés des contrôles ; ! écrire un code d'événement pour ajouter une fonctionnalité à une

application ; ! enregistrer, exécuter et créer une version de diffusion d'une application.

Introduction




Processus de développement

CréationCréation d'uned'une spécificationspécification de designde design

22

11

33

44

55

66

77

CréationCréation de de l'interfacel'interface utilisateurutilisateur

Définition des propriétés des objets de l'interface Définition des propriétés des objets de l'interface utilisateurutilisateurÉcriture de code pour l'ajout de fonctionnalitéÉcriture de code pour l'ajout de fonctionnalitéss

Test et Test et débogagedébogage de l'applicationde l'application

Création d'un fichier exécutableCréation d'un fichier exécutable

Création d'un programme d'installationCréation d'un programme d'installation


Visual Basic .NET contient tout ce dont vous avez besoin pour créer vos propres applications pour Windows, du début à la fin. Pour créer l'interface utilisateur, vous devez placer sur un formulaire des contrôles qui se trouvent dans la boîte à outils, puis personnaliser ces contrôles en paramétrant leurs propriétés. Une fois cela fait, vous devez définir le comportement de votre programme en écrivant le code qui convient. Enfin, vous devez enregistrer, exécuter et compiler votre programme pour que d'autres utilisateurs puissent l'utiliser.

La création d'une application dans Visual Basic .NET implique sept étapes de base :

1. Création d'une spécification de design La spécification de design est le plan que vous allez suivre pour créer une application. Prenez tout le temps nécessaire avant d'écrire du code pour concevoir l'application que vous allez créer. Visual Basic .NET fournit tous les outils nécessaires au développement rapide d'une solution, mais il est toutefois utile de bien comprendre les besoins de l'utilisateur et de bien définir les fonctions de départ pour ainsi développer le plus efficacement possible. Vous gagnerez du temps car vous réduirez les phases éventuelles de réécriture du code, nécessaires lorsque la spécification est mauvaise ou inexistante.

2. Création de l'interface utilisateur Pour créer l'interface de votre application, placez tout d'abord les contrôles et les objets sur un formulaire en les représentant au moyen du Concepteur Windows Forms. Vous pouvez vous inspirer d'autres applications comme Microsoft Excel ou Microsoft Word pour avoir une idée de design d'interface. Pour plus d'informations sur le design d'une interface, consultez le document Microsoft Windows User Experience (en anglais), publié par Microsoft Press®.

Étapes de base


3. Définition des propriétés des objets de l'interface utilisateur Après avoir ajouté des objets à un formulaire, vous devez définir leurs propriétés dans la fenêtre Propriétés ou dans l'éditeur de code.

4. Écriture de code pour l'ajout de fonctionnalités Après avoir défini les propriétés initiales du formulaire et de ses objets, vous pouvez ajouter du code qui s'exécute en réponse à certains événements. Les événements se produisent lorsque différentes actions sont enregistrées pour un contrôle ou un objet. Par exemple, l'événement Click d'un bouton se produit lorsqu'un utilisateur clique sur le bouton à l'aide d'une souris. Dans la plupart des applications, il vous faudra également écrire du code pour ajouter un élément qui fait partie de la logique d'application et pour accéder aux données.

5. Test et débogage de l'application Le test et le débogage ne se font pas en une seule étape mais de façon interactive tout au long du processus de développement. À chaque fois que vous apportez une modification majeure aux étapes 2, 3 ou 4 vous devez créer une version de débogage de l'application et vous assurer qu'elle fonctionne comme prévu. Visual Basic .NET fournit de nombreux outils de débogage que vous pouvez utiliser pour rechercher et corriger les erreurs dans votre application.

6. Création d'un fichier exécutable Une fois le projet terminé, vous devez créer une version de diffusion du projet, que vous devez tester et déboguer à nouveau. Cette opération compile les différents fichiers qui composent le programme pour générer un fichier exécutable autonome, appelé un assembly.

7. Création d'un programme d'installation Pour exécuter votre application, les utilisateurs auront besoin d'autres fichiers et par exemple des fichiers de bibliothèque de liens dynamiques (DLL, Dynamic-Link Library) que vous avez utilisés pour la créer. Visual Basic .NET fournit l'Assistant Installation qui automatise la création du programme d'installation et garantit que l'utilisateur dispose de tous les fichiers nécessaires.


Création de l'interface utilisateur

Placez des contrôlesdepuis la boîte à outils

sur le formulaire

Placez des contrôlesdepuis la boîte à outils

sur le formulaire


Lorsque vous créez une application, la première étape consiste à créer l'interface utilisateur. Dans Visual Basic .NET, il est possible de créer rapidement cette interface utilisateur en ajoutant dans un formulaire des contrôles qui se trouvent dans la boîte à outils.

! Pour ajouter des contrôles à un formulaire 1. Si la boîte à outils n'est pas ouverte, dans le menu Affichage, cliquez sur

Boîte à outils. 2. Dans la boîte à outils, cliquez sur le contrôle à ajouter au formulaire et

faites-le glisser vers l'emplacement de votre choix dans le formulaire.

! Pour déplacer et redimensionner des contrôles 1. Pour déplacer un contrôle, sélectionnez-le et faites-le glisser vers

l'emplacement de votre choix dans le formulaire. 2. Pour redimensionner un contrôle, sélectionnez-le et faites glisser l'une des

poignées de redimensionnement jusqu'à ce que le contrôle ait atteint la taille désirée, puis relâchez le bouton de la souris.

Introduction

Ajout de contrôles à un formulaire

Déplacement et redimensionnement des contrôles



PropriétésPropPropriétésriétés ValeursValeursValeurs(Name)(Name) Textbox1Textbox1

BackColorBackColor BlueBlue

AutosizeAutosize TrueTrue

VisibleVisible TrueTrue

BorderBorder Fixed 3DFixed 3D

FontFont Microsoft SanSerif, 8.2 ptMicrosoft SanSerif, 8.2 pt

TextText Textbox1Textbox1


Les propriétés des objets se modifient en sélectionnant les objets voulus sur le formulaire et en changeant leurs valeurs dans la fenêtre Propriétés.

! Pour définir les propriétés dans la fenêtre Propriétés 1. Si la fenêtre Propriétés n'est pas ouverte, dans le menu Affichage, cliquez

sur Fenêtre Propriétés. 2. Cliquez sur le contrôle pour lequel définir une propriété. 3. Dans la fenêtre Propriétés, sélectionnez la propriété et affectez-lui la valeur

souhaitée.

Introduction



Ajout de code pour les contrôles

Private Sub Button1_Click(. . .)Handles Button1.Click

'Ajoutez votre code ici

End Sub

Private Sub Button1_Click(. . .)Handles Button1.Click

'Ajoutez votre code ici

End Sub

! Dans la liste Nom de la classe, cliquez sur le contrôle

! Dans la liste Nom de la méthode, cliquez sur l'événement

! Ajoutez du code entre Private Sub et End Sub


Après avoir défini les propriétés initiales des objets de l'interface utilisateur, vous pouvez ajouter du code qui s'exécute en réponse à certains événements. Les événements se produisent lorsque différentes actions sont enregistrées pour un contrôle ou un objet. Par exemple, l'événement Click d'un bouton se produit lorsqu'un utilisateur clique sur le bouton à l'aide d'une souris.

! Pour écrire du code pour l'événement d'un contrôle 1. Dans l'Explorateur de solutions, sélectionnez le formulaire pour lequel

écrire du code. 2. Dans le menu Affichage, cliquez sur Code pour ouvrir l'éditeur de code. 3. Dans la liste Nom de la classe, sélectionnez le contrôle pour lequel écrire

du code. 4. Dans la liste Nom de la méthode, sélectionnez l'événement de votre choix

pour ouvrir son gestionnaire d'événements dans l'éditeur de code. L'éditeur de code affiche les instructions de programmation qui marquent le début et la fin de la procédure d'événement.

5. Écrivez votre code entre les balises qui signalent le début et la fin de la procédure.

Introduction

Écriture de code


Enregistrement, génération et exécution de l'application

Enregistrement de l'applicationEnregistrement de l'application

Exécution de la solution dansl'environnement de développementExécution de la solution dansl'environnement de développement

Génération d'un fichier exécutableGénération d'un fichier exécutable


Lorsque vous avez terminé de créer votre application, vous pouvez l'enregistrer et l'exécuter à l'intérieur de l'environnement de développement pour vous assurer qu'elle fonctionne correctement. La version ainsi générée est appelée une version déboguée. Vous pouvez ensuite générer un fichier exécutable pour permettre l'exécution de l'application en dehors de l'environnement de développement. La version ainsi générée est appelée une version de diffusion.

! Pour enregistrer l'application • Dans le menu Fichier, cliquez sur Enregistrer tout.

! Pour exécuter le projet dans l'environnement de développement

1. Dans la barre d'outils standard, cliquez sur le bouton Démarrer pour créer une version déboguée de l'application. Si l'application s'exécute sans erreur, une version utilisable du formulaire s'affiche.

2. Fermez le formulaire pour retourner dans l'environnement de programmation.

! Pour générer un fichier exécutable pour le projet 1. Dans le menu Générer, cliquez sur Générer la solution.

Lorsque vous générez un projet ou une solution, un fichier exécutable (.exe) est créé automatiquement dans le dossier dossier_projet\bin. Si l'élément Debug est sélectionné dans la liste Configurations de solutions de la barre d'outils, un second fichier .exe est créé dans le dossier dossier_projet\obj\ Debug. Si l'élément Release est sélectionné, le second fichier .exe est créé dans le dossier dossier_projet\obj\Release.

2. Pour exécuter ce projet dans Windows, utilisez la commande Exécuter du menu Démarrer ou double-cliquez sur le nom du fichier dans l'Explorateur Windows.

Introduction

Enregistrement de l'application

Exécution du projet

Génération du projet


Contrôle des acquis

! Concepts de base de l'environnement .NET

! Exploration de l'environnement de développement

! Création d'un projetVisual Basic .NET


Accèsaux données


Écriture decode

Créationd'une

interface


Studio .NET


1. Comment devez-vous procéder pour ouvrir l'éditeur de code pour un formulaire ? Expliquez pourquoi c'est nécessaire. Dans l'Explorateur de solutions, cliquez sur le bouton Afficher le code de la barre d'outils. Il faut ouvrir l'éditeur de code pour écrire du code en vue d'ajouter des fonctionnalités à un événement de contrôle.

2. De quelle façon le Common Language Runtime gère-t-il l'exécution des applications écrites dans plusieurs langages de programmation différents ? Visual Studio .NET compile le code indépendamment du langage de programmation pour obtenir un langage commun : le langage MSIL (Microsoft Intermediate Language).

3. Une fois que la spécification de design de votre application est terminée, que devez-vous faire pour créer les objets de l'interface utilisateur ? Il faut ajouter dans le Concepteur Windows Forms des contrôles qui se trouvent dans la boîte à outils.


4. Lorsque vous créez une application dans Visual Basic .NET, comment pouvez-vous vous assurer qu'elle fonctionne correctement après lui avoir apporté des modifications importantes ? Dans la barre d'outils standard, cliquez sur le bouton Démarrer pour exécuter l'application dans l'environnement de développement. Si des erreurs se produisent, l'exécution est interrompue et le compilateur affiche un message d'erreur pour vous aider à corriger le problème.

5. Quel outil de programmation devez-vous utiliser pour modifier la couleur et la légende d'un objet d'interface utilisateur ? La fenêtre Propriétés ou l'éditeur de code.

6. Quand devez-vous créer une version de diffusion pour votre application ? Lorsque vous êtes prêt à tester et à distribuer l'application aux autres utilisateurs ou sur les autres ordinateurs.


Atelier 1.1 : Création de votre première application

! Exercice 1 : Création de votre première application dans Visual Basic .NET


À la fin de cet atelier, vous serez à même d'effectuer les tâches suivantes :

! utiliser l'environnement de développement Visual Studio .NET ; ! créer l'interface utilisateur d'un projet simple Visual Basic .NET ; ! ajouter des contrôles et des fonctionnalités à un formulaire ; ! générer et exécuter un fichier d'application exécutable.

Cet atelier se concentre sur les concepts abordés dans ce module et peut par conséquent ne pas suivre les recommandations de Microsoft en termes de sécurité.

Objectifs

Remarque


Dans cet atelier, vous allez créer une application Windows simple et ajouter des contrôles à un formulaire. Vous allez aussi créer une version de diffusion de l'application pour pouvoir l'exécuter en dehors de l'environnement de développement. Le formulaire une fois terminé aura l'aspect dans le Concepteur Windows Forms de la capture d'écran ci-dessous :

1. Lorsque l'utilisateur clique sur Afficher le contenu de la zone de texte, une zone affiche le contenu de la zone de texte.

2. Lorsque l'utilisateur clique sur Modifier la couleur du formulaire, la couleur d'arrière-plan du formulaire change.

En règle générale, les conseils relatifs à la facilité d'accès proposent aux développeurs de ne pas modifier la couleur d'arrière-plan des formulaires. Si la couleur d'arrière-plan n'est pas modifiée, le formulaire utilise les paramètres Windows. Dans certains cas toutefois, il peut s'avérer nécessaire de modifier les couleurs d'arrière-plan pour répondre à des besoins de design spécifiques.

3. Lorsque l'utilisateur clique sur Modifier la couleur de la police de la zone de texte, la couleur du texte affiché dans la zone de texte change.

Les fichiers solution pour cet atelier se trouvent dans le dossier dossier_installation\Labfiles\Lab011\Ex01\Solution.

Scénario

Remarques de design

Remarque

Fichiers solution

Durée approximative de cet atelier : 30 minutes


Exercice 1 Création de votre première application dans Visual Basic .NET

Dans cet exercice, vous allez démarrer une nouvelle application basée sur Windows, ajouter plusieurs contrôles dans un formulaire généré automatiquement, définir des propriétés pour ces contrôles et ajouter du code pour leur associer des fonctionnalités.

! Démarrage d'une application Visual Basic .NET 1. Démarrez Visual Studio .NET si ce n'est déjà fait. 2. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 3. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets

Visual Basic, puis sur Application Windows. Attribuez au projet le nom MonPremierProjet et affectez-lui le chemin d'accès dossier_installation\ Labfiles\Lab011\Ex01 et enfin, cliquez sur OK.

! Ajout de contrôles au formulaire 1. Ajoutez un contrôle Label au formulaire.

Pour ajouter un contrôle à un emplacement précis sur le formulaire, sélectionnez le contrôle de votre choix, puis cliquez à l'emplacement voulu sur le formulaire. Le contrôle est ajouté dans le formulaire à l'emplacement où vous avez cliqué.

2. Ajoutez un contrôle TextBox au formulaire. 3. Ajoutez trois contrôles Button au formulaire 4. Déplacez et redimensionnez le formulaire et les contrôles pour obtenir un

formulaire similaire à celui représenté ci-dessous :

5. Enregistrez votre travail.


! Définition des propriétés des contrôles 1. Cliquez sur Label1 dans le formulaire pour afficher ses propriétés dans la

fenêtre Propriétés. Si la fenêtre Propriétés n'est pas visible, dans le menu Affichage, cliquez sur Fenêtre Propriétés.

2. Dans la fenêtre Propriétés, sélectionnez la propriété Font, puis cliquez sur le bouton Sélection pour afficher la boîte de dialogue Police. Changez les paramètres de la police comme illustré ci-dessous et cliquez sur OK.

3. Définissez les propriétés des contrôles Label et TextBox en leur affectant les valeurs du tableau ci-dessous.

Nom du contrôle Propriété Nouvelle valeur

Label1 Text Mon premier formulaire

Label1 TextAlign MiddleCenter

TextBox1 Text Taper quelque chose ici

4. Définissez la propriété Text pour les trois boutons en leur affectant les valeurs du tableau ci-dessous.


Button1 Text Afficher le contenu de la zone de texte

Button2 Text Modifier la couleur du formulaire

Button3 Text Modifier la couleur de la police de la zone de texte

5. Enregistrez votre travail.


Dans les trois procédures qui suivent, vous allez utiliser l'éditeur de code pour le formulaire Form1.vb et ajouter plusieurs lignes de code à votre application pour faire en sorte qu'elle réponde aux données entrées par les utilisateurs. L'objectif est de vous apprendre à ajouter du code à votre application et non à écrire du code. Ne soyez donc pas inquiet si vous n'êtes pas familier avec le code et la syntaxe du gestionnaire d'événements.

! Ajout de code au gestionnaire de l'événement Click du bouton Afficher le contenu de la zone de texte

1. Double-cliquez sur le bouton Afficher le contenu de la zone de texte du formulaire. L'éditeur de code du formulaire Form1.vb s'ouvre et affiche le code suivant : Private Sub Button1_Click (...) End Sub

Le formulaire contient deux vues : la vue Design ([Design] Form1.vb) et la vue Code (Form1.vb). Vous pouvez passer d'une vue à l'autre en cliquant sur les onglets correspondants en haut du formulaire.

2. Tapez la ligne de code suivante dans le gestionnaire d'événements Button1_Click : MessageBox.Show(TextBox1.Text)

Votre code doit ressembler au texte suivant : Private Sub Button1_Click (...) MessageBox.Show(TextBox1.Text) End Sub

! Ajout de code et modification de la couleur du bouton et de l'arrière-plan du formulaire

1. Activez la vue Design du formulaire. 2. Double-cliquez sur le bouton Modifier la couleur du formulaire pour

ouvrir l'éditeur de code. 3. Tapez la ligne de code suivante dans le gestionnaire d'événements

Button2_Click : Me.BackColor = Color.CadetBlue

Votre code doit ressembler au texte suivant : Private Sub Button2_Click (...) Me.BackColor = Color.CadetBlue End Sub

Remarque

Conseil


! Ajout de code et modification de la couleur de la police dans la zone de texte

1. Activez la vue Design du formulaire. 2. Double-cliquez sur le bouton Modifier la couleur de la police de la zone

de texte dans le formulaire pour ouvrir l'éditeur de code. 3. Tapez la ligne de code suivante dans le gestionnaire d'événements

Button3_Click : TextBox1.ForeColor = Color.Red

Votre code doit ressembler au texte suivant : Private Sub Button3_Click (...) TextBox1.ForeColor = Color.Red End Sub

! Exécution et test de votre application dans l'environnement de design

1. Cliquez sur le bouton Démarrer dans la barre d'outils standard. 2. Cliquez sur tous les boutons du formulaire afin de vous assurer qu'ils

fonctionnent correctement. 3. Modifiez le texte qui figure dans la zone de texte, puis cliquez sur Afficher

le contenu de la zone de texte. 4. Quittez l'application.

! Enregistrement et génération d'un fichier exécutable pour votre application

1. Pour enregistrer votre solution, cliquez sur le bouton Enregistrer tout de la barre d'outils standard.

2. Dans la liste Configurations de solutions de la barre d'outils standard, choisissez la configuration Release à la place de la configuration Debug.

3. Dans le menu Générer, cliquez sur Générer la solution pour créer une version de diffusion de votre application.

4. Quittez Visual Studio .NET. 5. Dans l'Explorateur Windows, recherchez votre fichier exécutable dans le

dossier dossier_installation\Labfiles\Lab011\Ex01\MonPremierProjet\ obj\Release.

6. Double-cliquez dessus pour l'exécuter et testez toutes les fonctionnalités en dehors de l'environnement de développement. Fermez l'application.


Table des matières

Vue d'ensemble 1

Présentation multimédia : Présentation des objets, propriétés, méthodes et événements 2

Leçon : Compréhension des concepts de programmation 3

Leçon : Utilisation de Windows Forms 9

Leçon : Utilisation des contrôles 25

Leçon : Présentation de votre code 40


Atelier 2.1 : Création de l'interface utilisateur 49

Module 2 : Utilisation de formulaires et de contrôles


Module 2 : Utilisation de formulaires et de contrôles iii

Notes de l'instructeur Ce module présente aux stagiaires les classes, les objets, les propriétés, les méthodes et les événements. Il leur explique ensuite comment les utiliser dans Microsoft® Visual Basic® .NET. Les stagiaires apprendront à définir des propriétés, à appeler des méthodes et à écrire le code correspondant aux événements de formulaire et de contrôle. Ils apprendront les instructions de code à utiliser pour gérer plusieurs formulaires dans une application. Ils se familiariseront avec les conventions d'affectation de noms Visual Basic et apprendront à mettre en forme et à documenter le code. Pour finir, ils utiliseront les formulaires, les contrôles et le code voulus pour créer le formulaire principal d'une application de simulation de prêt.


! expliquer les concepts fondamentaux de programmation tels que : programmation événementielle, classes, objets, propriétés, méthodes et événements ;

! utiliser des formulaires et des contrôles pour créer une interface utilisateur ; ! créer et gérer plusieurs formulaires dans une seule et unique application ; ! communiquer avec l'utilisateur à l'aide de la fonction MessageBox ; ! respecter les standards Visual Basic pour nommer les éléments qu'ils créent

ainsi que mettre en forme et documenter le code.


! Fichier Microsoft PowerPoint® 2560A_02.ppt ! Fichiers de démonstration multimédia 2560A_02d005.wmv et

2560A_02d010.wmv ! Fichier d'animation multimédia 2560A_OPMandE.htm


! lire tous les documents de cours relatifs à ce module ; ! réaliser les applications pratiques et l'atelier ; ! prendre connaissance des deux démonstrations multimédias et de

l'animation prévues pour ce module.

Présentation et applications pratiques : 75 minutes Atelier : 45 minutes

Documents de cours

Préparation

iv Module 2 : Utilisation de formulaires et de contrôles


Présentation multimédia : Présentation des objets, propriétés, méthodes et événements

Ce module commence par une animation multimédia qui présente tous les concepts clés utilisés dans le module. Dans cette animation, les stagiaires vont découvrir et apprendre à utiliser les objets, les propriétés, les méthodes et les événements.

Leçon : Compréhension des concepts de programmation Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Cette rubrique explique ce qu'est la programmation événementielle et en quoi elle diffère de la programmation en langage procédural. Si ce n'est pas encore fait, voilà une bonne occasion de demander à vos stagiaires l'expérience qu'ils possèdent en matière de programmation.

Ne perdez pas de temps à expliquer le code présent dans l'exemple de programmation événementielle. L'essentiel est d'expliquer que le code est traité en réponse à un événement.

Le but de cette rubrique est de faire comprendre aux stagiaires qu'un objet est une instance d'une classe. Les classes sont décrites en détail dans le module 7, « Programmation orientée objet en Visual Basic .NET », du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Si les stagiaires de votre classe ont peu d'expérience en programmation, pensez à créer un formulaire simple et à y ajouter quelques contrôles. Insistez sur le fait que chaque contrôle est un objet distinct placé sur le formulaire, qui est lui-même un objet.

Précisez bien aux stagiaires qu'ils n'ont pas besoin de comprendre parfaitement le fonctionnement des objets pour pouvoir les utiliser dans Visual Basic.

Présentation de la programmation événementielle

Classes : Modèles servant à la création des objets

Présentation des propriétés, des méthodes et des événements

Module 2 : Utilisation de formulaires et de contrôles v

Si les stagiaires ont du mal à comprendre ce que sont les propriétés, les méthodes et les événements, laissez-les réfléchir individuellement pendant cinq minutes sur cet exercice, puis vérifiez ensemble les réponses proposées. Si le groupe est plus expérimenté, faites l'exercice en groupe et laissez les stagiaires proposer des solutions. Quel que soit le cas, ne consacrez pas plus de 10 minutes à cette application pratique.

Voici quelques réponses possibles pour cette application pratique.

Objet Propriétés Méthodes Événements

Porte Hauteur, Largeur, Matériau

Ouvrir, Fermer Fermeture, Ouverture

Voiture Couleur, Modèle, Année

Arrêter, MettreContact

AppuiPédaleFrein, ActivationCléContact

Leçon : Utilisation de Windows Forms Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Pour bien faire comprendre les rubriques de ce module, n'hésitez pas à recourir à l'environnement de développement Microsoft Visual Studio® .NET lors de vos explications. Pour cette rubrique, ouvrez le concepteur Windows® Forms et affichez le formulaire par défaut. Expliquez ensuite comment ajouter un deuxième formulaire. Indiquez qu'un onglet Form2.vb [Design] vient s'ajouter au concepteur, ainsi qu'au projet dans l'Explorateur de solutions.

Ouvrez un formulaire dans Visual Basic, puis ouvrez la fenêtre Propriétés pour le formulaire. Suivez les étapes décrites dans les notes du stagiaire, puis modifiez quelques-unes des propriétés de base du formulaire. Expliquez la différence qui existe entre la propriété Name et la propriété Text. Montrez bien aux stagiaires que l'application ne fonctionne pas correctement si vous changez la propriété Name sans changer l'objet de démarrage. Expliquez ensuite comment modifier l'objet de démarrage du projet.

Cette rubrique s'accompagne d'une application pratique facultative. Si vous n'avez pas le temps de laisser les stagiaires réaliser cette application pratique, utilisez-la vous-même pour montrer comment modifier les propriétés, ou modifiez vous-même la propriété Cursor et laissez les stagiaires modifier la propriété Opacity. Cette application pratique ne doit pas prendre plus de cinq minutes.

Pour montrer en quoi consiste une méthode, vous pouvez ajouter Me.CenterToScreen( ) à l'événement Click du formulaire. Expliquez ensuite comment utiliser Microsoft IntelliSense® pour terminer la commande. Exécutez l'application pour montrer ce que fait la méthode.

Indiquez aux stagiaires que les parenthèses utilisées dans ce code sont obligatoires, mais ne perdez pas de temps à expliquer les paramètres. Cette rubrique est traitée en détail dans la suite du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Montrez comment ouvrir les gestionnaires d'événements pour deux ou trois des événements répertoriés dans le tableau des notes du stagiaire. Expliquez la différence qui existe entre les événements Closing et Closed et insistez sur le fait que certains événements se déroulent dans un ordre particulier.

Application pratique : Propriétés, méthodes et événements

Création d'un formulaire

Définition des propriétés d'un formulaire

Appel des méthodes

Gestion des événements de formulaire

vi Module 2 : Utilisation de formulaires et de contrôles

Cette application pratique a pour but de donner aux stagiaires la possibilité d'ouvrir un gestionnaire d'événements, d'écrire quelques lignes de code simples et de tester les résultats. Cette application pratique ne doit pas prendre plus de dix minutes.

Pour lancer cette démonstration, cliquez sur l'icône située au centre de la diapositive. Si vous préférez vous servir de cette démonstration multimédia en tant que démonstration dirigée, vous trouverez les étapes à suivre dans la section Démonstration des notes de l'instructeur.

Pour plus d'informations sur les paramètres corrects à utiliser pour une présentation optimale des démonstrations multimédias, consultez la Liste de préparation du cours fournie sur le CD de l'instructeur.

Expliquez ce qui différencie les formulaires modaux et les formulaires non modaux. Étudiez le point de vue de l'utilisateur et expliquez pourquoi il est important de donner le contrôle aux utilisateurs dans une application. Donnez aussi des exemples de situations où un formulaire non modal sera plus approprié (en présence de processus de longue durée) et où il sera préférable d'employer un formulaire modal.

Pour expliquer cette rubrique, vous avez tout intérêt à vous servir de l'environnement de développement Visual Studio .NET. Expliquez bien à quel moment il faut utiliser le mot clé Me et le nom du formulaire. Conseillez aux stagiaires de consulter le cours 2565, Developing Microsoft .NET Applications for Windows (Visual Basic .NET) (en anglais), dans lequel les applications compatibles avec l'interface multidocument (MDI) sont expliquées en détail.

Leçon : Utilisation des contrôles Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Les stagiaires ont eu un bref aperçu de cette rubrique dans le Module 1, « Mise en route », du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET. Si vous n'avez présenté qu'une méthode pour ajouter des contrôles à un formulaire lors du Module 1, cette rubrique est l'occasion de montrer les autres options existantes. Dans cette leçon, vous aborderez les quatre contrôles suivant en détail : ComboBox, GroupBox, PictureBox et RadioButton. Présentez ces contrôles lorsque vous expliquez d'autres manières d'ajouter des contrôles à un formulaire.

Expliquez aux stagiaires pourquoi il vaut mieux prendre l'habitude de renommer les contrôles lors de leur ajout à un formulaire. Décrivez brièvement les propriétés clés des quatre contrôles présentés dans cette leçon. Les stagiaires auront à utiliser ces propriétés dans l'atelier associé à ce module. Expliquez comment définir une propriété pour plusieurs contrôles à la fois. La propriété Font convient bien à ce genre de démonstration.

Application pratique : Création du code associé à des événe-ments de formulaire

Présentation multimédia : Gestion des formulaires

Formulaires modaux et non modaux

Gestion de plusieurs formulaires


Définition des propriétés d'un contrôle

Module 2 : Utilisation de formulaires et de contrôles vii

Cette rubrique aborde également le problème de l'accessibilité des logiciels. Compte tenu du nombre de personnes concernées par les questions d'accessibilité, il s'agit là d'une rubrique importante même pour ceux qui ne développeront pas de logiciel dans un secteur médical particulier. Étudiez quelques-unes des propriétés de contrôle qui permettront de rendre une application plus accessible. Ouvrez la documentation Visual Studio .NET et faites découvrir aux stagiaires les procédures pas à pas qui leur sont proposées sur plusieurs sujets, notamment la rubrique « Procédures pas à pas Visual Basic : Procédures pas à pas relatives à l'accessibilité : Création d'une application Windows accessible ». Indiquez leur également que la documentation Visual Studio .NET compte bien d'autres informations sur l'accessibilité.

Pour lancer cette démonstration, cliquez sur l'icône située au centre de la diapositive. Si vous préférez vous servir de cette démonstration multimédia en tant que démonstration dirigée, vous trouverez les étapes à suivre dans la section Démonstration des notes de l'instructeur.


Expliquez cette rubrique à l'aide de l'environnement de développement Visual Studio .NET. Cette rubrique est similaire à celle consacrée aux événements de formulaire. Dans ce cas, les stagiaires sélectionnent le nom du contrôle dans la liste Nom de la classe, alors que pour un formulaire ils utilisaient Événements de la classe de base.

La meilleure façon d'expliquer cette rubrique est de travailler dans l'environnement de développement Visual Studio .NET. Ne perdez pas de temps à expliquer les paramètres ; ils sont abordés en détail dans la suite du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Cette rubrique donne aux stagiaires la possibilité d'ajouter du code à des événements et d'utiliser la fonction MessageBox. Cette application pratique ne doit pas prendre plus de 10 minutes et constitue une préparation fort utile pour l'atelier. Pour la première fois, les stagiaires auront l'occasion d'écrire du code.

Leçon : Présentation de votre code Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Cette leçon doit être assez brève. Son but est d'aider les stagiaires lors de l'atelier et des applications pratiques de ce cours. Soulignez bien aux stagiaires qu'ils doivent choisir une convention d'affectation de noms et s'y tenir dans leur programme. En respectant ce principe, ils arriveront facilement à mettre leur code à jour et à le faire comprendre aux autres utilisateurs. Vous souhaiterez vraisemblablement montrer ce qui risque d'arriver en cas de violation de l'une des conventions d'affectation de noms. (N'oubliez pas de montrer aux stagiaires comment réparer l'erreur produite dans Visual Basic.)

Il y a quatre points clés à aborder dans cette rubrique : la mise en retrait, le signe de continuation, la concaténation et les commentaires. Expliquez brièvement chacun de ces points dans l'Éditeur de code. Donnez aux stagiaires quelques conseils quant au moment où ils devront commenter le code.

Présentation multimédia : Événements de formulaire et de contrôle

Association de code à des événements de contrôle

Utilisation de la fonction MessageBox

Application pratique : Création d'un message

Conventions d'affectation de noms

Mise en forme et documentation du code

viii Module 2 : Utilisation de formulaires et de contrôles

Contrôle des acquis Suivez la liste à puces de la diapositive pour passer en revue et résumer les principaux points de ce module. Adoptez le principe de la discussion pour répondre aux questions afin que chacun ait la possibilité de connaître la bonne réponse.

1. Assurez-vous que les stagiaires ne confondent pas une classe et un objet. 2. Les stagiaires risquent d'avoir quelques difficultés à différencier les

méthodes des événements. Ces concepts sont abordés dans la première leçon.

3. Si les stagiaires rencontrent quelques difficultés à cet égard, prenez le temps d'expliquer la réponse dans l'environnement de développement Visual Studio .NET.

4. Passez en revue chaque réponse. Assurez-vous que les stagiaires comprennent bien pourquoi la réponse A est incorrecte.

5. Conseillez aux stagiaires de revoir l'application pratique : « Création d'un message » s'ils rencontrent des difficultés à cet égard. Ils auront encore la possibilité de revenir sur le sujet lors de l'atelier.

6. Demandez aux stagiaires de vous donner quelques exemples de commentaires pour cette rubrique.

Atelier 2.1 : Création de l'interface utilisateur

Demandez aux stagiaires de répondre aux questions du contrôle des acquis de ce module avant de passer à l'atelier 2.1.

Expliquez aux stagiaires que, dans le cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET, ils auront la possibilité de créer une application complète au cours de plusieurs ateliers. Chaque atelier reprend le code créé au cours du précédent. Au commencement de chaque atelier, les stagiaires peuvent décider de poursuivre avec leurs propres fichiers ou de démarrer avec les fichiers fournis.

L'application que les stagiaires ont à créer est une application de simulation de prêt. Montrez aux stagiaires le résultat escompté des ateliers de scénario en exécutant le code situé dans le dossier dossier_installation\Labfiles\Lab061\ Ex01\Solution.

Au cours de l'atelier 2.1, les stagiaires créeront le formulaire principal de l'application de simulation de prêt.

Module 2 : Utilisation de formulaires et de contrôles ix

Démonstrations Vous pouvez présenter les démonstrations multimédias en exécutant le fichier multimédia fourni avec ce module. Vous pouvez également procéder vous-même à la démonstration en suivant ces instructions.


Présentation multimédia : Gestion des formulaires Dans cette démonstration, vous allez apprendre à gérer plusieurs formulaires dans une application Visual Basic .NET. Vous allez également apprendre à distinguer les formulaires modaux des formulaires non modaux et à masquer ou afficher les formulaires.

! Démarrage de Visual Studio .NET et chargement du projet de démonstration

1. Cliquez sur Démarrer, pointez sur Tous les programmes, puis sur Microsoft Visual Studio .NET et cliquez sur Microsoft Visual Studio .NET.

2. Dans la page de démarrage de Visual Studio, sous l'onglet Démarrer, cliquez sur Ouvrir un projet.

3. Dans la boîte de dialogue Ouvrir un projet, accédez au dossier dossier_installation\Democode\Mod02\ManagingWindows, puis double-cliquez sur ManagingWindows.sln. Cette application contient deux formulaires : Form1 et Form2.

! Ajout de code à Form1 • Sous l'onglet Form1.vb [Design], double-cliquez sur Afficher Form2.

Dans l'Éditeur de code de Form1.vb, entrez les instructions Private Sub Button1_Click et End Sub, tapez le code suivant : Dim form2 As New Form2( ) form2.ShowDialog( )

Le code ajouté crée une instance de Form2 et utilise la méthode ShowDialog pour l'afficher.

! Ajout de code à Form2 1. Dans l'Explorateur de solutions, double-cliquez sur Form2. 2. Sous l'onglet Form2.vb [Design], double-cliquez sur Masquer.

Dans l'Éditeur de code de Form2.vb, entrez les instructions Private Sub Button1_Click et End Sub, tapez le code suivant : Me.Hide( )

Le code ajouté masque cette instance de Form2.

x Module 2 : Utilisation de formulaires et de contrôles

! Exécution de l'application

1. Cliquez sur le bouton Démarrer dans la barre d'outils. 2. Dans la fenêtre Form1, cliquez sur Afficher Form2.

Form2 s'affiche à l'écran. Remarquez qu'il n'est pas possible de revenir à Form1. Form2 est un formulaire modal, ce qui signifie que l'utilisateur doit interagir avec le formulaire pour que l'application puisse poursuivre.

3. Dans Form2, cliquez sur Masquer. Form2 est masqué et le contrôle repasse à Form1.

4. Fermez Form1.

! Transformation de Form2 de formulaire modal en formulaire non modal

1. Cliquez sur l'onglet Form1.vb pour activer l'Éditeur de code. 2. Modifiez form2.ShowDialog( ) en form2.Show( ).


1. Cliquez sur le bouton Démarrer dans la barre d'outils. 2. Dans la fenêtre Form1, cliquez sur Afficher Form2.

Form2 s'affiche à l'écran. Il est dorénavant possible de revenir à Form1. Form2 est un formulaire non modal.

3. Dans Form2, cliquez sur Masquer. 4. Fermez Form1.

! Fermeture de Visual Studio .NET

1. Dans la barre d'outils standard, cliquez sur Enregistrer tout. 2. Dans le menu Fichier, cliquez sur Quitter.

Module 2 : Utilisation de formulaires et de contrôles xi

Présentation multimédia : Événements de formulaire et de contrôle Des événements peuvent se produire à la suite d'une action de l'utilisateur (clic sur un bouton) ou du système (minuterie qui se déclenche à la fin d'une période donnée). Cette démonstration présente quelques-uns des événements de formulaire et de contrôle qui surviennent généralement à la suite d'une action de l'utilisateur.

! Ouverture de Visual Studio .NET et chargement du projet de démonstration


2. Dans la page de démarrage, sous l'onglet Démarrer, cliquez sur Ouvrir un projet.

3. Dans la boîte de dialogue Ouvrir un projet, accédez au dossier dossier_installation\Democode\Mod02\FormControlEvents, puis double-cliquez sur FormControlEvents.sln.

! Examen des événements de formulaire et de contrôle

1. Cliquez sur le bouton Démarrer dans la barre d'outils. Expliquez que la liste Événements, située sur le côté gauche de cette application, affiche les événements générés à partir du formulaire et des contrôles du formulaire. L'événement le plus récent occupe le premier rang de la liste. Remarquez que, dès le démarrage de l'application, les trois événements générés à partir du formulaire s'affichent dans la liste Événements : Resize, Activated et Paint. L'événement le plus récent apparaît en début de liste. L'événement Resize se produit lorsque le formulaire change de taille ; dans ce cas, par exemple, lors de son affichage, le formulaire est passé à sa taille actuelle. L'événement Activated s'est produit car le formulaire est dorénavant la fenêtre active. L'événement Paint s'est produit car Windows a affiché le formulaire.

2. Cliquez sur Button1. Lorsque vous cliquez sur Button1, plusieurs événements se déclenchent. Toutefois, dans le cadre de cette démonstration, seuls les deux premiers événements s'affichent dans la liste Événements. Le premier événement est Enter, ce qui signifie que Button1 est désormais le contrôle actif du formulaire. Le deuxième événement est Click, ce qui signifie que le bouton a été activé.

3. Cliquez sur Button1. En cliquant une nouvelle fois sur Button1, vous ne déclenchez que l'événement Click. L'événement Enter n'est pas déclenché car le contrôle est déjà actif.

xii Module 2 : Utilisation de formulaires et de contrôles

4. Cliquez sur Button2. En cliquant sur Button2, vous commencez par déclencher l'événement Button1 Leave, qui indique que Button1 était actif et qu'il est devenu inactif. Il est important de souligner qu'un clic sur Button2 a déclenché un événement sur un contrôle différent. Le deuxième événement est l'événement Enter pour Button2. Le troisième événement est l'événement Click pour Button2.

5. Cliquez sur Label. En cliquant sur le contrôle Label, vous ne déclenchez qu'un seul événement Click. Dans la mesure où une étiquette ne peut pas devenir un contrôle actif d'un formulaire, Button2 reste le contrôle actif en vigueur. Par conséquent, seul un événement Click pour l'étiquette a été enregistré.

6. Redimensionnez le formulaire. Le redimensionnement du formulaire déclenche consécutivement les événements Resize et Paint lors du redimensionnement et du dessin du formulaire.

7. Cliquez sur Afficher MouseMove. En cliquant sur Afficher MouseMove, vous déclenchez un événement Button2 Leave, puis un événement CheckBox1 Enter et enfin un événement CheckBox1 Click.

8. Déplacez le pointeur de la souris sur le formulaire et ses contrôles. En cliquant sur la case à cocher Afficher MouseMove, vous permettez à l'application d'enregistrer l'événement MouseMove dans la liste Événements. Remarquez que lorsque le curseur passe sur les contrôles du formulaire, l'événement MouseMove est déclenché à partir du contrôle situé sous le pointeur de la souris.

9. Fermez le formulaire. Ces événements sont importants car vous pouvez décider de créer du code pour chacun d'entre eux. Lorsque l'événement survient, le code qui lui est associé s'exécute.

! Fermeture de Visual Studio .NET • Dans le menu Fichier, cliquez sur Quitter.

Module 2 : Utilisation de formulaires et de contrôles 1

Vue d'ensemble

! Compréhension des concepts de programmation

! Utilisation de Windows Forms

! Utilisation des contrôles

! Présentation de votre code

Utilisation de Visual

Studio .NET

Accèsaux données


Écriturede code

Créationd'une

interface


Dans ce module, vous apprendrez ce que sont les classes, les objets, les propriétés, les méthodes et les événements. Vous apprendrez à utiliser des formulaires, des contrôles et du code dans Microsoft® Visual Basic® .NET afin de créer une application. Vous apprendrez les instructions de code à utiliser pour gérer plusieurs formulaires dans une application. Pour finir, vous vous familiariserez avec les conventions d'affectation de noms Visual Basic et apprendrez à mettre en forme et à documenter le code.


! expliquer les concepts fondamentaux de programmation tels que : programmation événementielle, classes, objets, propriétés, méthodes et événements ;

! utiliser des formulaires et des contrôles pour créer une interface utilisateur ; ! créer et gérer plusieurs formulaires dans une seule et unique application ; ! communiquer avec l'utilisateur à l'aide de la fonction MessageBox ; ! respecter les standards Visual Basic pour nommer les éléments que vous

créez ainsi que mettre en forme et documenter le code.

Introduction

Objectifs

2 Module 2 : Utilisation de formulaires et de contrôles

Présentation multimédia : Présentation des objets, propriétés, méthodes et événements


Cette animation vous présente les éléments fondamentaux dont vous allez vous servir dans Visual Basic .NET et que vous allez apprendre à utiliser tout au long de ce module : objets, propriétés, méthodes et événements.

Lorsque vous écrivez des applications dans Microsoft® Visual Basic® .NET, vous travaillez avec des objets, des méthodes, des propriétés et des événements.

Les objets sont les blocs de construction d�une application Visual Basic ; c'est-à-dire les éléments programmables que vous utilisez pour créer l�interface utilisateur. Le formulaire que vous utilisez pour créer une fenêtre, ou le bouton et la zone de texte que vous ajoutez au formulaire, sont des exemples d�objets. Pour interagir avec un objet, vous utilisez des propriétés, des méthodes et des événements. Pour comprendre ce que sont les propriétés, les méthodes et les événements, faites une analogie entre un objet physique (un réveil) et un objet Visual Basic (un formulaire).

Les propriétés sont les caractéristiques d�un objet. Par exemple, les propriétés d�un réveil incluent sa hauteur, sa largeur et sa couleur. Les propriétés du formulaire incluent également sa hauteur, sa largeur et sa couleur.

Les méthodes sont les choses qu�un objet peut faire. Par exemple, un réveil inclut les deux méthodes SetHours et SetMinutes. Les méthodes du formulaire représentent également ce qu'il peut faire, par exemple Hide ou Show.

Les événements sont les actions auxquelles un objet peut répondre. Par exemple, lorsqu�un utilisateur règle l�alarme, le réveil répond à l�événement Alarm en émettant un son. Lorsqu�un utilisateur ferme un formulaire, celui-ci répond à l�événement Closed et exécute le code correspondant à l�événement.

Pour récapituler, les objets sont des éléments programmables. Les propriétés sont des caractéristiques, alors que les méthodes sont des actions. Quant aux événements, ils correspondent aux éléments auxquels un objet peut répondre.

Introduction

Script d'animation


Leçon : Compréhension des concepts de programmation

Programmation

événementielleProgrammation

événementielle

ÉvénementsÉvénements

MéthodesMéthodes

ObjetsObjets

PropriétésPropriétés

ClassesClasses


Cette leçon décrit les concepts de programmation fondamentaux qu'il vous faut bien comprendre avant d'écrire du code en Visual Basic .NET.

Cette leçon aborde les points suivants :

! Présentation de la programmation événementielle ! Classes : Modèles servant à la création des objets ! Présentation des propriétés, des méthodes et des événements ! Application pratique : Propriétés, méthodes et événements


! expliquer la différence entre la programmation événementielle et la programmation procédurale ;

! faire la distinction entre les objets et les classes ; ! décrire les propriétés, les méthodes et les événements.

Introduction




Présentation de la programmation événementielle

Sub Button1_Click (�)

'insérer le code de'l'événement

End Sub

Sub Button1_Click (�)

'insérer le code de'l'événement

End Sub


Les applications écrites en Visual Basic sont événementielles. Pour bien comprendre ce qu'est la programmation événementielle, il faut l'opposer à la programmation procédurale.

Les applications écrites en langage procédural s'exécute en avançant logiquement, ligne après ligne, dans le code du programme. Le flux logique peut être temporairement transféré à d'autres parties du programme au moyen de diverses instructions de code, dirigeant le programme du début à la fin.

Dans un programme procédural, le programme principal contrôle la façon dont l'utilisateur entre les informations.

Introduction

Programation procédurale

Exemple de programmation procédurale


Dans une application événementielle, les instructions du programme ne s'exécutent que lorsqu'un événement spécifique appelle une section de code associée à cet événement. Les événements peuvent être déclenchés par une touche du clavier, une action de la souris, le système d'exploitation ou le code de l'application. Un programme événementiel évalue constamment des ensembles d'événements et y répond. Si un événement se produit et que la procédure d'événement associée contient du code, Visual Basic appelle ce code.

Examinez ce qui se passe lorsqu'un utilisateur clique sur un bouton, appelé Button1, dans un formulaire. Le clic de la souris est un événement. Lorsque l'événement Click se produit, Visual Basic exécute le code de la procédure Sub appelée Button1_Click. Une fois le code exécuté, Visual Basic attend le prochain événement.

Cet exemple a pour but de vous familiariser avec le concept de base utilisé en cas de programmation événementielle. Ne vous préoccupez pas de la syntaxe proprement dite du code, pour l'instant.

Programmation événementielle

Exemple de programmation événementielle

Remarque


Classes : Modèles servant à la création des objets

Une instance d'une classe

Analogie : une maisonconçue à partir du plan

Une instance d'une classe

Analogie : une maisonconçue à partir du plan

ObjetObjetObjet

Chaque formulaire d'un projet Visual Basic est un objet distinct Chaque formulaire est une instance de la classe Form

Chaque formulaire d'un projet Visual Basic est un objet distinct Chaque formulaire est une instance de la classe Form

ExempleExempleExemple

Une représentationsymbolique d'un objet

Analogie : un plan

Une représentationsymbolique d'un objet

Analogie : un plan

ClasseClasseClasse


Les termes classe et objet sont parfois utilisés l'un pour l'autre mais, en fait, les classes décrivent la structure des objets, alors que les objets sont les instances des classes. Les classes et les objets sont étroitement liés. Il est impossible d'étudier un objet sans faire référence à sa classe.

Une classe est une représentation symbolique d'un objet. Une classe décrit les attributs et les opérations qui caractérisent tous les membres (ou objets) de la classe. Elle peut être assimilée au plan d'une maison qui décrit les éléments dont se compose la maison (portes, fenêtres et murs).

Un objet est une instance d'une classe. La classe vous sert de modèle pour créer plusieurs objets individuels de même que le plan d'une maison permet de construire plusieurs maisons individuelles. Chaque objet est une copie exacte, bien que distincte, de sa classe.

Puisqu'un objet est une instance d'une classe, la création d'un objet porte le nom d'instanciation.

Dans Visual Basic, la classe Form définit les formulaires comme étant rectangulaires, possédant une légende, ayant la possibilité d'être sélectionné, etc. Chaque formulaire que vous utilisez dans un projet Visual Basic est un objet distinct-une instance de la classe Form.

Les contrôles de la boîte à outils de Visual Basic .NET représentent également des classes. Lorsque vous faites glisser un contrôle Button de la boîte à outils vers un formulaire, vous créez en fait une instance de la classe Button-un objet Button.

Introduction

Définitions

Exemples Visual Basic


Présentation des propriétés, des méthodes et des événements

Form1

PropriétésPropriétésPropriétés SizeTextSizeText

MéthodesMéthodesMéthodes CloseHide

CloseHide

ÉvénementsÉÉvénementsvénements ClickClick

VolumeBassesVolumeBasses

Rechercher unestation

Rechercher unestation

Niveau de pile faibleNiveau de pile faible


Les classes décrivent les propriétés, les méthodes et les événements qui constituent les objets, membres de la classe. Pour contrôler un objet, vous utilisez des propriétés, des méthodes et des événements.

Les propriétés sont les caractéristiques d'un objet telles que taille, couleur et texte.

Les méthodes sont les actions qu'un objet peut accomplir. Close et Hide sont des exemples de méthode très courants pour un formulaire.

Les événements sont des actions, très souvent générées par un utilisateur, qui sont reconnues par un objet, par exemple : activation d'une touche, clic sur un bouton ou mouvement de la souris. Chaque formulaire ou contrôle dispose d'un ensemble d'événements particulier qu'il reconnaît. Les événements sont déclenchés lorsque certains aspects de l'objet changent. Par exemple, lorsqu'un utilisateur clique sur une souris, l'événement Click se déclenche.

Pour bien comprendre la relation qu'entretiennent les objets, les propriétés et les méthodes, prenons l'exemple d'un poste de radio stéréo. La radio est un objet et possède un certain nombre de propriétés telles que volume, basses et aigus. Le volume de la radio est une propriété que vous pouvez modifier. Vous pouvez également changer de station, une autre propriété, en utilisant la méthode « rechercher une station » de la radio.

Chacune de ces propriétés et de ces méthodes a une fin bien précise et permet d'atteindre un but ou un objectif donné : rechercher une station, par exemple. En tant que propriétaire de la radio, vous apprenez à utiliser ces objets mais, dans la plupart des cas, vous n'apprenez ni à les installer, ni à les entretenir, ni à les réparer. Il vous suffit de savoir comment les faire fonctionner et ce que vous voulez obtenir.

De même, avec Visual Basic, vous pouvez utiliser des objets-formulaires et contrôles-pour créer des applications. Dans la majorité des cas, vous pouvez vous servir des objets sans avoir une connaissance approfondie de leur fonctionnement.

Introduction

Propriétés

Méthodes

Événements

Comparaison avec un objet physique


Application pratique : Propriétés, méthodes et événements

! Porte

! Voiture

! Exemple : Téléphone

" Propriétés : Largeur, Couleur, Volume

" Méthodes : Sonner, RéglerVolume

" Événements : RéglageVolume, FinNumérotation

Associez à chacun des objets suivants les propriétés, les méthodes et les événementsappropriés :


Associez à chacun des objets suivants les propriétés, les méthodes et les événements appropriés.

Objet Propriétés Méthodes Événements

Exemple Téléphone

Largeur, Couleur, Volume

Sonner, RéglerVolume

RéglageVolume, FinNumérotation (en réponse à une numérotation de l'utilisateur)

Porte Hauteur, Largeur, Matériau

Ouvrir, Fermer Fermeture, Ouverture

Voiture Couleur, Modèle, Année Arrêter, MettreContact AppuiPédaleFrein, ActivationCléContact


Leçon : Utilisation de Windows Forms

! Création d'un formulaire

! Définition des propriétés d'un formulaire

! Appel des méthodes

! Gestion des événements de formulaire

! Formulaires modaux et non modaux

! Gestion de plusieurs formulaires


Pour créer une application Microsoft Windows®, il faut commencer par créer un formulaire. Dans cette leçon, vous apprendrez à créer un formulaire, définir ses propriétés, appeler les méthodes appropriées et écrire le code voulu pour gérer les événements du formulaire. Vous apprendrez aussi à travailler avec plusieurs formulaires et, notamment, à afficher, à masquer et à fermer des formulaires modaux et non modaux.


! Création d'un formulaire ! Définition des propriétés d'un formulaire ! Appel des méthodes ! Gestion des événements de formulaire ! Application pratique : Création du code associé aux événements de

formulaire ! Démonstration multimédia : Gestion des formulaires ! Formulaires modaux et non modaux ! Gestion de plusieurs formulaires


! ajouter des formulaires à un projet ; ! définir les propriétés du formulaire lors de la conception ; ! appeler des méthodes ; ! créer le code associé à des événements de formulaire ; ! définir un formulaire comme modal ou non modal ; ! masquer, afficher et fermer les formulaires.

Introduction




Création d'un formulaire


Dans Visual Basic, un formulaire est une fenêtre utilisée dans votre application. Lorsque vous créez un nouveau projet d'application Windows, Visual Basic vous fournit une fenêtre de conception où figure un formulaire. Le formulaire par défaut contient les éléments minimums utilisés dans la plupart des formulaires : une barre de titre, une case système et des boutons Réduire, Agrandir et Fermer.

Les applications requièrent généralement plusieurs fenêtres. Il faut ajouter un formulaire à votre projet pour chaque fenêtre que réclame votre application.

! Pour ajouter des formulaires à votre projet 1. Si l'Explorateur de solutions n'est pas ouvert, dans le menu Affichage,

cliquez sur Explorateur de solutions. 2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du

projet, pointez sur Ajouter et cliquez sur Ajouter un formulaire Windows.

3. Dans la boîte de dialogue Ajouter un nouvel élément, donnez un nom approprié au formulaire, puis cliquez sur Ouvrir.

Introduction

Ajout de formulaires


Définition des propriétés d'un formulaire

! Si vous modifiez la propriété Name de Form1, vous devez aussidonner le nouveau nom à l'objet de démarrage de votre projet

Nom de l'objetNom de l'objet

Bouton AlphabétiqueBouton Alphabétique

Bouton Par catégorieBouton Par catégorie

Volet DescriptionVolet Description


Lors de la création de l'interface utilisateur d'une application Visual Basic, vous devez définir les propriétés des objets que vous créez.

Vous pouvez définir les propriétés de formulaire soit en écrivant du code, soit en utilisant la fenêtre Propriétés. Tous les paramètres définis au moment de la conception-lorsque vous créez l'application-servent de paramètres initiaux à chaque nouvelle exécution de votre application.

! Pour définir les propriétés de formulaire lors de la conception. 1. Si la fenêtre Propriétés n'est pas ouverte, dans le menu Affichage, cliquez

sur Fenêtre Propriétés. 2. Dans la vue Conception, cliquez sur le formulaire dont vous voulez définir

une propriété. Le nom du formulaire apparaît dans la liste déroulante Objet en haut de la fenêtre Propriétés.

3. Utilisez les boutons Alphabétique et Par catégorie de la fenêtre Propriétés pour afficher les propriétés du formulaire dans l'ordre alphabétique ou par catégorie.

4. Dans la fenêtre Propriétés, cliquez sur la propriété que vous souhaitez définir.

Lorsque vous cliquez sur une propriété, sa description s'affiche au bas de la fenêtre Propriétés, dans le volet Description.

5. Tapez ou sélectionnez la valeur que vous voulez donner à la propriété. 6. Pour voir l'impact du nouveau paramètre sur le formulaire, vous pouvez

exécuter votre application en cliquant sur le bouton Démarrer dans la barre d'outils standard.

Introduction

Définition des propriétés de formulaire

Remarque


Le tableau suivant décrit certaines des propriétés de formulaire les plus généralement définies lors de la conception.

Propriété Description Paramètre par défaut

(Name) Définit le nom du formulaire dans votre projet. (Il ne s'agit pas du nom que les utilisateurs voient apparaître dans la barre de légende.)

Important : Si vous modifiez la propriété Name de Form1, vous devez aussi donner le nouveau nom à l'objet de démarrage de votre projet, sinon le projet ne démarrera pas correctement.

Form1 (Form2, Form3, etc.)

AcceptButton Définit le bouton « sélectionné » chaque fois qu'un utilisateur appuie sur la touche ENTRÉE.

Remarque : Un bouton au moins de votre formulaire doit utiliser cette propriété.

(Aucun)

CancelButton Définit le bouton « sélectionné » chaque fois qu'un utilisateur appuie sur la touche ÉCHAP.

Remarque : Un bouton au moins de votre formulaire doit utiliser cette propriété.

(Aucun)

ControlBox Détermine si un formulaire affiche une case système dans la barre de légende.

True

FormBorderStyle Contrôle l'apparence de la bordure du formulaire. Cette propriété influe également sur l'apparence de la barre de légende et sur les boutons à y afficher.

Sizable

MaximizeBox Détermine si un bouton Agrandir apparaît dans le coin supérieur droit de la barre de légende du formulaire.

True

MinimizeBox Détermine si un bouton Réduire apparaît dans le coin supérieur droit de la barre de légende du formulaire.

True

StartPosition Détermine la place à laquelle le formulaire apparaît la première fois à l'écran.

WindowsDefaultLocation

Text Définit le texte affiché dans la barre de légende du contrôle.

Form1 (Form2, Form3, etc.)

Lorsque vous démarrez un nouveau projet, Visual Basic considère que Form1 est l'objet de démarrage par défaut de votre projet. Si vous modifiez la propriété Name de Form1, vous devez aussi donner le même nom à l'objet de démarrage de votre projet, sinon le projet ne démarrera pas correctement.

! Pour modifier l'objet de démarrage de votre projet 1. Si l'Explorateur de solutions n'est pas ouvert, dans le menu Affichage,

cliquez sur Explorateur de solutions. 2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du

projet, puis cliquez sur Propriétés. 3. Dans la zone Objet de démarrage, cliquez sur le nouvel objet de

démarrage de votre projet.

Propriétés de formulaires courantes

Modification de l'objet de démarrage


Dans cette application pratique facultative, vous modifierez deux propriétés du formulaire et étudierez leur impact sur le formulaire. Cette application pratique ne doit pas prendre plus de 10 minutes.

! Définition des propriétés de formulaire 1. Ouvrez une nouvelle application Windows dans Visual Basic .NET.

Créez un nouveau projet nommé FormProperties dans dossier_installation\Practices\Mod02.

2. Ouvrez la fenêtre Propriétés de Form1. 3. Donnez une nouvelle valeur à la propriété Cursor. 4. Exécutez l'application et laissez le pointeur de la souris sur le formulaire

pour constater l'impact de la modification. 5. Revenez en mode conception en quittant l'application. Pour quitter

l'application, vous pouvez cliquer sur la case Fermer du formulaire. 6. Cliquez sur la propriété Opacity de Form1, puis tapez une valeur comprise

entre 10 et 90 %. 7. Exécutez l'application pour constater l'impact de la modification. 8. Revenez en mode conception en quittant l'application.

Application pratique (facultative)


Appel des méthodes

Sub Form1_ClickMe.CenterToScreen( )

End Sub

Sub Form1_ClickMe.CenterToScreen( )

End Sub

MéthodesMéthodes


Les formulaires proposent des méthodes uniques, ou actions, qu'ils peuvent accomplir. Vous appelez une méthode d'un formulaire pour demander au formulaire de réaliser une action.

Le tableau suivant répertorie les méthodes de formulaire que vous serez le plus souvent amené à utiliser.

Méthode Description

CenterToScreen Place automatiquement le formulaire au centre de l'écran lors de son ouverture.

Close Ferme le formulaire.

Hide Rend invisible le formulaire, mais le conserve en mémoire.

Show Rend le formulaire visible.

Utilisez la syntaxe suivante pour appeler une méthode d'un formulaire dans le code du formulaire :

Me.Méthode( )

! « Me » fait référence à l'instance du formulaire. ! Méthode est la méthode de formulaire que vous appelez. ! Vous devez utiliser les parenthèses ( ) dans ce code. Les parenthèses

peuvent servir à transmettre des informations supplémentaires, appelées paramètres, dans le programme.

Le code suivant permet d'afficher le formulaire au centre de l'écran grâce à la méthode CenterToScreen du formulaire :

Me.CenterToScreen( )

Introduction

Méthodes de formulaire courantes

Syntaxe

Exemple d'appel d'une méthode


Visual Basic .NET dispose d'une fonction appelée Microsoft IntelliSense®, qui permet d'afficher, dans des fenêtres indépendantes et des listes déroulantes, toutes les informations en rapport avec un langage. Vous pouvez faire appel à IntelliSense pour consulter et sélectionner les propriétés, méthodes et événements disponibles des objets.

! Pour utiliser IntelliSense afin de consulter et de sélectionner les méthodes de formulaire disponibles

1. Double-cliquez sur le formulaire dans la fenêtre de conception. Ce faisant, vous ouvrez l'Éditeur de code et définissez le point d'insertion dans un bloc de code. Dans cet exemple, vous utiliserez IntelliSense pour écrire le code associé à l'événement Form1_Load.

2. Tapez Me Dès que vous aurez tapé le point, IntelliSense affichera une liste des propriétés et des méthodes disponibles pour le formulaire.

L'icône représente une méthode.

L'icône représente une propriété.

3. Double-cliquez sur la méthode que vous souhaitez appeler. La méthode que vous choisissez s'affiche dans votre code et la fenêtre IntelliSense disparaît de l'écran.

Utilisation de MS IntelliSense


Gestion des événements de formulaire

ÉvénementsÉvénements

Zone de listeNom de la classe

Zone de listeNom de la classe


Pour répondre aux actions réalisées sur un objet, vous écrivez le code voulu dans le gestionnaire d'événements, ou bloc de code, associé à l'événement de l'objet. Ce code s'exécute dès que l'événement survient.

Le tableau suivant répertorie les événements de formulaire pour lesquels vous serez le plus souvent amené à écrire du code.

Événement Description

Activated Se produit lorsque le formulaire est activé par du code ou un utilisateur.

Click Se produit lorsque le formulaire est sélectionné.

Closed Se produit lorsqu'un utilisateur ferme le formulaire ou en réponse à la méthode Close.

Closing Se produit au moment de la fermeture du formulaire.

(Précède généralement l'événement Closed.)

Deactivate Se produit lorsque le formulaire perd le focus et qu'il n'est plus le formulaire actif.

GotFocus Se produit lorsque le formulaire reçoit le focus.

Load Se produit lors de la première apparition d'un formulaire.

Introduction

Événements de formulaires courants


Un gestionnaire d'événements est un segment de code appelé lors du déclenchement de l'événement correspondant. Vous pouvez, par exemple, écrire du code dans un gestionnaire d'événements pour l'événement Activated d'un formulaire afin de procéder à certaines opérations telles que mise à jour des données affichées dans les contrôles du formulaire lors de l'activation de ce dernier. Les gestionnaires d'événements sont une procédure de type Sub.

Les événements de formulaire se produisent dans un ordre particulier. Par exemple, l'événement Load précède toujours l'événement Activated. Il est important de connaître cet ordre car l'ordre des événements influe sur l'ordre d'exécution de votre code.

Visual Basic applique des conventions d'affectation de noms standard pour les gestionnaires d'événements. Par convention, il convient d'utiliser le nom de l'objet qui envoie l'événement, un souligné et le nom de l'événement. Par exemple, l'événement Click d'un formulaire nommé Form1 serait Sub Form1_Click.

! Pour ajouter un gestionnaire d'événements 1. Ouvrez l'Éditeur de code du formulaire pour lequel vous voulez ajouter un

gestionnaire d'événements. 2. Dans la zone de liste Nom de la classe, cliquez sur (Événements de la

classe de base). L'illustration suivante montre la zone de liste Nom de la classe où (Événements de la classe de base) est sélectionné.

Gestionnaires d'événements

Remarque

Ajout d'un gestionnaire d'événements


3. Cliquez sur la flèche de la zone déroulante Nom de la méthode afin d'afficher les événements disponibles pour le formulaire. L'illustration suivante montre la zone de liste Nom de la méthode où sont répertoriés les événements du formulaire et où l'événement Click est sélectionné. L'icône éclair en regard du nom de l'événement indique qu'il s'agit d'un événement.

4. Cliquez sur l'événement pour ajouter un gestionnaire d'événements.


Application pratique : Création du code associé à des événements de formulaire

Ouvrez une nouvelle application Windows dansVisual Basic .NET

Ouvrez l'Éditeur de code correspondant à ce formulaire

Ajoutez du code au gestionnaire d'événements

Créez le gestionnaire d'événementForm1_Click

Exécutez l'application et testez votre code


Dans cette application pratique, vous allez écrire le code à associer à l'événement Click d'un formulaire. Lors de la sélection du formulaire, un bip sonore retentira et le formulaire se fermera.

! Écriture du code associé au gestionnaire d'événements Click 1. Ouvrez une nouvelle application Windows dans Visual Basic .NET. Créez

un projet nommé WritingCode dans dossier_installation\Practices\Mod02. 2. Ouvrez l'Éditeur de code correspondant à ce formulaire. 3. Créez le gestionnaire d'événements Form1_Click en cliquant sur

(Événements de la classe de base) dans la zone de liste Nom de la classe et en cliquant sur Click dans la zone de liste Nom de la méthode.

4. Dans le gestionnaire d'événements, tapez le code suivant : Beep( ) Me.Close( )

Ce code provoque l'émission d'un bip sonore, puis ferme le formulaire en appelant la méthode Close du formulaire.

5. Exécutez votre application en cliquant sur le bouton Démarrer dans la barre d'outils standard.

6. Cliquez sur le formulaire pour vérifier le bon fonctionnement du code.


Présentation multimédia : Gestion des formulaires


Dans cette démonstration, vous allez apprendre à différencier un formulaire modal d'un formulaire non modal. Vous apprendrez aussi à gérer plusieurs formulaires, à déterminer les formulaires que l'utilisateur voit et à identifier les formulaires ouverts ou fermés à l'aide des méthodes Show, Hide et Close du formulaire.


Formulaires modaux et non modaux

Formulaire modal

Enregistrer les fichiersavant de quitter ?

Formulaire principal

Oui Non


Si votre application se compose de plusieurs formulaires, vous devez savoir s'il faut utiliser des formulaires modaux ou non modaux.

Les formulaires non modaux permettent à l'utilisateur de passer à un autre formulaire ou à une autre boîte de dialogue sans aucune interaction avec le formulaire non modal. Si vous avez, par exemple, plusieurs fenêtres non modales ouvertes, vous pouvez déplacer une fenêtre et dialoguer avec une autre sans fermer la première.

Les formulaires modaux ne laissent pas l'utilisateur interagir avec d'autres formulaires de l'application tant que le formulaire modal n'a pas été déchargé. Le programme doit masquer ou fermer un formulaire modal (généralement en réponse à une action de l'utilisateur) avant qu'une saisie dans un autre formulaire puisse avoir lieu. Par exemple, un message est de type modal. L'utilisateur doit y répondre avant de pouvoir interagir avec les autres formulaires de l'application.

Par défaut, les formulaires que vous créez dans Visual Basic .NET sont non modaux. Pour rendre un formulaire modal, appelez la méthode ShowDialog du formulaire.

Introduction

Formulaires non modaux

Formulaires modaux


Les interactions modales obligent les utilisateurs à terminer une tâche avant de passer à une autre. Les interactions non modales permettent aux utilisateurs de passer librement d'une tâche à l'autre sans achever obligatoirement l'une d'entre elles.

Bien qu'il soit de temps en temps préférable de restreindre le contrôle de l'utilisateur, mieux vaut, en règle générale, que vos applications n'aient que peu d'interactions modales. Les longs processus doivent s'exécuter en arrière-plan de façon à laisser un entière liberté à l'avant-plan. Par exemple, en cas d'impression, les utilisateurs doivent pouvoir réduire la fenêtre même s'il est impossible de modifier le document.

L'interaction modale enlève tout contrôle à l'utilisateur. L'interaction non modale lui redonne la main. Concevez vos logiciels afin de donner à l'utilisateur un contrôle maximal en minimisant les interactions modales.

Point de vue de l'utilisateur


Gestion de plusieurs formulaires

Form1

Form2Form2

Ouvrir

Fermer


Dans la plupart des applications, l'interface utilisateur se compose de plusieurs fenêtres ou boîtes de dialogue. Pour afficher ou masquer les formulaires, vous devez utiliser les méthodes Show ou Hide du formulaire. Pour fermer un formulaire, utilisez la méthode Close.

La méthode Show affiche un objet formulaire. Si vous voulez utiliser la méthode Show pour afficher un deuxième formulaire à partir d'un formulaire existant ouvert, utilisez la syntaxe suivante :

NomFormulaire.Show( )

Une instance du formulaire NomFormulaire doit exister pour pouvoir appeler la méthode Show du formulaire.

La méthode Hide rend un objet formulaire invisible, mais ne le ferme pas pour autant. Autrement dit, le formulaire disparaît, mais tous les objets et variables qu'il contient restent chargés en mémoire.

Si vous voulez utiliser la méthode Hide pour masquer un deuxième formulaire à partir d'un formulaire existant ouvert, utilisez la syntaxe suivante :

NomFormulaire.Hide( )

Pour masquer le formulaire en cours d'exécution, utilisez le mot clé Me pour appeler la méthode Hide du formulaire.

Me.Hide( )

Introduction

Syntaxe à utiliser pour afficher les formulaires

Remarque

Syntaxe à utiliser pour masquer les formulaires


Prenons le cas où l'utilisateur clique sur un bouton d'un premier formulaire pour afficher un deuxième formulaire dans l'application. Lors de l'ouverture du deuxième formulaire, l'utilisateur n'a plus besoin du premier ; vous voulez donc le faire disparaître. Toutefois, puisque vous avez besoin d'accéder aux variables et aux éléments qui s'y trouvent, vous ne voulez pas le fermer.

Pour mettre ce scénario en �uvre, vous devez ajouter un bouton au premier formulaire et associer le code suivant à l'événement Click du bouton :

Sub OpenButton_Click(...) ' Ce code s'exécute lorsque l'utilisateur clique sur un ' bouton appelé OpenButton. Dim CalculationForm as new Form2( ) CalculationForm.Show( ) ' Déclare une instance du deuxième formulaire, puis ' appelle la méthode Show du deuxième formulaire. Ainsi, ' le deuxième formulaire devient visible. Me.Hide ' Appelle la méthode Hide du formulaire actif. Ainsi, ' le formulaire actif devient invisible. End Sub ' Fin de ce bloc de code.

Dans l'exemple précédent, la méthode Hide masque le premier formulaire au lieu de le fermer.

La méthode Close ferme un objet formulaire. Lorsque vous fermez un formulaire, toutes les ressources qui s'y trouvent sont fermées et le formulaire est supprimé. Si vous voulez utiliser la méthode Close pour fermer un deuxième formulaire à partir d'un formulaire existant ouvert, utilisez la syntaxe suivante :

NomFormulaire.Close( )

Pour fermer le formulaire en cours d'exécution, utilisez le mot clé Me pour appeler la méthode Close à partir du formulaire actif, comme le montre l'exemple suivant :

Me.Close( )

Les applications à interface multidocument (MDI) vous permettent d'afficher plusieurs documents en même temps ; chaque document étant affiché dans sa propre fenêtre. Les applications MDI disposent souvent d'un menu Fenêtre et de commandes qui permettent de passer d'une fenêtre ou d'un document à l'autre. Ce sujet ne fait pas l'objet de ce cours. Pour plus d'informations sur le développement de Windows Forms dans Visual Basic .NET, consultez le cours 2565 (en anglais), Developing Microsoft .NET Applications for Windows (Visual Basic .NET).

Exemple

Important

Syntaxe à utiliser pour fermer les formulaires

Remarque


Leçon : Utilisation des contrôles

! Ajout de contrôles à un formulaire

! Définition des propriétés d'un contrôle

! Association de code à des événements de contrôle

! Utilisation de la fonction MessageBox


Dans cette leçon, vous apprendrez à créer une interface utilisateur et, notamment, à ajouter des contrôles à un formulaire, à définir les propriétés de ces contrôles et à écrire le code associé aux événements des contrôles. Vous apprendrez également à créer des messages pour dialoguer avec l'utilisateur.


! Ajout de contrôles à un formulaire ! Définition des propriétés d'un contrôle ! Démonstration multimédia : Événements de formulaire et de contrôle ! Association de code à des événements de contrôle ! Utilisation de la fonction MessageBox ! Application pratique : Création d'un message


! ajouter des contrôles à un formulaire ; ! définir les propriétés des contrôles ; ! associer du code à des événements de contrôle ; ! utiliser un message pour dialoguer avec les utilisateurs.

Introduction






Presque toutes les applications que vous écrivez en Visual Basic utilisent des contrôles sur un formulaire. Les contrôles sont des objets contenus au sein des objets formulaires. Les boutons, lez zones de texte et les étiquettes en sont de parfaits exemples.

Le tableau suivant présente les quatre contrôles les plus complexes que vous utiliserez le plus fréquemment.

Contrôle Description

ComboBox Vous permet d'afficher et de suggérer une liste de propositions à un utilisateur. Les zones de liste déroulantes font gagner de la place sur un formulaire puisqu'elles peuvent s'afficher dans un menu déroulant.

GroupBox Vous permet de regrouper d'autres contrôles dans une sous-division du formulaire. Vous pouvez, par exemple, utiliser une zone de regroupement pour regrouper plusieurs cases d'option.

PictureBox Vous permet d'afficher un graphique dans votre formulaire au format bitmap, Graphics Interchange Format (GIF), Joint Photographic Experts Group (JPEG), métafichier ou icône.

RadioButton Permet aux utilisateurs de sélectionner un élément dans une liste prédéfinie courte.

Bien que vous ajoutiez les cases d'option l'une après l'autre, vous en utilisez souvent plusieurs à la fois. En cas de regroupement, il n'est possible de cocher qu'une seule case d'option à la fois.

Introduction

Contrôles de base


Il existe deux manières d'ajouter des contrôles à un formulaire. La première vous permet d'ajouter plusieurs contrôles rapidement, puis de les dimensionner et de les positionner un par un. La deuxième vous permet de contrôler, dès le départ, la taille et la position du contrôle.

! Pour ajouter des contrôles à un formulaire, puis les dimensionner et les positionner

1. Si la boîte à outils n'est pas ouverte, dans le menu Affichage, cliquez sur Boîte à outils.

2. Double-cliquez sur l'icône Boîte à outils du contrôle que vous voulez ajouter. De cette façon, vous placez une instance du contrôle, à la taille par défaut, dans le coin supérieur gauche de l'objet actif. Lorsque vous ajoutez plusieurs contrôles de cette manière, ils se retrouvent tous les uns sur les autres.

3. Une fois les contrôles ajoutés, vous pouvez les repositionner et les redimensionner. a. Pour repositionner le contrôle, cliquez dessus pour le sélectionner, puis

faites-le glisser à l'emplacement voulu. b. Pour redimensionner le contrôle, cliquez dessus pour le sélectionner,

faites glisser l'une des huit poignées de dimensionnement jusqu'à ce que le contrôle atteigne la taille voulue, puis relâchez le bouton de la souris.

! Pour dimensionner et positionner les contrôles lors de leur ajout au formulaire

1. Si la boîte à outils n'est pas ouverte, dans le menu Affichage, cliquez sur Boîte à outils.

2. Cliquez sur l'icône Boîte à outils du contrôle que vous voulez ajouter. 3. Déplacez le pointeur de la souris sur le formulaire. Le pointeur se

transforme en réticule. 4. Placez le réticule à l'endroit où vous voulez que se trouve le coin supérieur

gauche du contrôle. 5. Cliquez et faites glisser le réticule vers le coin inférieur droit. Un rectangle

se dessine à l'écran, représentant la taille et l'emplacement du contrôle. 6. Lorsque le contrôle a la taille voulue, relâchez le bouton de la souris. Le

contrôle correctement dimensionné apparaît à l'emplacement que vous avez choisi sur le formulaire.

7. Vous pouvez ensuite repositionner ou redimensionner le contrôle après avoir relâché le bouton de la souris. a. Pour repositionner le contrôle, cliquez dessus pour le sélectionner, puis

faites-le glisser à l'emplacement voulu. b. Pour redimensionner le contrôle, cliquez dessus pour le sélectionner,

faites glisser l'une des huit poignées de dimensionnement jusqu'à ce que le contrôle atteigne la taille voulue, puis relâchez le bouton de la souris.



Définition des propriétés d'un contrôle

! Vous pouvez choisir la même valeur de propriété pour plusieurs contrôles à la fois

! Définissez les propriétés de contrôles individuels pour faciliter l'accessibilité de l'application


Les contrôles graphiques possèdent généralement des propriétés modifiables qui permettent de changer leur apparence. Les contrôles ont des propriétés qui indiquent la façon dont ils vont interagir avec l'utilisateur. Vous pouvez aussi utiliser les propriétés des contrôles pour rendre vos applications plus accessibles aux personnes handicapées.

! Pour définir les propriétés des contrôles à l'aide de la fenêtre Propriétés 1. Si la fenêtre Propriétés n'est pas ouverte, dans le menu Affichage, cliquez

sur Fenêtre Propriétés. 2. Choisissez le contrôle dont vous voulez définir une propriété.

Pour ce faire, vous pouvez cliquer directement sur le contrôle ou cliquer sur le nom du contrôle dans la liste déroulante Objet située en haut de la fenêtre Propriétés.

3. Choisissez si vous voulez afficher les propriétés des contrôles par ordre

alphabétique ou par catégorie en utilisant les boutons Alphabétique

ou Par catégorie de la fenêtre Propriétés. 4. Dans la fenêtre Propriétés, cliquez sur la propriété que vous souhaitez

définir.

Lorsque vous cliquez sur une propriété, sa description s'affiche dans le volet Description, au bas de la fenêtre Propriétés.

5. Tapez ou sélectionnez la valeur que vous voulez donner à la propriété.

Introduction


Remarque


Vous pouvez également choisir la même valeur de propriété pour plusieurs contrôles à la fois. Par exemple, si vous souhaitez que plusieurs contrôles utilisent la même police, vous pouvez définir simultanément la propriété Font pour tous les contrôles.

! Pour définir une seule valeur de propriété pour plusieurs contrôles 1. Sélectionnez le premier contrôle dans le groupe de contrôles que vous

voulez modifier. 2. Maintenez la touche CTRL enfoncée pendant que vous sélectionnez les

autres contrôles à modifier. Notez que la fenêtre Propriétés n'affichent que les propriétés communes à tous les contrôles sélectionnés.

3. Dans la fenêtre Propriétés, donnez à la propriété la valeur voulue. Tous les changements apportés à une propriété s'appliquent à l'ensemble des contrôles sélectionnés.

Lors de la création d'un contrôle, Visual Basic lui affecte un nom par défaut indiquant le type de contrôle dont il s'agit, puis fait suivre ce nom d'un nombre entier. Par exemple, le premier nouvel objet Button sera Button1, le deuxième Button2, etc. Vous avez tout intérêt à donner à la propriété Name de chaque contrôle un nom qui identifie le but de l'objet.

La propriété Name d'un contrôle doit commencer par une lettre et peut se composer de chiffres et du caractère souligné (_), mais elle ne peut contenir ni signe de ponctuation, ni espace.

Le tableau suivant répertorie les principales propriétés des contrôles ComboBox, GroupBox, PictureBox et RadioButton.

Contrôle Propriété Description de la propriété

ComboBox Items Répertorie les éléments qui figurent dans la zone de liste déroulante.

GroupBox Text Définit la légende de la zone de regroupement.

PictureBox Background Image Définit l'image d'arrière-plan à utiliser pour le contrôle.

Image Identifie l'image affichée dans le contrôle.

RadioButton CheckAlign Détermine l'emplacement de la case à cocher par rapport au texte du contrôle.

Checked Indique si l'élément est coché ou non lors de la première exécution du programme.

L'accessibilité a des impacts commerciaux importants pour les développeurs de logiciels. Bon nombre de gouvernements imposent des règles en la matière pour l'achat de logiciels. Près de 30 millions de résidants, aux États-Unis uniquement, sont concernés par des problèmes d'accessibilité des logiciels.

Définition des propriétés pour plusieurs contrôles

Propriétés de contrôle courantes

Remarque

Prise en charge des options d'accessibilité


Les contrôles de la boîte à outils standard de Windows Forms prennent en charge pas mal d'options d'accessibilité. De plus, le tableau suivant répertorie les propriétés de contrôles individuels pouvant faciliter l'accessibilité de l'application.

Propriété du contrôle Options d'accessibilité

AccessibleDescription Contient une description associée à un outil d'accessibilité. Les outils d'accessibilité sont des programmes ou des périphériques spéciaux, tels que lecteurs d'écran, qui aident les personnes souffrant d'un handicap à utiliser plus facilement l'ordinateur.

AccessibleName Contient le nom associé à un outil d'accessibilité.

AccessibleRole Décrit le rôle de l'élément dans l'interface utilisateur.

TabIndex Crée un chemin de navigation facile dans le formulaire.

Il est important que, pour les contrôles sans étiquette intrinsèque (zones de texte, par exemple), les étiquettes les précèdent dans l'ordre de tabulation.

Text Utilise le caractère « & » pour créer des touches d'accès rapide.

Par exemple, si vous définissez &Ouvrir comme la propriété texte d'un bouton, le nom du bouton s'affiche sous la forme Ouvrir, la lettre O étant la touche d'accès rapide.

Font Size Si la taille de la police n'est pas ajustable, elle doit être de 10 points au minimum. Une fois la taille de police du formulaire définie, tous les contrôles ajoutés au formulaire auront la même taille.

ForeColor Si cette propriété est définie par défaut, c'est la couleur préférée de l'utilisateur qui sera utilisée sur le formulaire.

BackColor Si cette propriété est définie par défaut, c'est la couleur préférée de l'utilisateur qui sera utilisée sur le formulaire.

BackgroundImage Laissez cette propriété vide pour faciliter la lisibilité du texte.

Pour plus d'informations sur l'amélioration de l'accessibilité de votre application Windows, consultez la section « Procédures pas à pas Visual Basic : Procédures pas à pas relatives à l'accessibilité : Création d'une application Windows accessible » dans la documentation de Microsoft Visual Studio® .NET.

Remarque


Présentation multimédia : Événements de formulaire et de contrôle


Dans cette démonstration, vous vous familiariserez avec les différents événements qui peuvent survenir suite à une action de l'utilisateur. Vous apprendrez également à intercepter certains événements dans votre code en écrivant du code pour les gestionnaires d'événements.


Association de code à des événements de contrôle


Les événements de contrôle vous permettent de répondre aux actions réalisées sur le contrôle. Vous pouvez écrire du code dans le bloc de code, ou gestionnaire d'événements, associé à l'événement du contrôle. Ce code s'exécute dès que l'événement survient.

! Pour ouvrir un gestionnaire d'événements pour un événement de contrôle

1. Dans le menu Affichage, cliquez sur Code pour ouvrir l'Éditeur de code correspondant au formulaire sur lequel vous travaillez.

2. Dans la liste Nom de la classe, cliquez sur le contrôle pour lequel vous voulez écrire le code. L'illustration suivante affiche la liste Nom de la classe avec Button1 sélectionné :

Introduction

Ajout de code


3. Ouvrez la liste Nom de la méthode pour afficher les événements disponibles pour le contrôle. L'illustration suivante affiche une liste partielle des événements de contrôle pour Button1. L'événement Click est sélectionné.

4. Cliquez sur l'événement pour ouvrir le gestionnaire d'événements correspondant.


Utilisation de la fonction MessageBox

MessageBox.Show( ) MessageBox.Show( )

Bouton par défautBouton par défaut

IcôneIcône

Texte en tant que chaîneTexte en tant que chaîne

Légende en tant que chaîneLégende en tant que chaîne

BoutonsBoutons


Un message est une boîte de dialogue prédéfinie qui sert à communiquer des informations à l'utilisateur ou à lui demander quelques renseignements simples.

Utilisez la syntaxe suivante pour appeler la fonction MessageBox et créer un message :

MessageBox.Show( )

! Pour créer un message 1. Accédez au bloc de code où vous voulez ajouter le code du message. Par

exemple, créez un formulaire doté d'un bouton et ouvrez le gestionnaire d'événements Button1_Click.

2. Ajoutez le code suivant au bloc de code. MessageBox.Show( )

3. Choisissez l'option que vous voulez utiliser pour le message.

Visual Basic .NET offre douze options par défaut pour créer un message. Ces options s'affichent dans une fenêtre dès que vous tapez le code présenté à l'étape 2. Pour chaque option, la fenêtre décrit les éléments requis que vous devez entrer entre parenthèses à la suite de la fonction MessageBox.Show. Utilisez les boutons FLÈCHE HAUT et FLÈCHE BAS de votre clavier pour passer en revue les options.

4. Entrez les éléments requis dans l'ordre demandé. a. Vous devez séparer chaque élément par une virgule. b. Le groupe d'éléments doit être délimité par des parenthèses ( ).

Introduction

Syntaxe

Création d'un message


Le tableau suivant explique les informations que vous devez entrer pour la première des douze options du message (option 1 de 12 dans la fenêtre).

Informations demandées

Définition

1 text As String Définit le texte qui apparaîtra dans le message. La chaîne doit figurer entre guillemets. Exemple : �Voulez-vous enregistrer ce fichier ?�

2 caption As String Définit la légende qui apparaîtra dans la barre de titre du message. La chaîne doit figurer entre guillemets. Exemple : �Question�

3 buttons Définit les boutons qui apparaîtront dans votre message. Vous choisissez ces boutons en double-cliquant dessus dans une zone de liste.

Exemple : Double-cliquez sur MessageBoxButtons.YesNo si vous souhaitez faire apparaître deux boutons-un bouton Oui et un bouton Non-dans le message.

Vous disposez des options suivantes : • Annuler, Réessayer & Ignorer

• OK

• OK & Annuler

• Réessayer & Annuler

• Oui & Non

• Oui, Non & Annuler

4 Icon Définit l'icône qui apparaîtra sur votre message afin d'informer l'utilisateur sur le contenu du message. Vous choisissez l'icône en double-cliquant dessus dans une zone de liste.

Exemple : Double-cliquez sur MessageBoxIcon.Question pour afficher une icône Point d'interrogation dans le message.

5 defaultButton Définit le bouton qui jouera le rôle de bouton par défaut sur votre formulaire. Vous choisissez le bouton par défaut en double-cliquant dessus dans une zone de liste.

Exemple : Si vous choisissez d'afficher les boutons Oui et Non dans votre message, double-cliquez sur MessageBoxDefaultButton.Button1 pour sélectionner Oui comme bouton par défaut.

6 options Définit les options d'affichage et d'association que vous utiliserez dans le message. Vous choisissez ces options en double-cliquant dessus dans une zone de liste.

Exemple : Double-cliquez sur MessageBoxOptions.DefaultDesktopOnly pour afficher le message sur le Bureau actif.

Pour plus d'informations sur chacune des options d'affichage et d'association, consultez les sections « MsgBoxStyle, énumération » et « MsgBoxResult, énumération » dans la documentation de Visual Studio .NET.


Si vous suiviez les exemples proposés dans le tableau ci-dessus, le message résultant ressemblerait à la capture d'écran suivante.

Votre code se présenterait ainsi :

Private Sub Button1_Click(. . .) MessageBox.Show("Voulez-vous enregistrer ce fichier ?", _ "Question", MessageBoxButtons.YesNo, _ MessageBoxIcon.Question, MessageBoxDefaultButton.Button1, _ MessageBoxOptions.DefaultDesktopOnly) End Sub

Vous pouvez aussi utiliser la fonction MessageBox en conjonction à une zone de texte pour en extraire le texte entré soit par défaut, soit par l'utilisateur. Pour extraire le texte d'une zone de texte à l'aide d'un message, utilisez la syntaxe suivante, où NomBoîteTexte est la valeur saisie dans la propriété Name du contrôle TextBox.

MessageBox.Show(NomBoîteTexte.Text)

Par exemple, considérez le formulaire suivant, où une zone de texte appelée ColorTextBox est proposée aux utilisateurs pour entrer leur couleur préférée.

Si vous voulez utiliser un message pour récupérer le texte saisi par l'utilisateur, vous pouvez utiliser le code suivant :

MessageBox.Show(ColorTextBox.Text)

Exemple de message

Extraction de texte d'une zone de texte

Exemple d'extraction de texte


Si vous avez ajouté ce code à l'événement Button1_Click, le message doit se présenter ainsi lorsque vous cliquez sur le bouton du formulaire. (Dans cet exemple, l'utilisateur a entré « Vert » dans la zone de texte.)


Application pratique : Création d'un message

Ouvrez une nouvelle application Windows dansVisual Basic .NET

Créez l'interface utilisateur

Ouvrez un gestionnaire d'événements et ajoutez du code pour créer une boîte de message

Définissez les propriétés du formulaire et ducontrôle

Exécutez l'application et testez votre code


Dans cette application pratique, vous allez créer un formulaire, puis y ajouter un contrôle TextBox et un contrôle Button. Vous écrirez du code pour l'événement Click du bouton. Lorsque le bouton sera sélectionné, un message apparaîtra. Le message affichera le texte qui se trouve dans la zone de texte.

! Écriture de code et création d'un message à partir d'un événement de contrôle

1. Ouvrez une nouvelle application Windows dans Visual Basic .NET. Créez un nouveau projet nommé MessageBoxProject dans dossier_installation\ Practices\Mod02.

2. Ajoutez deux contrôles au formulaire par défaut : un TextBox et un Button. Votre formulaire doit ressembler à peu près à ce qui suit :

3. Donnez à la propriété Text du contrôle TextBox1 la valeur suivante : Veuillez entrer votre nom ici. Le texte « Veuillez entrer votre nom ici » doit désormais apparaître dans la zone de texte de votre formulaire.

4. Double-cliquez sur le bouton pour créer le gestionnaire d'événements Button1_Click.


5. Dans le gestionnaire d'événements Button1_Click, écrivez le code permettant de récupérer le texte de TextBox1 et de l'afficher dans un message. Votre code doit ressembler à ce qui suit : Private Sub Button1_Click(...) MessageBox.Show(TextBox1.Text) End Sub

6. Exécutez votre application en cliquant sur le bouton Démarrer dans la barre d'outils standard.

7. Cliquez sur Button1 pour vérifier que le code du gestionnaire d'événements Button1_Click donne les résultats escomptés.

8. Quittez votre application.


Leçon : Présentation de votre code

! Conventions d'affectation de noms

! Mise en forme et documentation du code


Vous pouvez faciliter la lecture et la gestion de votre code en adoptant des conventions d'affectation de noms standard et en mettant en forme et documentant correctement votre code.


! Conventions d'affectation de noms ! Mise en forme et documentation du code


! respecter les conventions d'affectation de noms standard pour nommer les éléments que vous créez ;

! mettre en forme et documenter votre code à l'aide des éléments suivants : mise en retrait, signe de continuation, concaténation et commentaires.

Introduction




Conventions d'affectation de noms

! Règles d'affectation de noms" Utilisez uniquement des lettres, des chiffres et

des soulignés (_)" Commencez par une lettre ou un souligné" N'utilisez pas de mots clés

! Principe d'affectation de noms" Casse : Utilisez PascalCasing ou camelCasing,

selon l'élément que vous nommez

" Mécanique : Utilisez des substantifs pour les objets, des verbes pour les méthodes, etc.

" Choix des mots : Soyez cohérent, utilisez les mêmes termes dans les différents segments de code

Answer4242AnswerAnswer4242Answer ##

$$

BADSTYLE_poorstyleBestStyle

BADSTYLE_poorstyleBestStyle

##$$##

OpenButtonTrueOpenButtonTrue ##

$$


Si vous respectez scrupuleusement les conventions d'affectation de noms, votre code sera plus facile à lire et à mettre à jour. Il existe également des règles d'affectation de noms que vous devez suivre pour assurer le bon fonctionnement de votre programme.

Il y a quatre règles fondamentales à respecter lorsque vous nommez un élément dans Visual Basic. Si vous ne respectez pas ces règles, votre programme ne fonctionnera pas et générera une erreur.

1. Un nom doit commencer par un caractère alphabétique ou un caractère souligné (_).

2. Un nom ne doit se composer que de caractères alphabétiques, de chiffres et de soulignés.

3. Un nom doit contenir au moins un caractère alphabétique ou un chiffre s'il commence par un souligné.

4. Aucun nom ne peut être identique à un mot clé restreint.

Introduction

Règles d'affectation de noms


Vous pouvez attribuer n'importe quel nom à un objet, mais prenez l'habitude d'adopter une convention d'affectation de noms et de vous y tenir tout au long des programmes. Voici les trois éléments essentiels des principes d'affectation de noms :

1. Casse : Il existe deux styles de capitalisation standard dans Visual Studio .NET. Le choix du style dépend de l'élément que vous nommez. Pour plus d'informations sur l'utilisation de ces styles, consultez la remarque qui suit.

• PascalCasing Selon cette convention, il faut mettre le premier caractère de chaque mot en majuscules. Par exemple, utilisez OpenButton plutôt que Openbutton ou Open_Button.

• camelCasing Selon cette convention, il faut mettre le premier caractère de chaque mot en majuscules, à l'exception du premier mot. Par exemple, utilisez backColor plutôt que back_color ou backcolor.

2. Mécanique : Utilisez des substantifs pour les objets, des verbes pour les méthodes, etc.

3. Choix des mots : Soyez cohérent, utilisez les mêmes termes dans les différents segments de code.

Visual Studio .NET propose une documentation complète sur les principes d'affectation de noms. Pour plus d'informations sur les principes d'affectation de noms, consultez « Introduction à la bibliothèque de classes .NET Framework dans Visual Studio » dans la documentation Visual Studio .NET.

Principes d'affectation de noms

Remarque


Mise en forme et documentation du code

! Mise en retrait du code

! Signe de continuation et concaténation

! Ajout de commentaires dans le code

! Ajoutez des commentaires dans le code pour en faciliter la lecture et la mise à jour

MessageBox.Show("Nom Utilisateur = " & UserName.Text & _

", Mot de passe = " & Password.Text)

MessageBox.Show("Nom Utilisateur = " & UserName.Text & _

", Mot de passe = " & Password.Text)

Sub Button1_Click

Me.CloseEnd Sub

Sub Button1_Click

Me.CloseEnd Sub

'Rendre CalculationForm visible

Dim CalculationForm as new Form2( )

CalculationForm.Show( )

'Rendre CalculationForm visible

Dim CalculationForm as new Form2( )

CalculationForm.Show( )


Vous pouvez faciliter la lecture et la mise à jour de votre code en utilisant des techniques appropriées pour le mettre en forme et le documenter. Parmi ces techniques, citons : la mise en retrait de segments de code, la séparation et la concaténation des lignes de code et l'ajout de commentaires.

N'hésitez pas à mettre en retrait certains segments de code pour les distinguer les uns des autres (boucles et instructions conditionnelles, par exemple). Pour mettre en retrait une ligne de code, utilisez la touche TAB de votre clavier ou utilisez le bouton Augmenter le retrait de la barre d'outils de l'éditeur de texte.

! Pour afficher le paramètre par défaut de la mise en retrait du code 1. Dans le menu Outils, cliquez sur Options. 2. Cliquez sur le dossier Éditeur de texte, puis cliquez sur le dossier Basic. 3. Cliquez sur Tabulations pour consulter ou modifier les valeurs par défaut

des tabulations et du retrait, et pour vérifier que la mise en retrait intelligente est activée.

Vous pouvez utiliser des sauts de ligne pour pouvoir lire tout le code dans l'Éditeur de code sans utiliser la touche de défilement horizontale. Dans Visual Basic, vous interrompez une ligne de code en utilisant le signe de continuation, qui est le souligné (_) précédé d'un espace.

Des sauts de ligne ont, par exemple, été utilisés dans le code suivant pour que toute la chaîne puisse être lue dans l'Éditeur de code sans faire défiler l'écran sur la droite.

MessageBox.Show("Nom Utilisateur = " & UserName.Text & _ ", Mot de passe = " & Password.Text)

Remarquez que la ligne qui suit le saut de ligne est mise en retrait. Il s'agit là d'une astuce visuelle qui indique que le texte mis en retrait fait par partie du texte précédant le saut de ligne.

Introduction

Mise en retrait du code

Signe de continuation


Si vous devez diviser une chaîne en deux ou plusieurs autres, placez un signe de continuation entre les chaînes, puis concaténez-les, ou reliez-les entre elles, à l'aide d'un Et commercial (&).

Tous les espaces doivent conserver leur place dans la chaîne lors de la concaténation.

Code Affichage

Incorrect : MessageBox.Show("Nom Utilisateur =" & UserName.Text & _

Nom Utilisateur =username

Correct : MessageBox.Show("Nom Utilisateur = " & UserName.Text & _

Nom Utilisateur = username

Pour commenter votre code, utilisez une apostrophe ('). Visual Basic ignore tout ce qui suit une seule apostrophe ; les commentaires peuvent occuper une ligne à eux tout seuls ou se placer à la fin d'une ligne de code.

Vous pouvez ajouter ou supprimer des symboles de commentaires dans un bloc de code en sélectionnant deux ou plusieurs lignes de code et en cliquant sur les boutons Commenter la sélection et Ne pas commenter la sélection de la barre d'outils de l'éditeur de texte.

Voici le bouton Commenter la sélection.

Voici le bouton Ne pas commenter la sélection.

Voici deux exemples de code commenté :

! Le commentaire se trouve à la fin d'une ligne de code : CalculationForm.Show( ) ' CalculationForm devient visible

! Le commentaire est situé sur une ligne qui lui est propre :

' Créer le message pour l'événement Button1_Click Private Sub Button1_Click(. . MessageBox.Show("Voulez-vous enregistrer ce fichier ?", _ "Question", MessageBoxButtons.YesNo, _ MessageBoxDefaultButton.Button1) End Sub

Concaténation

Ajout de commentaires dans le code


Dès lors que vous écrivez des codes plus compliqués, n'hésitez pas à ajouter des commentaires pour en faciliter la lecture et la mise à jour. Utilisez des commentaires pour expliquer, en langage de tous les jours, le but d'une section de code, surtout lorsque la fonction ne va pas de soi ou n'est pas claire. Un commentaire du style « calculer le remboursement mensuel prévu de l'utilisateur à partir des données saisies par l'utilisateur » pourrait, par exemple, accompagner une fonction de calcul pour en expliquer le but.

La liste suivante vous explique dans quel cas vous avez intérêt à commenter votre code :

! Commencez les procédures par un bloc de commentaires. Ce bloc peut contenir des informations telles que but de la procédure, valeur renvoyée par une fonction, arguments utilisés par la procédure, etc.

! Dans les procédures plus longues, utilisez des commentaires pour décomposer les diverses étapes de travail de la procédure.

! Lorsque vous déclarez des variables, ajoutez un commentaire pour indiquer la façon d'utiliser la variable.

! Lorsque vous écrivez une structure décisionnelle, utilisez un commentaire pour indiquer la façon de prendre la décision et ce qu'elle implique.

Utilisation des commentaires



! Compréhension des concepts de programmation

! Utilisation de Windows Forms

! Utilisation des contrôles

! Présentation de votre code


Studio .NET

Accèsaux données


Écriturede code

Créationd'une

interface


1. Quelle est la relation entre classes et objets ? Les classes sont des représentations symboliques des objets. Chaque objet est une instance d'une classe.

2. Parmi les éléments suivants, quels sont les propriétés, les méthodes ou les événements ?

a. Click e. Size b. Close f. Resize c. Text g. Show d. KeyPress h. Closing

Les éléments a, d, f et h sont des événements. Les éléments b et g sont des méthodes. Les éléments c et e sont des propriétés.


3. Vous créez une nouvelle application et modifiez les propriétés de Form1, conformément au tableau ci-dessous. Lorsque vous essayez d'exécuter l'application, vous obtenez un message d'erreur qui vous indique la présence d'erreurs de génération. Quelle est la cause probable de ce problème et comment pouvez-vous y remédier ?

Propriété du formulaire Nouvelle valeur

ControlBox False

Name LogonForm

Text Formulaire de connexion

StartPosition CenterScreen

L'erreur provient vraisemblablement du fait que l'objet de démarrage est toujours Form1. Lorsque vous modifiez la propriété Name du formulaire, vous devez modifier en conséquence l'objet de démarrage du projet. Pour cela, dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, cliquez sur Propriétés, puis donnez la valeur LogonForm au nouvel objet de démarrage.

4. Indiquez si les instructions suivantes sont vraies ou fausses. Si une instruction est fausse, expliquez pourquoi. a. Lorsque vous appelez la méthode Hide d'un formulaire, le formulaire se

ferme. b. Vous utilisez la syntaxe suivante pour afficher un formulaire :

NomFormulaire.Show( ) c. Il est préférable de laisser aux utilisateurs un contrôle maximal en

réduisant le nombre d'interactions modales dans vos applications. a. Faux. Lorsque vous appelez la méthode Hide d'un formulaire, le

formulaire devient invisible mais ne se ferme pas. b. Vrai. c. Vrai.


5. Vous écrivez un programme et devez placer le contenu de FirstNameTextBox dans un message. Écrivez le code qui vous permet de créer ce message. MessageBox.Show(FirstNameTextBox.Text)

6. Le code suivant est répertorié dans l'Éditeur de code pour Form1, qui dispose d'un bouton appelé ClickMeButton. Ajoutez un commentaire à ce code pour expliquer le rôle du bouton. N'oubliez pas d'utiliser le caractère correct pour indiquer qu'il s'agit d'un commentaire. Private Sub ClickMeButton_Click(...) Me.CenterToScreen( ) MessageBox.Show("Bonjour") End Sub

' Centre Form1 sur l'écran, puis ouvre un message


Atelier 2.1 : Création de l'interface utilisateur

! Exercice 1 : Création du formulaireprincipal



! créer des formulaires et des contrôles pour créer une interface utilisateur ; ! définir et modifier les propriétés des formulaires et des contrôles ; ! écrire le code qui permet de gérer les événements de formulaire et de

contrôle ; ! modifier l'objet de démarrage d'un projet.

Cet atelier étant essentiellement axé sur les concepts abordés dans ce module, les recommandations de sécurité de Microsoft ne seront peut-être pas toujours respectées.

Avant de poursuivre, vous devez :

! savoir ajouter des contrôles à un formulaire ; ! connaître l'environnement de développement de Visual Studio .NET ; ! savoir écrire du code pour gérer les événements ;. ! connaître les propriétés de formulaire et de contrôle.

Objectifs

Remarque



Dans les ateliers des modules 2, 4, 5, 6 et 12 du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET, vous apprendrez à créer une simulation de prêt. Vous créerez l'ensemble de l'application en plusieurs étapes, chaque étape reprenant le code créé dans l'atelier précédent. Au commencement de chaque atelier, vous pouvez décider de poursuivre avec vos propres fichiers ou de démarrer avec les fichiers fournis.

Dans l'Atelier 2.1, vous créerez l'interface utilisateur de l'application : un formulaire de calcul de prêt.

Les fichiers solution de cet atelier se trouvent dans le dossier dossier_installation\Labfiles\Lab021\Ex01\Solution.

Scénario

Fichiers solution



Exercice 1 Création du formulaire principal

Au cours de cet exercice, vous créerez le formulaire principal d'une application de simulation de prêt. Vous commencerez un nouveau projet, renommerez le formulaire, placerez les contrôles sur le formulaire, définirez les propriétés des contrôles et modifierez l'objet de démarrage de votre projet.

! Création d'un nouveau projet 1. Ouvrez Visual Studio .NET. 2. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 3. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets

Visual Basic, puis sur le modèle Application Windows. Créez un nouveau projet nommé LoanApplication dans dossier_installation\Labfiles\Lab021\ Ex01\Starter. Cliquez sur OK.

4. Dans l'Explorateur de solutions, cliquez sur Form1.vb. 5. Dans la fenêtre Propriétés, donnez à la propriété File Name la valeur

Main.vb.

! Ajout de contrôles au formulaire principal 1. Ajoutez deux contrôles Label au formulaire. 2. Ajoutez un contrôle TextBox au formulaire. 3. Ajoutez un contrôle ComboBox au formulaire. 4. Ajoutez un contrôle GroupBox au formulaire, puis ajoutez trois contrôles

RadioButton à l'intérieur du contrôle GroupBox. 5. Ajoutez un contrôle Button au formulaire.

Votre formulaire doit être similaire à la capture d'écran ci-dessous.


6. Définissez les propriétés de ces contrôles en leur donnant les valeurs répertoriées dans le tableau ci-dessous.

Nom du contrôle Propriété Valeur de la propriété

Label1 Name LoanLabel

Text Montant du prêt

Label2 Name RateLabel

Text Taux d'intérêt

TextBox1 Name LoanTextBox

Text vide

ComboBox1 Name RateComboBox

Text vide

Items 4,5

6,25

7,0

8,325

9,0

10,0

GroupBox1 Name TermGroupBox

Text Durée du prêt

RadioButton1 Name Length5RadioButton

Text 5 ans

Checked True


Text 15 ans


Text 30 ans

Button1 Name DoneButton

Text &Terminé

Form1 Name MainForm

Text Simulation de prêt

FormBorderStyle FixedSingle

MaximizeBox False

CancelButton DoneButton


Votre formulaire doit désormais être similaire à la capture d'écran ci-dessous.

! Ajout d'un gestionnaire d'événements • Pour quitter l'application de prêt, créez un gestionnaire d'événements pour

l'événement Click du bouton Terminé. Appelez la méthode Me.Close lorsqu'un utilisateur clique sur le bouton Terminé.

! Modification de l'objet de démarrage • Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet

LoanApplication, puis cliquez sur Propriétés. Dans la boîte de dialogue Objet de démarrage, donnez à l'objet de démarrage le nom MainForm, puis cliquez sur OK.

! Test de l'application 1. Dans le menu Déboguer, cliquez sur Démarrer. Tapez un montant de prêt

et sélectionnez un taux d'intérêt. 2. Cliquez sur le bouton Terminé pour quitter l'application. 3. Exécutez une nouvelle fois l'application. 4. Appuyez sur ÉCHAP.

Que se passe-t-il ? Pourquoi ? L'application prend fin car le bouton Terminé est mentionné dans la propriété CancelButton du formulaire. ____________________________________________________________

____________________________________________________________

CETTE PAGE EST VOLONTAIREMENT VIDE

Table des matières

Vue d'ensemble 1

Présentation multimédia : Présentation des variables 2

Leçon : Introduction aux types de données 4

Leçon : Utilisation de variables 10

Leçon : Portée des variables 21

Leçon : Conversion des types de données 32

Atelier 3.1 : Création et utilisation de variables 38

Leçon : Création et utilisation de structures 45

Leçon : Stockage de données dans des tableaux 54


Atelier 3.2 : Utilisation de structures et de tableaux 65

Module 3 : Utilisation de variables et de tableaux


Module 3 : Utilisation de variables et de tableaux iii

Notes de l'instructeur Lorsqu'une application s'exécute, elle utilise des variables pour stocker des valeurs dans la mémoire temporaire afin de traiter des données et effectuer des calculs. Ce module explique comment nommer, déclarer et affecter des valeurs à vos variables et comment utiliser ces dernières dans vos applications. Il s'attache également à la création et à l'utilisation de structures et de tableaux.


! décrire les différents types de données utilisables pour la déclaration de variables ;

! nommer, déclarer, initialiser et utiliser des variables et des constantes ; ! déclarer des variables avec différents niveaux de portée ; ! créer des structures de données définies par l'utilisateur ; ! convertir des valeurs de variables d'un type de données en un autre type ; ! stocker des données dans des tableaux.


! Fichier Microsoft PowerPoint® 2560A_03.ppt ! Fichier d'animation multimédia 2560A_Variables.htm ! Fichier de démonstration multimédia 2560A_03d005.wmv.


! lire tous les documents de cours relatifs à ce module ; ! réaliser les applications pratiques et les ateliers ; ! utiliser les démonstrations dirigées ; ! étudier les démonstrations multimédias.

Présentation et applications pratiques : 150 minutes Ateliers : 75 minutes

Documents de cours

Préparation

iv Module 3 : Utilisation de variables et de tableaux


Présentation multimédia : Présentation des variables Ce module commence par une animation multimédia permettant de jeter les bases des concepts et des tâches clés de ce module. Cette animation explique la nature des variables et la manière dont les applications les utilisent pour traiter des données et calculer des valeurs. Pour lancer cette animation, cliquez sur l'icône au centre de la diapositive de cette rubrique.

Leçon : Introduction aux types de données Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Lancez la discussion en rappelant aux stagiaires que le système de types communs fait partie du Common Language Runtime. Insistez sur le fait que le système de types communs fournit les bases de la sécurisation des types, ce qui implique un accès à ces types uniquement par des moyens autorisés et bien définis. Expliquez que le système de types communs prend en charge deux types : les types valeur et les types référence.

Il est possible que les stagiaires soient déroutés par la différence existant entre ces deux types. Expliquez-leur que les types valeur contiennent eux-mêmes leurs données tandis que les types référence ne comprennent que des pointeurs vers leurs données. Le cas échéant, établissez un parallèle comme celui-ci : les types valeur sont assimilables à la ville de Paris et les types référence aux indications permettant de s'y rendre. Soyez prêt à expliquer qu'en ce qui concerne les chaînes, l'instance est détruite : une nouvelle instance est donc créée pour recevoir la nouvelle valeur ; pourtant la chaîne fonctionne comme si la valeur était remplacée dans l'instance originale.

Cette rubrique fournit des informations sur les sept types de données couramment utilisés : Boolean, Date, Decimal, Double, Integer, Single et String. Expliquez que les stagiaires peuvent trouver la liste complète et la description des types de données de Microsoft Visual Basic® .NET dans la documentation Visual Basic .NET.

Précisez bien que même si les stagiaires ne sont pas amenés à spécifier des types de données dans Visual Basic .NET, il leur est fortement recommandé de sélectionner explicitement un type de données. Des applications plus fiables et moins gourmandes au niveau de la mémoire découleront de cette pratique.

Dans cette application pratique, les stagiaires travailleront par groupes de deux pour analyser les exemples de données et choisir le type le plus dense pour chaque exemple. Une durée de 10 minutes environ est prévue pour cette application pratique.

Présentation du système de types communs

Types de données

Choix d'un type de données

Application pratique : Choix du type de données

Module 3 : Utilisation de variables et de tableaux v

Leçon : Utilisation de variables Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Cette rubrique décrit les variables et explique le rôle qu'elles jouent dans les applications créées avec Visual Basic .NET. Expliquez que les variables sont utiles pour le stockage temporaire. Par exemple, elles sont utiles lorsqu'un compteur est nécessaire dans une application. Définissez chacun des six éléments constituant une variable : le nom, l'adresse, le type de données, la valeur, la portée et la durée de vie.

Cette rubrique décrit les conventions d'appellation des variables dans Visual Basic .NET. Expliquez que l'adhésion aux règles est nécessaire et que suivre les recommandations faites est une bonne habitude à prendre pour pouvoir élaborer des applications faciles à déboguer et à gérer. Soulignez également que le choix de noms significatifs est particulièrement important pour la gestion du code.

L'élément essentiel de cette rubrique est la syntaxe permettant de déclarer une variable. Expliquez que déclarer une variable signifie spécifier le nom et les caractéristiques de cette variable. Précisez que les stagiaires utiliseront l'instruction Dim pour déclarer à la fois les variables de type valeur et les variables de type référence.

Cette rubrique explique comment déclarer des variables implicitement en définissant Option Explicit au niveau du projet. Soulignez que même s'il est généralement préférable de déclarer des variables avant de les utiliser, les stagiaires doivent connaître cette option au cas où ils la rencontreraient dans les applications qu'ils gèrent.

Cette rubrique décrit la façon d'utiliser des instructions d'assignation pour initialiser des variables. Expliquez qu'après avoir nommé et déclaré une variable, les stagiaires devront l'initialiser. Précisez que s'ils ont déclaré une variable à l'aide de l'instruction Dim, Visual Basic .NET définira automatiquement les valeurs numériques sur 0 et les chaînes de texte sur vide. Signalez que les valeurs de chaîne doivent être mises entre guillemets ("") et les valeurs de date précédées et suivies du signe dièse (#).

Après avoir déclaré des variables et leur avoir assigné des valeurs, les stagiaires peuvent les utiliser pour traiter ou stocker des données dans des applications. Ceci peut leur paraître déroutant au début car ils peuvent modifier par mégarde les valeurs des variables. Insistez sur l'utilisation du message pour vérifier les valeurs de leurs variables lorsqu'ils développent des applications.

Les stagiaires ont appris à la rubrique précédente que les variables ne changent pas toujours de valeur dans les applications. Expliquez-leur que le stockage de valeurs immuables en constantes est une bonne façon de gérer des valeurs qui ne changent pas parce que les constantes utilisent moins de mémoire que les variables et parce qu'elles sont faciles à mettre à jour dans le code.

Au cours de cette application pratique, les stagiaires travailleront par groupes de deux et corrigeront les bogues contenus dans cinq exemples Visual Basic .NET. Assurez-vous qu'ils notent leurs réponses par écrit. Lors de la mise en commun des réponses, écrivez les réponses correctes sur le tableau blanc pour éviter toute confusion. Une durée de 10 minutes environ est prévue pour cette application pratique.

Présentation des variables

Attribution d'un nom aux variables

Déclaration de variables

Incidences de Option Explicit sur les variables

Affectation de valeurs aux variables

Utilisation de variables

Comparaison Variables / Constantes

Application pratique : Recherche de bogues

vi Module 3 : Utilisation de variables et de tableaux

Leçon : Portée des variables Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Expliquez que la portée d'une variable est l'ensemble de tout le code pouvant se référer à la variable par son nom. Soyez prêt à savoir faire la distinction entre les noms qualifiés et les noms non qualifiés, au cas où la question vous serait posée. Précisez que limiter la portée au maximum est une bonne habitude de programmation à prendre pour économiser de la mémoire et diminuer les risques de voir le code se référer à la mauvaise variable. Faites une brève description des termes peu courants sur la diapositive en gardant à l'esprit que les stagiaires découvriront dans les détails les notions de blocs, de procédures et de classes plus loin dans ce cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Expliquez que les variables locales constituent un excellent choix pour les calculs rapides et temporaires. Précisez aux stagiaires qu'ils doivent déclarer les variables locales dans un bloc ou dans une procédure et que ces variables seront uniquement disponibles dans le bloc ou la procédure où elles sont déclarées au moment de l'exécution du code.

Expliquez aux stagiaires qu'ils peuvent utiliser les variables statiques pour préserver la valeur d'une variable d'un appel de procédure à l'autre. Soulignez que la durée de vie d'une variable statique perdure avec l'existence d'une application.

Si les stagiaires ont besoin de variables de longue portée, comme pour les niveaux de module ou de projet, expliquez-leur qu'ils peuvent déclarer des variables de niveau module dans un module mais que ceci n'est pas possible dans toutes les procédures. Spécifiez que ces variables de module sont déclarées au niveau du module mais qu'elles peuvent également être initialisées et utilisées dans les procédures.

Cette démonstration multimédia montre comment déclarer une variable à différents niveaux de portée.

Pour lancer cette démonstration, cliquez sur l'icône au centre de la diapositive de cette rubrique. Si vous préférez exploiter cette démonstration multimédia comme démonstration dirigée, consultez l'activité qui vous est réservée en qualité d'instructeur dans la section Démonstration des notes de l'instructeur.

Pour les informations sur le réglage optimal de l'affichage des démonstrations multimédias, consultez la liste de préparation au cours incluse dans le kit de l'instructeur.

Au cours de cette application pratique, les stagiaires étudieront le code de démarrage proposé dans lequel une variable est utilisée mais non déclarée. Ils décideront de l'emplacement où déclarer la variable et choisiront le modificateur d'accès à utiliser pour lui assigner différents niveaux de portée. Une durée de 10 minutes environ est prévue pour cette application pratique.

Présentation de la notion de portée

Déclaration de variables locales

Déclaration de variables statiques

Déclaration de variables de module

Présentation multimédia : Définition de niveaux d'accès aux variables

Application pratique : Définition de niveaux d'accès aux variables

Module 3 : Utilisation de variables et de tableaux vii

Leçon : Conversion des types de données Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Cette rubrique présente quelques-unes des fonctions de conversion les plus fréquemment utilisées. Proposez quelques scénarii dans lesquels la conversion de données peut se révéler utile. Un scénario peut, par exemple, décrire une situation où l'utilisateur entre des données de chaîne contenant des nombres. Le développeur peut ensuite vouloir convertir ces valeurs, du type de données String en type de données Integer, pour qu'elles soient utilisables dans des calculs mathématiques. Renvoyez les stagiaires à la documentation Microsoft Visual Studio® .NET pour obtenir une liste complète des fonctions de conversion.

Guidez les stagiaires à travers les différentes étapes du processus de conversion d'une valeur d'un type de données en un autre type. Mentionnez le fait que Visual Basic .NET peut effectuer certaines conversions implicites de données mais qu'il est conseillé aux stagiaires d'utiliser des conversions explicites pour éviter la présence éventuelle de bogues dans leurs codes. Expliquez la différence existant entre les conversions étendues et les conversions restrictives, puis discutez de la possibilité de perdre des données lors de l'utilisation de conversions restrictives.

Cette rubrique explique les conversions implicites de données. Mettez les stagiaires en garde contre la possibilité offerte par Visual Basic .NET d'effectuer certaines conversions de types de données automatiquement (ou implicitement) car il existe des inconvénients remettant en cause la fiabilité des conversions automatiques des types de données. L'un de ces inconvénients majeurs est l'éventuelle production de résultats inattendus par l'application.

Atelier 3.1 : Création et utilisation de variables Avant de démarrer cet atelier, les stagiaires doivent s'assurer qu'ils ont réalisé toutes les applications pratiques des quatre premières leçons. Dans le premier exercice, les stagiaires déclareront et utiliseront une variable statique pour vérifier un formulaire d'ouverture de session (logon). Dans le deuxième exercice, les stagiaires déclareront et utiliseront des variables permettant à l'application de gérer des données entrées par l'utilisateur. Cet atelier est proposé à mi-module pour permettre aux stagiaires de mettre en pratique les nouveaux acquis avant de passer aux rubriques plus poussées concernant la création et l'utilisation de structures et de tableaux.

Cet atelier ne fait pas partie du scénario de l'application sur l'emprunt utilisé dans les autres modules du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Présentation des fonctions de conversion

Conversion explicite de types de données

Mécanisme de conversion implicite de données

viii Module 3 : Utilisation de variables et de tableaux

Leçon : Création et utilisation de structures Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Expliquez que les structures peuvent posséder des propriétés, des méthodes et des événements et qu'elles peuvent implémenter une voire plusieurs interfaces. Mettez l'accent sur le concept de regroupement des informations connexes. La rubrique développe l'exemple d'une structure incluant le nom d'un employé, sa date d'embauche, sa fonction et son salaire. Pour cela, vous pouvez utiliser plusieurs variables, mais rien de vous empêche de définir une structure et de l'utiliser comme variable Employee unique. L'avantage d'une telle structure devient évident lorsque vous avez beaucoup d'employés et donc de nombreuses instances de cette variable. Le code permettant d'illustrer cet exemple se trouve dans les notes du stagiaire ; il peut être profitable de le parcourir en cours pour une meilleure compréhension de ce concept par la classe.

Exposez la syntaxe générale servant à déclarer une structure. Expliquez aux stagiaires qu'ils peuvent déclarer uniquement des structures au niveau du module, du fichier ou de l'espace de noms. Les stagiaires peuvent hésiter sur la façon d'atteindre les membres d'une structure définis à l'intérieur d'une autre structure. Précisez-leur que, pour accéder à ces membres, ils doivent déclarer une variable du type de données de la structure interne.

Cette rubrique expose brièvement les quatre grandes étapes à suivre pour utiliser une structure : déclaration d'une structure, déclaration d'un type de variable du type de structure déclaré, affectation de valeurs aux données membres et écriture de code pour utiliser les membres de la structure. Décomposez ces tâches en différentes étapes peut aider les stagiaires à comprendre le contexte dans lequel utiliser des structures.

Au cours de cette application pratique, les stagiaires créeront une structure, puis ils déclareront une variable de ce type de structure ; ils affecteront des valeurs aux données membres de la structure et écriront le code pour utiliser la variable et les membres de la structure. Une durée de 25 minutes environ est prévue pour cette application pratique.

Leçon : Stockage de données dans des tableaux Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Un tableau est un type de données capital dans Visual Basic .NET, il l'est d'ailleurs pour la plupart des langages de programmation. Expliquez les concepts de base qui définissent la façon dont les tableaux fonctionnent. Ceux-ci contiennent une série d'éléments, possédant le même type de données, dont certains sont accessibles en utilisant un entier comme index. Utilisez à votre convenance l'exemple suivant : étant donné qu'une enfilade de maisons forme une rue, un tableau de maisons constitue une rue.

Exposez la syntaxe générale servant à déclarer un tableau. Cette rubrique explique comment déclarer des tableaux en spécifiant la taille et les valeurs initiales des membres du tableau.

Présentation des structures

Déclaration de structures

Utilisation de structures

Application pratique : Création et utilisation de structures

Présentation d'un tableau

Déclaration d'un tableau unidimensionnel

Module 3 : Utilisation de variables et de tableaux ix

Exposez la syntaxe générale servant à déclarer des tableaux multidimensionnels. Expliquez la façon dont les index fonctionnent et comment spécifier le nombre et la grandeur des dimensions dans l'instruction de déclaration. L'utilisation d'exemples est probablement la meilleure solution permettant d'assimiler l'aspect multidimensionnel des tableaux et la raison de leur utilité. Les pixels s'affichant sur l'écran d'un ordinateur ou les cellules d'une feuille de calcul Microsoft Excel sont de bons exemples usuels.

Tous les tableaux sont dynamiques dans Visual Basic .NET. Signalez que n'importe quel tableau existant dans Visual Basic .NET peut être redimensionné en utilisant l'instruction ReDim et en précisant de nouvelles dimensions. Mentionnez qu'il est également possible de conserver les valeurs du tableau original en incluant le mot clé Preserve dans l'instruction ReDim.

Contrôle des acquis Encouragez les stagiaires à revenir sur le contenu du module pour répondre aux questions difficiles. Vous pouvez également préférer la forme d'une discussion pour aborder ces questions afin que chacun profite des réponses.

1. Voici une question simple pour vérifier que les stagiaires comprennent bien la manière dont ils doivent choisir les types de données. Pour les conditions vraies ou fausses, utilisez toujours un type de données Boolean.

2. Si les stagiaires ne se souviennent plus des deux solutions possibles d'affectation d'une valeur à une variable, rappelez-leur qu'ils peuvent soit assigner une valeur à une variable après la déclaration de la variable, soit affecter la valeur en l'intégrant à l'instruction de déclaration.

3. Cette question permet de tester si les stagiaires ont compris le sens du concept de portée. Si une variable est déclarée publique dans une classe publique, elle est accessible à partir de n'importe quel point de la solution. Pour limiter l'accès au niveau du module, passez simplement le modificateur d'accès de Public à Private.

4. Profitez de cette question pour exposer le concept de durée de vie. Les variables locales existent uniquement tant que le bloc ou la procédure dans lequel elles ont été déclarées s'exécute. Les variables statiques ont la même durée de vie que l'application dans laquelle elles ont été déclarées et perdurent tant que l'application s'exécute.

5. Les stagiaires doivent être capable d'analyser ce code et de déterminer ce qui se passe pour une valeur durant la conversion des données. Si les stagiaires ont du mal à répondre à cette question, révisez le processus de conversion des données.

6. Assurez-vous que les stagiaires sont capables de créer et d'utiliser une structure de données telle qu'elle est formulée dans la question. Ils devront effectuer cette tâche pour terminer l'atelier 3.2, « Utilisation de structures et de tableaux ».

7. Profitez de cette question pour débattre sur la façon de déterminer les valeurs d'index à utiliser pour accéder à un élément dans un tableau.

Utilisation de tableaux multidimensionnels

Redimensionnement des tableaux

x Module 3 : Utilisation de variables et de tableaux

Atelier 3.2 : Utilisation de structures et de tableaux Au cours de cet atelier, les stagiaires ouvriront un formulaire existant ; ils déclareront et utiliseront les variables nécessaires à une simulation d'emprunt. Ils créeront ensuite une structure de données qu'ils utiliseront dans cette demande. Enfin, ils déclareront un tableau en utilisant la structure de données et afficheront son contenu. Cet atelier ne fait pas partie du scénario de l'application sur l'emprunt utilisée dans les autres modules du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Démonstrations Vous pouvez présenter cette démonstration multimédia en exécutant le fichier multimédia fourni avec ce module ou effectuer la démonstration vous-même en suivant ces instructions.

Pour les informations sur le réglage optimal de l'affichage des démonstrations multimédias, consultez la liste de préparation au cours incluse dans le kit de l'instructeur.

Présentation multimédia : Définition de niveaux d'accès aux variables Cette démonstration multimédia montre comment déclarer une variable avec différents niveaux de portée. La portée d'une variable constitue l'ensemble du code pouvant se référer à la variable par son nom.

! Chargement du fichier de solution pour la démonstration 1. Démarrez Visual Studio .NET. 2. Ouvrez le fichier VariableAccess.sln situé dans le dossier

dossier_installation\Democode\Mod03\VariableAccess. Cette solution comprend un projet unique. Il comporte deux formulaires et un module.

! Analyse de Form1 1. Dans l'Explorateur de solutions, double-cliquez sur Form1.vb pour ouvrir le

concepteur Microsoft Windows® Forms. 2. Dans l'onglet Form1. [Design], double-cliquez sur Quelle est la valeur de

myVar ? Précisez que le code de Form1 est très simple. Si l'utilisateur clique sur le bouton lorsque l'application s'exécute, la valeur de la variable myVar apparaît.

! Exécution de l'application 1. Dans la barre d'outils standard, cliquez sur le bouton Démarrer. 2. Dans la boîte de dialogue Environnement de développement Microsoft,

cliquez sur Non. La fenêtre Liste des tâches résume les erreurs de génération détectées par le compilateur. En cas d'erreur, un message vous informe que la variable myVar n'est pas déclarée dans Form1.vb.

Module 3 : Utilisation de variables et de tableaux xi

3. Positionnez le pointeur de la souris sur myVar dans l'éditeur de code de Form1.vb. Dans l'environnement de développement, les erreurs de code sont soulignées en bleu. En cas d'erreur, le message indique que Le nom 'myVar' n'est pas déclaré.

4. Insérez la ligne suivante au-dessus de l'instruction MessageBox.Show : Dim myVar As Integer = 10

Remarquez que le trait bleu sous myVar à la ligne suivante a disparu puisque la variable myVar est à présent déclarée.

! Utilisation de la portée au niveau du bloc 1. Déplacez l'instruction MessageBox suivante hors du bloc et placez-la après

l'instruction End If : MessageBox.Show("La valeur de myVar est " & myVar)

Remarquez que la fenêtre Liste des tâches signale à présent la variable myVar comme non déclarée. Étant donné que myVar est déclarée à l'intérieur du bloc de code If�End If, elle a une portée de niveau de bloc ; elle est donc inaccessible de l'extérieur du bloc.

2. Déplacez l'instruction MessageBox devant l'instruction End If pour effacer l'erreur.

! Utilisation de la portée au niveau de la procédure •••• Déplacez la déclaration myVar devant l'instruction If�Then, comme suit :

Dim myVar As Integer = 10 If CheckBox1.Checked Then

À présent, myVar a une portée de niveau de procédure ; elle est donc accessible à partir de n'importe quel endroit de la procédure. Remarquez que myVar est toujours valide et que l'erreur a disparu de la fenêtre Liste des tâches.

! Utilisation de la portée au niveau du formulaire 1. Dans l'éditeur de code de Form1.vb, insérez la ligne suivante dans le

gestionnaire d'événements Button1_Click, après l'instruction MessageBox : CallMyVar( )

2. Devant l'instruction End Class, insérez le code suivant :

Private Sub CallMyVar( ) MessageBox.Show("Utilisation de myVar à partir d'une autre " & _ "procédure � la valeur est:" & myVar) End Sub

xii Module 3 : Utilisation de variables et de tableaux

3. Déplacez la déclaration myVar à l'intérieur de la procédure CallMyVar, comme suit : Private Sub CallMyVar( ) Dim myVar As Integer = 10

Remarquez que myVar n'est plus valide dans le gestionnaire d'événements Button1_Click de la première procédure. Toutefois, elle est valide dans la nouvelle procédure. Elle est déclarée à l'intérieur d'une procédure, ce qui lui confère une portée de niveau de procédure ; elle est donc uniquement accessible dans la procédure où elle a été déclarée.

4. Déplacez la déclaration myVar pour qu'elle suive immédiatement l'instruction Inherits, comme montré dans les lignes de code suivantes : Inherits System.Windows.Forms.Form Dim myVar As Integer = 10

À présent, la variable a une portée de niveau de formulaire ; elle est donc accessible à partir de n'importe quel endroit du formulaire.

5. Dans la barre d'outils standard, cliquez sur le bouton Démarrer pour exécuter l'application.

6. Dans Form1, cliquez sur Quelle est la valeur de myVar ? 7. Dans le message, cliquez sur OK.

Ce message est déclenché par l'instruction MessageBox du gestionnaire d'événements Button1_Click.

8. Dans le message, cliquez sur OK. Ce message est déclenché par l'instruction MessageBox dans la procédure CallMyVar Sub.

9. Fermez Form1. 10. Dans le gestionnaire d'événements Button1_Click, supprimez la ligne

suivante : CallMyVar( )

11. Supprimez la procédure CallMyVar.

! Utilisation de la portée au niveau du projet 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Form2.vb,

puis sélectionnez Afficher le code. 2. Ne commentez pas la ligne de code MessageBox.

Remarquez que Form2, comme Form1, utilise une méthode MessageBox.Show pour afficher la valeur de la variable myVar. Bien que myVar soit déclarée dans Form1, la variable myVar de cette procédure est marquée comme erreur de génération.

3. Déplacez le pointeur de la souris sur myVar. Une info-bulle affiche le message d'erreur : « Le nom 'myVar' n'est pas déclaré. » La déclaration de myVar dans Form1 est faite au niveau du formulaire, par conséquent myVar est inaccessible dans Form2. Pour corriger cette erreur, vous devez déclarer la variable afin qu'elle soit accessible pour les deux formulaires.

Module 3 : Utilisation de variables et de tableaux xiii

4. Dans l'éditeur de code, cliquez sur l'onglet Form1.vb*. 5. Supprimez l'instruction suivante :

Dim myVar As Integer = 10

6. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Module1.vb, puis sélectionnez Afficher le code.

7. Déclarez myVar au début du module, après l'instruction Module Module1, comme suit : Dim myVar As Integer = 10

Bien que l'instruction Dim soit valide dans le code du module, myVar n'est toujours pas disponible pour le code de Form2.

8. Dans la déclaration de variable, remplacez Dim par Friend, comme suit : Friend myVar As Integer = 10

Le mot clé Friend est uniquement utilisable au niveau du module, du fichier ou de l'espace de noms. Remarquez que les erreurs de génération ont été effacées de la fenêtre Liste des tâches. L'instruction Friend rend la variable accessible à partir de n'importe quel endroit du projet, mais elle reste inaccessible de l'extérieur.

Si vous voulez qu'une variable soit accessible pour tous les projets inclus dans une solution, déclarez cette variable avec le modificateur d'accès Public au début d'un module.

! Exécution et test de l'application 1. Dans la barre d'outils standard, cliquez sur le bouton Démarrer. 2. Déplacez les formulaires pour qu'ils soient tous les deux visibles. 3. Dans Form1, cliquez sur Quelle est la valeur de myVar ? 4. Dans le message, cliquez sur OK. 5. Dans Form2, cliquez sur Quelle est la valeur de myVar ? 6. Dans le message, cliquez sur OK.

Remarquez que le message de chaque formulaire affiche correctement la valeur 10 pour myVar.

7. Fermez Form1.

! Quittez Visual Studio .NET.

1. Dans la barre d'outils standard, cliquez sur le bouton Enregistrer tout. 2. Dans le menu Fichier, cliquez sur Quitter.

Remarque

Module 3 : Utilisation de variables et de tableaux 1

Vue d'ensemble

! Introduction aux types de données

! Utilisation de variables

! Portée des variables

! Conversion des types de données

! Création et utilisation de structures

! Stockage de données dansdes tableaux

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


Lorsqu'une application s'exécute, elle se sert de variables pour stocker des valeurs dans la mémoire temporaire : son but est de traiter des données et d'effectuer des calculs. Ce module explique comment nommer des variables, comment les déclarer, leur affecter des valeurs et les utiliser. Il s'attache également au stockage des données dans un tableau.


! décrire les différents types de données utilisables pour la déclaration de variables ;

! nommer, déclarer, initialiser et utiliser des variables et des constantes ; ! déclarer des variables avec différents niveaux de portée ; ! créer des structures de données définies par l'utilisateur ; ! convertir des valeurs de variables d'un type de données en un autre type ; ! stocker des données dans des tableaux.

Introduction

Objectifs

2 Module 3 : Utilisation de variables et de tableaux

Présentation multimédia : Présentation des variables


Cette animation multimédia explique la nature des variables et la façon dont les applications les utilisent pour traiter des données et calculer des valeurs.

Lorsque votre code est exécuté, il doit stocker différents types de données en mémoire, lesquels seront utilisés par d'autres parties de votre application. Vous pouvez, par exemple, avoir besoin de stocker les données entrées dans un formulaire en vue de les utiliser dans un autre formulaire. Ou encore, vous pouvez avoir besoin de stocker les informations de votre formulaire avant de les enregistrer dans une base de données. Vous pouvez également avoir besoin d'effectuer un calcul mathématique.

Dans Microsoft® Visual Basic®, tout comme dans la plupart des langages de programmation, les variables permettent de stocker des valeurs qui sont susceptibles de changer lorsque votre application est en cours d'exécution. Grâce aux variables, vous pouvez traiter pratiquement tous les types de données.

Supposons que vous disposez d'un formulaire permettant à l'utilisateur de saisir des nombres dans deux zones de texte puis de cliquer sur un bouton pour afficher le total. Étudions l'expression mathématique qui est nécessaire pour additionner les deux nombres. Vous pouvez accéder aux nombres par le biais des propriétés Textbox, mais les possibilités sont bien plus grandes si vous les stockez dans des variables. Vous pouvez utiliser des variables pour stocker les propriétés de zone de texte afin que Visual Basic puisse effectuer l'opération mathématique.

Imaginez que la mémoire de votre ordinateur est un entrepôt qui vous permet de stocker vos variables. Lorsque vous stockez des articles dans un entrepôt, vous devez prendre trois éléments en considération :

! Quel est l'espace nécessaire pour un article donné ? ! Quel type d'article stockez-vous ? ! Comment procédez-vous pour localiser l'article après l'avoir stocké ?

Introduction

Script d'animation


Étudions la syntaxe de la déclaration d'une variable. Examinons à présent une déclaration d'une variable de type entier afin de connaître la procédure de gestion de la taille, du type et de l'emplacement. L'instruction Dim réserve l'espace en mémoire, le nom de la variable Number1 est affecté à cet espace, As est un mot clé qui indique qu'un type de données doit suivre, et le type de données Integer définit la quantité d'espace et répertorie cette variable en tant que nombre. Lorsque les variables sont déclarées en tant qu'entiers, Visual Basic peut appliquer la fonctionnalité correcte correspondant aux entiers.

Visual Basic comprend de nombreux types de données que vous pouvez utiliser pour définir vos variables, notamment Integer, Double, String, ainsi que le type de données Object, qui gère toutes les variables de classes. Ce module explique comment utiliser ces types de données pour stocker et traiter les données dans vos applications.


Leçon : Introduction aux types de données

Système de types

communsSystème de types

communs

Types valeurTypes valeur

Types référenceTypes référence


Le type de données d'un élément de programmation fait référence au genre de données qu'il peut contenir et à la manière dont les données sont stockées. Le système de types communs définit les types de données pris en charge par le Common Language Runtime. Visual Basic .NET utilise des types de données correspondant directement aux types de données du système de types communs.

Cette leçon décrit le système de types communs, elle explique la façon dont Visual Basic .NET met en �uvre les types communs et montre comment choisir le type de données approprié pour une variable donnée.

Cette leçon développe les activités et les points suivants :

! Présentation du système de types communs ! Types de données ! Choix d'un type de données ! Application pratique : Choix du type de données


! décrire les types disponibles dans le système de types communs ; ! expliquer les différences entre les variables de type valeur et les variables de

type référence ; ! dresser une liste des types de données couramment utilisés et disponibles

dans Visual Basic .NET ; ! choisir le type de données approprié pour une variable.

Introduction




Présentation du système de types communs

Définit la manière dont les types fonctionnent dans le Common Language Runtime

Types de donnés prédéfinis

Structures définies par l'utilisateur

Énumérations

Chaînes

Tableaux

Classes

Types valeurTypes valeur Types référenceTypes référence

Système de types communsSystème de types communs


Le système de types communs définit la manière dont les types sont déclarés, utilisés et gérés par le Common Language Runtime. Chaque type de données utilisé dans Visual Basic .NET correspond directement à un type défini dans le système de types communs.

Le système de types communs joue un rôle fondamental dans la création d'applications pour la plate-forme Microsoft .NET. Il permet à un développeur de créer un projet dans Visual Basic .NET, puis de l'intégrer à un composant créé par un autre développeur dans Microsoft Visual C#� et de l'incorporer à une fonction écrite par un troisième développeur dans un autre langage compatible .NET. Tous ces morceaux sont intégrables dans une solution unique. Les compilateurs et outils de Microsoft Visual Studio® .NET et le Common Language Runtime dépendent du système de types communs pour obtenir :

! une intégration inter-langage ; ! un code de type sécurisé, ce qui signifie impérativement un accès autorisé et

bien défini aux types ; ! les outils qui gèrent et permettent une exécution du code extrêmement

performante.

Le système de types communs prend en charge deux catégories générales de types : les types valeur et les types référence.

Une variable de type valeur contient directement ses données. Chaque variable de type valeur dispose de son propre jeu de données ; les opérations sur une variable de ce type ne peuvent donc pas affecter une autre variable.

Une variable de type référence comprend une référence ou un pointeur dirigé vers la valeur d'un objet. Deux variables de type référence peuvent référencer le même objet. Les opérations sur une variable de ce type peuvent affecter l'objet référencé par une autre variable de type référence.

Introduction

Avantages du système de types communs

Types valeur contre types référence


Types de données

Type Visual Basic .NET

Type Visual Type Visual Basic .NETBasic .NET

Taille de stockageTailleTaille de de stockagestockage Plage des valeursPlagePlage des des valeursvaleurs

BooleanBoolean

DateDate

DecimalDecimal

DoubleDouble

IntegerInteger

SingleSingle

2 octets2 octets

8 octets8 octets

16 octets16 octets

8 octets8 octets

4 octets4 octets

4 octets4 octets

True ou FalseTrue ou False

De 0:00:00, le 1er janvier 0001, à 23:59:59, le 31 décembre 9999

De 0:00:00, le 1er janvier 0001, à 23:59:59, le 31 décembre 9999

Jusqu'à 29 chiffres significatifs avec des valeurscomprises jusqu'à to 7,9228 x 10 (signées)

Jusqu'à 29 chiffres significatifs avec des valeurscomprises jusqu'à to 7,9228 x 10 (signées)

De -4,94065645841246544E-324 à+1,79769313486231570E+308 (signées)

De -4,94065645841246544E-324 à+1,79769313486231570E+308 (signées)

De -2 147 483 648 à +2 147 483 647 (signées)De -2 147 483 648 à +2 147 483 647 (signées)

De -3,4028235E+38 à 1,401298E-45 (signées)De -3,4028235E+38 à 1,401298E-45 (signées)

StringString

28

VarieVarie De 0 à environ 2 milliards de caractères UnicodeDe 0 à environ 2 milliards de caractères Unicode


L'illustration ci-dessus classifie quelques types couramment utilisés dans Visual Basic .NET. Le terme signé indique que les chiffres peuvent être positifs ou négatifs, comme +48 ou �48.

Pour obtenir la liste complète et la description des types de données dans Visual Basic .NET, recherchez uniquement dans les titres « Liste des types de données » de la documentation Visual Basic .NET.

Introduction

Remarque


Choix d'un type de données

BooleanBoolean Conditions True ou FalseConditions True ou False ValeurValeur TrueTrue

Type de donnéesType de Type de donnéesdonnées GestionGestionGestion TypeTypeType ExempleExempleExemple

Short, Integer,Long et Byte

Short, Integer,Long et Byte

Tous les entiersTous les entiers ValeurValeur 23 (Integer)

23 (Integer)

Single, Double et Decimal

Single, Double et Decimal

Nombres composésd'entiers et de fractions

Nombres composésd'entiers et de fractions

ValeurValeur 9456,72(Decimal)

9456,72(Decimal)

DateDate Valeurs horaires et de date

Valeurs horaires et de date

ValeurValeur 12/02/200312:30:42

12/02/200312:30:42

StringString Caractères pouvant êtreimprimés et affichés

Caractères pouvant êtreimprimés et affichés

RéférenceRéférence « Maison »« Maison »

ObjectObject Pointeur vers la valeurd'un objet

Pointeur vers la valeurd'un objet

RéférenceRéférence myClassmyPerson

myClassmyPerson


Visual Basic ne demande pas de sélectionner explicitement un type de données lorsque vous déclarez une variable. Néanmoins, c'est une bonne habitude à prendre car vos applications seront plus fiables et moins gourmandes en mémoire. Le type de données détermine les valeurs autorisées pour une variable, et ces valeurs autorisées les opérations possibles sur cette variable.

Suivez les directives générales présentées dans l'illustration précédente pour choisir le type de données qui convient à une variable.

Si vous déclarez des variables sans choisir un type de données, le type de données Object par défaut leur est assigné. Ceci permet d'écrire des programmes rapidement, mais c'est au détriment de leur vitesse d'exécution. L'opération consistant à spécifier des types de données pour toutes vos variables s'appelle le typage fort. L'utilisation du typage fort est préconisée parce qu'il :

! réduit la quantité de mémoire utilisée par l'application ; ! permet au compilateur d'effectuer une vérification des types. Celle-ci permet

de récupérer les instructions susceptibles d'échouer au moment de l'exécution en raison d'une non-correspondance entre les variables et les valeurs ;

! procure une rapidité d'exécution à votre code ; ! active la prise en charge de vos variables par Microsoft IntelliSense® . Cette

technologie vous permet de voir leurs propriétés et les autres membres au fur et à mesure que vous tapez le code.

Introduction

Sélection d'un type de données

Typage fort


Application pratique : Choix du type de données

Analysez les exemples de données

Tenez compte de la taille et du type des données

Sélectionnez le type de données le plus dense


Travaillez par groupes de deux pour analyser les exemples de données et choisir le type approprié.

Choisissez le type de données le plus dense pour chaque exemple de données suivant :

! Adresse de la rue String. ____________________________________________________________

____________________________________________________________

! Montant de l'emprunt. Decimal. Utilisez le type Decimal pour la devise car les nombres de type Decimal ne sont pas arrondis contrairement aux nombres de type Single et Double. ____________________________________________________________

____________________________________________________________

! Numéro de téléphone String. ____________________________________________________________

____________________________________________________________

! Taux d'intérêt Single. ____________________________________________________________

____________________________________________________________

Introduction

Instructions


! Anniversaire Date. ____________________________________________________________

____________________________________________________________

! Numéro d'identification personnel String : lorsque les règles commerciales demandent que les caractères alphabétiques et numériques soient mélangés. Integer, Short ou Long (le plus petit type de données numériques approprié) : lorsqu'aucun caractère alphabétique n'est requis. ____________________________________________________________

____________________________________________________________


Leçon : Utilisation de variables

TâchesTâchesTâches

Attribution d'un nom aux variablesAttribution d'un nom aux variables

Déclaration de variablesDéclaration de variables

Affectation de valeurs aux variablesAffectation de valeurs aux variables

Utilisation de variablesUtilisation de variables


Avant de pouvoir utiliser une variable dans votre application, vous devez tout d'abord nommer et déclarer cette variable, puis lui affecter une valeur. Cette démonstration montre comment créer et utiliser des variables et des constantes.


! Présentation des variables ! Attribution d'un nom aux variables ! Déclaration de variables ! Incidences de Option Explicit sur les variables ! Affectation de valeurs aux variables ! Utilisation de variables ! Comparaison Variables / Constantes ! Application pratique : Recherche de bogues


! expliquer la finalité des variables ; ! suivre des règles et des directives établies pour nommer les variables ; ! déclarer les variables de type valeur et de type référence ; ! affecter des valeurs aux variables ; ! utiliser des variables dans une application ; ! établir la différence existant entre les variables et les constantes.

Introduction




Présentation des variables

! Les variables stockent des valeurs sujettes à modification lorsqu'une application s'exécute

! Une variable est composée des six éléments suivants :

ÉlémentÉÉlémentlément DescriptionDescriptionDescriptionNomNom Mot que vous utilisez pour vous référer à la variable dans le codeMot que vous utilisez pour vous référer à la variable dans le code

AdresseAdresse Emplacement de la mémoire où la valeur de la variable est conservéeEmplacement de la mémoire où la valeur de la variable est conservée

Type de donnéesType de données Type et taille d'origine des données pouvant être stockées par la variableType et taille d'origine des données pouvant être stockées par la variable

ValeurValeur Valeur au niveau de l'adresse de la variableValeur au niveau de l'adresse de la variable

PortéePortée Ensemble du code pouvant accéder à la variable et l'utiliserEnsemble du code pouvant accéder à la variable et l'utiliser

Durée de vieDurée de vie Période au cours de laquelle une variable est valide et utilisablePériode au cours de laquelle une variable est valide et utilisable


Stocker des valeurs temporairement est une opération fréquente lorsque vous effectuez des calculs dans Visual Basic, par exemple pour calculer plusieurs valeurs, les comparer et effectuer d'autres opérations diverses selon le résultat de la comparaison.

Vous utilisez des variables pour stocker des valeurs sujettes à modification lorsqu'une application s'exécute.

Une variable est composée des six éléments suivants :

Élément Description

Nom Mot que vous utilisez pour vous référer à la variable dans le code.

Adresse Emplacement de la mémoire où la valeur de la variable est conservée.

Type de données

Type et taille d'origine des données pouvant être stockées par la variable.

Valeur Valeur au niveau de l'adresse de la variable.

Portée Ensemble du code pouvant accéder à la variable et l'utiliser.

Durée de vie Période au cours de laquelle une variable est valide et utilisable. Sa valeur peut changer au fil du temps, mais elle garde toujours une valeur tant qu'elle est présente dans la mémoire.

Une variable peut être utilisée de bien des façons, par exemple :

! comme compteur enregistrant le nombre de fois qu'un événement est déclenché ;

! comme zone de stockage temporaire pour les valeurs de propriété ; ! comme emplacement pour contenir une valeur retournée par une fonction ; ! comme emplacement pour stocker les noms de répertoire ou de fichier.

Introduction

Définition

Éléments de variable

Exemples de variable


Attribution d'un nom aux variables

! Règles

" Commencer chaque nom de variable par un caractère alphabétique ou un trait de soulignement (_)

" Ne pas utiliser d'espaces ni de symboles

" Ne pas utiliser de mots clés tels que Integer ou Date

! Exemples

" NomClient (PascalCasing)

" SoldeCompte (camelCasing)


Lorsque vous déclarez des variables, il est important d'adopter une stratégie d'appellation. La clarté et la cohérence pour un meilleur suivi sont deux critères essentiels, surtout si d'autres personnes sont amenées à lire ou à gérer votre code.

Lorsque vous attribuez un nom à une variable dans Visual Basic .NET, les règles suivantes doivent être observées :

! Commencer chaque nom de variable par un caractère alphabétique ou un trait de soulignement (_).

! Ne pas utiliser d'espaces ni de symboles. ! Ne pas utiliser de mots clés tels que Integer ou Date.

Il est recommandé de se conformer aux directives suivantes lorsque vous nommez des variables :

! Choisir des noms significatifs et évocateurs, tels que numéroCompte. Bien qu'un nom de variable long puisse être fastidieux à taper lorsque l'on écrit un code, il n'en est pas moins plus lisible et plus facile à gérer.

! Commencer chaque mot distinct inclus dans le nom d'une variable publique par une majuscule, comme dans NomClient. Cette opération est appelée PascalCasing.

! Éviter l'emploi d'abréviations. Bien que l'utilisation d'un nom de variable tel que nocpte soit possible, votre code sera beaucoup plus lisible si vous choisissez le nom numéroCompte. Si vous devez utiliser des abréviations, assurez-vous qu'elles sont réutilisées dans toute l'application.

Introduction

Règles

Recommandations


! Utiliser un nom unique à l'intérieur de la portée d'une variable. La portée fait référence à l'ensemble du code qui reconnaît cette variable.

! Pour déclarer des variables locales et privées, commencer le premier mot par une minuscule, comme dans nouveauClient. Cette opération est appelée camelCasing.


Déclaration de variables

! Syntaxe" Dim nomDeLaVariable As Type

! Exemples de type valeur

! Exemples de type référence

Dim numberBooks As IntegerDim squareFootage As SingleDim numberBooks As IntegerDim squareFootage As Single

Dim myForm As FormDim userInput As StringDim myForm As FormDim userInput As String


Vous déclarez une variable pour spécifier son nom et ses caractéristiques. L'instruction de déclaration servant pour les variables de type valeur et de type référence est l'instruction Dim. L'emplacement et le contenu de la déclaration déterminent les caractéristiques de la variable.

Pour déclarer une variable, utilisez la syntaxe suivante :

Dim nomDeLaVariable As Type

Vous utilisez l'instruction Dim pour déclarer et allouer un espace de stockage aux variables intégrées dans des blocs, des procédures, des modules, des structures et des classes. Vous utilisez la clause As dans l'instruction Dim pour spécifier le type de données de la variable.

Le mot clé Dim est l'abréviation du mot dimension.

Les exemples suivants montrent comment déclarer des variables avec des types valeur prédéfinis :

Dim numberBooks As Integer Dim squareFootage As Single

Les exemples suivants montrent comment déclarer des variables avec des types référence prédéfinis :

Dim myForm As Form Dim userInput As String

Bien que vous utilisiez une syntaxe de déclaration similaire pour les variables de types valeur et les variables de types référence, l'exécution du code gère ces déclarations différemment. Une variable de type référence comprend toujours un pointeur dirigé vers une valeur de ce type ou une référence nulle. Une variable de type valeur contient la valeur réelle de la variable.

Introduction

Syntaxe

Remarque

Exemples de type valeur

Exemples de type référence


Incidences de Option Explicit sur les variables

! Lorsque Option Explicit est On (réglage par défaut)" Vous devez déclarer explicitement les variables avant de

les utiliser" Réduit les erreurs de logique et facilite la gestion du code" Entraîne une exécution du code plus rapide

! Lorsque Option Explicit est Off" Vous pouvez déclarer implicitement une variable par le

simple fait de l'utiliser dans votre code" Accroît le risque de conflits de noms et de comportements

inattendus provoqués par des erreurs d'orthographe" Entraîne une exécution du code plus lente


En règle générale, les variables doivent être déclarées explicitement dans votre application avant d'être utilisées. Tout risque d'erreur de logique est ainsi écarté et votre code est plus facile à gérer. Bien que cela soit déconseillé, vous pouvez utiliser des variables non déclarées préalablement dans votre application. C'est ce qu'on appelle une déclaration implicite.

Lorsque Option Explicit est On (réglage par défaut), vous devez déclarer explicitement les variables avant de les utiliser sinon le compilateur produira une erreur.

Lorsque Option Explicit est Off, vous pouvez déclarer implicitement une variable par le simple fait de l'utiliser dans votre code. Elle sera créée en tant que type objet. Bien qu'il soit pratique de déclarer implicitement des variables, cet usage accroît le risque de conflits de noms et de comportements inattendus provoqués par des erreurs d'orthographe. C'est également une utilisation peu avantageuse de la mémoire de stockage.

Supposez, par exemple, que la variable currentSalary contienne le salaire annuel d'un employé et qu'une procédure utilise cette variable dans une formule calculant la prime de l'employé. Imaginez que la variable currentSalary n'ait pas été tapée correctement, comme montré dans l'exemple suivant :

Dim currentSalary As Integer currentBonus = currentSalary * 0,10

Si Option Explicit est défini sur Off, le résultat de ce calcul donnera une prime de 0,00 EUR puisque la variable currentSalary aura été implicitement déclarée comme une nouvelle variable objet et donc initialisée sur vide. Que currentSalary soit inclus dans le calcul et Visual Basic le convertit automatiquement en 0. Si ce calcul est effectué de nombreuses fois à l'intérieur d'une structure en boucle, la vitesse d'exécution de votre application se ralentira considérablement car Visual Basic aura besoin de temps pour, à chaque fois, créer, initialiser et convertir la variable.

Introduction

Fonctionnement de Option Explicit

Exemple d'un avantage de Option Explicit


Vous pouvez définir Option Explicit sur On (activé) ou sur Off (désactivé) au niveau du projet dans l'environnement de développement.

! Définition de Option Explicit 1. Dans l'Explorateur de solutions, cliquez sur le nom du projet pour lequel

vous voulez définir Option Explicit. 2. Dans le menu Affichage, cliquez sur Pages de propriétés. 3. Développez le dossier Propriétés communes puis cliquez sur le dossier

Générer. 4. Sous Paramètres par défaut du compilateur, cliquez au choix sur Off ou

On dans la liste Option Explicit, puis cliquez sur OK.

Vous pouvez également définir Option Explicit sur On ou Off en plaçant l'instruction appropriée au début de votre code :

' Activation de Option Explicit Option Explicit On ' Désactivation de Option Explicit Option Explicit Off

Définition de Option Explicit


Affectation de valeurs aux variables

Vous pouvez effectuer les opérations suivantes :

! Affecter une valeur à une variable après la déclarationde cette dernière

! Affecter une valeur au moment de la déclaration de cette dernière

Dim birthday As Datebirthday = #3/9/1974#Dim birthday As Datebirthday = #3/9/1974#

Dim birthday As Date = #3/9/1974#Dim birthday As Date = #3/9/1974#


Avant de pouvoir utiliser des variables dans votre application, vous devez leur affecter des valeurs. Effectuez cette opération après ou pendant la déclaration d'une variable.

Pour affecter une valeur à une variable, utilisez l'opérateur d'assignation (=), comme montré dans l'expression suivante :

NomDeLaVariable=Valeur

La valeur située derrière l'opérateur est affectée à la variable située devant celui-ci.

Vous pouvez affecter des valeurs aux variables une fois qu'elles sont déclarées, comme montré dans l'exemple suivant :

Dim birthday As Date birthday = #3/9/1974#

Lorsque vous créez une variable à l'aide de l'instruction Dim, Visual Basic initialise automatiquement les variables numériques sur 0, les chaînes de texte sur vide ("") et les variables de type date sur Janvier 1, 0001.

Une autre solution consiste à affecter une valeur à une variable au moment de sa déclaration, comme montré dans l'exemple suivant :

Dim birthday As Date = #3/9/1974# Dim goodNews As String = "Votre chèque est au courrier." Dim testCondition As Boolean = True

Les valeurs Date doivent être insérées entre deux signes dièse (##) et les valeurs String mises entre guillemets ("").

Introduction

Syntaxe

Affectation d'une valeur après la déclaration

Affectation de valeurs au moment de la déclaration

Remarque


Utilisation de variables

Vous pouvez utiliser des variables pour :

! Stocker des valeurs issues d'une expression

! Stocker des informations saisies par l'utilisateur

! Stocker des objets

! Stocker des valeurs de propriété

! Renvoyer des valeurs

! Afficher des informations en sortie


Une fois que les variables sont nommées, déclarées et qu'elles ont reçu une valeur, vous pouvez les utiliser dans votre application. Les variables peuvent conserver la même valeur tout au long d'une application ou changer de valeur plusieurs fois selon la manière dont vous les utilisez.

Vous pouvez utiliser des variables pour stocker des données issues d'une expression, comme montré dans les exemples suivants :

newMessage = "Vous venez de recevoir du courrier !" unreadMail = totalMail � readMail

Vous pouvez utiliser des variables pour stocker des informations entrées par l'utilisateur, comme montré dans les exemples suivants :

userName = nameTextBox.Text applicationDate = appDateTextBox.Text

Vous pouvez utiliser des variables pour stocker des objets, comme montré dans l'exemple suivant :

myForm = mainForm

Introduction

Exemples


Comparaison Variables / Constantes

VariableVariableVariable ConstantConstantConstant

Declare with DimDeclare with Dim

Values change asapplication runs

Values change asapplication runs

Uses more memory thanconstants

Uses more memory thanconstants

Declare with ConstDeclare with Const

Values stay the same asapplication runs

Values stay the same asapplication runs

Uses less memory thanvariables

Uses less memory thanvariables

VariablesVariablesVariables ConstantesConstantesConstantes

Déclaration à l'aide de l'expression Dim

Déclaration à l'aide de l'expression Dim

Les valeurs changentlorsque l'application s'exécute

Les valeurs changentlorsque l'application s'exécuteUtilisation de la mémoireplus importante qu'avec des constantes

Utilisation de la mémoireplus importante qu'avec des constantes

Déclaration à l'aide de l'expression Const

Déclaration à l'aide de l'expression Const

Les valeurs restentidentiques lorsquel'application s'exécute

Les valeurs restentidentiques lorsquel'application s'exécuteUtilisation de la mémoireplus réduite qu'avec des variables

Utilisation de la mémoireplus réduite qu'avec des variables

Syntaxe :Const nomDeLaConstante As Type


Si une variable de votre programme contient une valeur immuable, envisagez de la stocker comme constante et non comme variable. Les constantes offrent une possibilité d'utiliser des noms significatifs à la place d'une valeur immuable (telle que π, quantité mathématique fixe).

Les constantes stockent des valeurs et, comme leur nom l'indique, demeurent constantes durant l'exécution d'une application. Les avantages liés à l'utilisation de constantes incluent entre autres :

! une meilleure lisibilité du code ; ! une utilisation de la mémoire plus réduite qu'avec des variables ; ! une plus grande facilité de gestion des modifications à l'échelle de

l'application.

Pour déclarer une constante, utilisez l'instruction Const avec la syntaxe suivante :

Const nomDeLaConstante As Type

Nommez et spécifiez des niveaux de portée pour les constantes en suivant les mêmes règles que celles des variables.

L'exemple suivant illustre la façon dont vous devez déclarer et utiliser une constante :

Dim area, radius, circumference As Double Const Pi As Double = 3,1415 area = Pi * radius ^ 2 circumference = 2 * Pi * radius

Introduction

Fonctionnement des constantes

Syntaxe

Exemple


Application pratique : Recherche de bogues

Dim Number For Double

Const Son's Birthday As Day

Dim Error.Message As Text

Dim $CurrentExpenses With Decimal

Dim 12Count As Integer


Travaillez par groupes de deux pour rechercher et éliminer les bogues sur la diapositive.

Récrivez les instructions de déclaration suivantes pour corriger les erreurs. Suivez les règles d'appellation et les recommandations instaurées pour les variables locales.

Dim 12Count As Integer Dim Number For Double Const Son's Birthday As Day Dim Error.Message As Text Dim $CurrentExpenses With Decimal

Dim count As Integer

Dim number As Double

Const sonBirthday As Date

Dim errorMessage As String

Dim currentExpenses As Decimal

________________________________________________________________

________________________________________________________________

________________________________________________________________

________________________________________________________________

________________________________________________________________

Introduction

Instructions


Leçon : Portée des variables

Module ou classe Public Public A As Integer

Module ou classe FriendFriend B As Date

Module ou classe PrivatePrivate c As String

Procédure ou blocDim d As Integer

La variable A est accessible à partirde n'importe quel projet de la solution

La variable A est accessible à partirde n'importe quel projet de la solution

La variable B est accessible n'importe où dans le projet

La variable B est accessible n'importe où dans le projet

La variable c est accessible n'importe où dans le module

La variable c est accessible n'importe où dans le module

La variable d estaccessible uniquement dans la procédure ou le bloc

La variable d estaccessible uniquement dans la procédure ou le bloc


Lorsque vous utilisez des variables, vous devez vous assurer que toutes les parties du code qui s'y référent ont accès à ces variables. Sinon, vous devrez peut-être restreindre l'accès de certaines variables. L'ensemble du code pouvant se référer à une variable par son nom s'appelle la portée d'une variable. Cette leçon décrit les différents niveaux de portée s'appliquant aux variables et explique comment s'assurer de la bonne portée de chaque variable dans votre application.


! Présentation de la notion de portée ! Déclaration de variables locales ! Déclaration de variables statiques ! Déclaration de variables de module ! Démonstration multimédia : Définition de niveaux d'accès aux variables ! Application pratique : Définition de niveaux d'accès aux variables


! expliquer les différents niveaux de portée des variables ; ! choisir le niveau d'accès approprié pour une variable, en se basant sur la

façon dont elle est utilisée au sein d'une application ; ! déclarer des variables locales dans des blocs et dans des procédures ; ! déclarer des variables locales statiques ; ! déclarer des variables de module pour une utilisation dans des modules, des

classes, des projets, des solutions et des espaces de noms standard.

Introduction




Présentation de la notion de portée

Niveau d'accès duconteneur de la variable

Endroit de déclarationde la variable

Facteurs qui affectent la portée Bloc

Procédure

Module, classe oustructure

Private

Public

Friend

Définition : La portée est l'ensemble de tout le code se référant à une variable par son nom

Niveau d'accès de la variable


La portée est une des premières choses dont vous tiendrez probablement compte lorsque vous déclarerez des variables car si vous utilisez une variable hors de sa portée, le compilateur génère une erreur.

Pour savoir comment une portée fonctionne avec des variables, vous devez tout d'abord vous familiariser avec les termes et les définitions du tableau suivant.

Terme Définition

Portée des variables

Ensemble de tout le code se référant à une variable par le nom qu'il lui a été attribué sans qualificateurs.

Bloc Bloc de code commençant par une condition comme If ou While et se terminant par une instruction End, Loop ou Next.

Procédure Bloc de code commençant par une instruction de déclaration comme Sub et se terminant par une instruction End.

Module Fichier regroupant les procédures communes et les données globales pour les rendre accessibles à une utilisation élargie sur un ou plusieurs projets.

Assembly Fichier exécutable autonome dans lequel divers fichiers sont compilés lorsqu'une solution est élaborée.

Modificateur d'accès

Mot clé comme Public ou Friend utilisé pour spécifier le niveau d'accès d'une variable ou son conteneur (module, classe ou structure).

Introduction

Définitions


Vous assignez une portée à une variable lorsque vous la déclarez. Trois facteurs primordiaux ont une incidence sur la portée d'une variable :

! l'endroit où vous la déclarez : à l'intérieur d'un bloc, d'une procédure, d'un module, d'une classe ou d'une structure ;

! le niveau d'accès (Public, Friend ou Private) du module, de la classe ou de la structure où elle est déclarée. La portée d'une variable ne peut pas excéder la portée de son conteneur ;

! la syntaxe que vous utilisez pour déclarer la variable (Dim, Private, Friend ou Public).

Une variable peut se voir attribuer l'un des niveaux de portée suivants :

Niveau de portée Description

Bloc Disponible uniquement à l'intérieur du bloc de code où la variable est déclarée.

Procédure Disponible uniquement au sein de la procédure dans laquelle la variable est déclarée.

Module Disponible pour tout le code contenu dans la classe, la structure ou le module dans lequel la variable est déclarée.

Espace de noms Disponible pour tout le code contenu dans l'espace de noms.

La définition de la portée d'une variable de module peut être affinée en déclarant un modificateur d'accès, Private, Public ou Friend, au moment de sa déclaration. Les modificateurs d'accès seront étudiés à la rubrique « Déclaration de variables de module » dans cette leçon.

Pour en savoir plus sur la portée, consultez la documentation Visual Basic .NET.

Incidences sur la portée

Niveaux de portée

Remarque


Déclaration de variables locales

If x < > 0 ThenDim blockNumber As IntegerblockNumber = x + 1

End If

If x < > 0 ThenDim blockNumber As IntegerblockNumber = x + 1

End If

Sub ShowMessage_Click( )Dim myVariable As String' Insérer du code pour ajouter des fonctionnalités

End Sub

Sub ShowMessage_Click( )Dim myVariable As String' Insérer du code pour ajouter des fonctionnalités

End Sub

Exemple de variable locale : au niveau du bloc

Exemple de variable locale : au niveau de la procédure

Endroit de déclarationEndroitEndroit de de déclarationdéclaration

BlocBloc

Mot cléMot Mot cléclé

DimDim

Modificateurd'accès

ModificateurModificateurdd''accèsaccès

AucunAucun

PortéePortéePortée

Niveau du blocNiveau du bloc

ProcédureProcédure DimDim AucunAucun Niveau de la procédureNiveau de la procédure


Les variables déclarées dans un bloc ou dans une procédure sont appelées variables locales, leur portée est donc limitée à la procédure ou au bloc dans lequel elles sont déclarées. Lorsque vous choisissez une portée, rappelez-vous que les variables locales représentent une bonne solution pour tout type de calcul temporaire. Elles utilisent de la mémoire uniquement pendant l'exécution de leur procédure et leurs noms ne sont pas sujets à conflit.

Pour déclarer une variable locale, utilisez l'instruction Dim avec la syntaxe suivante :

Dim nomDeLaVariable As Type

L'exemple suivant illustre la façon dont vous devez déclarer une variable locale nommée blockNumber avec une portée de niveau de bloc :

If x <> 0 Then Dim blockNumber As Integer blockNumber = 1 / x End If

D'une façon générale, restreindre au maximum la portée d'une variable au moment de sa déclaration est une bonne habitude de programmation à prendre. (La portée au niveau du bloc est la plus restrictive.) En réduisant la portée, vous économisez de la mémoire et vous diminuez les risques de voir votre code se référer à la mauvaise variable.

Introduction

Syntaxe

Exemple de portée au niveau du bloc

Remarque


L'exemple suivant illustre la façon dont vous devez déclarer une variable locale name associée à une portée de niveau de procédure :

Sub ShowMessage_Click( ) Dim name As String name = NameTextBox.Text MessageBox.Show("Bienvenue, " & name & "!") End Sub

Dans cet exemple, le contenu de la zone de texte Nom est placé dans la variable name ; cette variable est donc utilisée comme élément de l'invite affiché dans le message.

Exemple de portée au niveau de la procédure


Déclaration de variables statiques

! Endroit : Déclarez les variables dans un bloc ou une procédure

! Syntaxe : Utilisez un mot clé statique (aucun modificateur d'accès)

" Static nomDeLaVariable As Type

! Exemple

Sub AddItem_Click( )Static items As Integer

' Ajouter 1 au compteuritems += 1MessageBox.Show (" Le compte est actuellement de " & items)

End Sub

Sub AddItem_Click( )Static items As Integer

' Ajouter 1 au compteuritems += 1MessageBox.Show (" Le compte est actuellement de " & items)

End Sub


La durée de vie d'une variable locale commence au moment où une procédure l'appelle et s'achève lorsque celle-ci se termine. Une fois la durée de vie de la variable locale écoulée, l'instance de la variable est détruite et sa valeur perdue. Il existe quelques cas où vous pouvez souhaiter prolonger la durée de vie d'une variable locale au-delà de l'existence d'une procédure. Par exemple, si vous voulez qu'une procédure effectue une action spécifique au premier appel et qu'elle reste inactive les fois suivantes. Déclarez simplement une variable statique pour accomplir cette fonctionnalité.

Une variable statique survit tant que l'application s'exécute. Ces variables statiques demeurent en vie et conservent leurs valeurs les plus récentes entre les appels faits à la procédure dans laquelle elles sont déclarées. Toutefois, elles sont inaccessibles dans les autres procédures en utilisant le code.

Pour déclarer une variable locale statique, utilisez la syntaxe suivante :

Static nomDeLaVariable As Type

Introduction

Définition

Syntaxe


Les variables statiques sont utiles pour la mise à jour des compteurs utilisés exclusivement au sein d'une procédure. L'exemple suivant montre comment déclarer une variable statique enregistrant le nombre de fois que la procédure AddItem s'exécute. À chaque exécution, la valeur stockée dans items (articles) est incrémentée de 1.

Sub AddItem_Click( ) Static items As Integer ' Ajouter 1 au compteur items += 1 ' Utiliser le et commercial(&) pour combiner une chaîne ' avec une variable Messagebox.Show("Le compte est actuellement de " & items) End Sub

Vous pouvez obtenir des résultats identiques à ceux du précédent code en déclarant items (articles) comme variable de module. Toutefois, d'autres procédures auront accès à la variable et elles pourront la modifier. L'utilisation d'une variable statique est recommandée, sauf si la portée au niveau du module est voulue.

Exemple

Remarque


Déclaration de variables de module

Modificateur d'accèsModificateurModificateur dd''accèsaccèsPrivatePrivate

PortéePortéePortéeModuleModule

FriendFriend ProjetProjet

PublicPublic SolutionSolution

Private myModuleMessage As StringFriend myProjectMessage As StringPublic mySolutionMessage As String

Private myModuleMessage As StringFriend myProjectMessage As StringPublic mySolutionMessage As String

! Déclarez la variable dans un module, une classe ou une structure

! Exemples


Les variables qui ne sont pas déclarées dans une procédure, mais dans un module, une classe ou une structure s'appellent des variables de module. Après avoir déclaré une variable de module, vous pouvez lui affecter une valeur, lui assigner une portée par l'intermédiaire d'un modificateur d'accès et l'utiliser à l'intérieur même de cette portée.

Pour déclarer une variable de module, utilisez la syntaxe suivante :

ModificateurAccès nomDeLaVariable As Type

Faites votre choix parmi les modificateurs d'accès existants, y compris ceux figurant dans le tableau suivant.

Modificateur d'accès Portée Description

Private Module Accessible de n'importe quel endroit de la classe, de la structure ou du module dans lequel la variable est déclarée. Si vous déclarez une variable de module au moyen du mot clé Dim, son accès est Private par défaut.

Friend Projet Accessible de n'importe quelle partie du projet, mais inaccessible de l'extérieur.

Public Solution Accessible de n'importe quelle partie de la solution. Il n'existe aucune restriction sur l'utilisation des variables Public.

La portée d'une variable de module est non seulement déterminée par le modificateur d'accès utilisé au moment de la déclaration, mais également par le niveau d'accès du module, de la classe ou de la structure dans lequel vous la déclarez. La portée d'une variable ne peut pas excéder la portée de son conteneur. Pour plus d'informations sur l'accessibilité et obtenir la liste complète des modificateurs d'accès, consultez la documentation Visual Basic .NET.

Introduction

Syntaxe

Remarque


L'exemple suivant illustre la façon dont vous devez déclarer et utiliser une variable associée à une portée de niveau de module :

' Placer la déclaration suivante au niveau du module ' (et non dans une procédure) Private myModuleMessage As String ' ... Sub InitializeModuleVariable( ) myModuleMessage = "Cette variable a une portée de niveau de module." End Sub ' ... Sub UseModuleVariable( ) MessageBox.Show(myModuleMessage) End Sub

L'exemple suivant illustre la façon dont vous devez déclarer et utiliser une variable associée à une portée de niveau de projet :

' Placer la déclaration suivante au niveau du module ' (et non dans une procédure) Friend MyProjectMessage As String ' ... Sub InitializeProjectVariable( ) MyProjectMessage = "Cette variable a une portée de niveau de projet." End Sub ' ... Sub UseProjectVariable( ) MessageBox.Show(MyProjectMessage) End Sub

L'exemple suivant illustre la façon dont vous devez déclarer et utiliser une variable associée à une portée de niveau de solution :

' Placer la déclaration suivante au niveau du module ' (et non dans une procédure) Public MySolutionMessage As String ' ... Sub InitializeSolutionVariable( ) MySolutionMessage = _ "Cette variable a une portée de niveau de solution." End Sub ' ... Sub UseSolutionVariable( ) MessageBox.Show(MySolutionMessage) End Sub

Exemple de portée au niveau du module

Exemple de portée au niveau du projet

Exemple de portée au niveau de la solution


Présentation multimédia : Définition de niveaux d'accès aux variables


Cette démonstration multimédia montre comment déclarer une variable à différents niveaux de portée. Vous découvrirez l'endroit où déclarer les variables et la manière dont vous devez spécifier les bons modificateurs d'accès pour attribuer plusieurs niveaux différents de portée.

Introduction


Application pratique : Définition de niveaux d'accès aux variables

Examinez le code de démarrage pour rechercher une variable non déclarée

Déclarez la variable dans différents endroitspour obtenir différents niveaux de portée

Déterminez quel modificateur d'accèsutiliser lors de la déclaration d'une variable


Au cours de cette application pratique, vous examinerez le code de démarrage pour y trouver une variable non déclarée. Vous déterminerez ensuite l'endroit où la variable doit être déclarée et vous choisirez le modificateur d'accès à utiliser pour lui attribuer différents niveaux de portée.

! Ouverture du code de démarrage de l'application pratique 1. Démarrez Visual Studio .NET. 2. Ouvrez le fichier Scope.sln situé dans dossier_installation\Practices\

Mod03\Scope\Starter.

! Définition de niveaux d'accès à la variable 1. Ouvrez l'éditeur de code pour Form1.vb. 2. Recherchez la variable non déclarée myVariable dans le code de démarrage. 3. Déclarez myVariable comme variable locale ayant une portée de niveau de

procédure.

L'environnement de développement souligne les erreurs de code en bleu. Si vous trouvez une erreur, placez le pointeur de la souris sur le code erroné. Une info-bulle apparaîtra pour vous aider à corriger l'erreur.

4. Déclarez myVariable comme variable de module disponible dans toute la classe Form1.

5. Déclarez myVariable comme variable de module disponible dans tout le projet.

6. Déclarez myVariable comme variable de module disponible dans toute la solution.

Les fichiers de solution correspondant à cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod03\Scope\Solution.

Introduction

Instructions

Conseil

Fichiers de solution


Leçon : Conversion des types de données

! Présentation des fonctions de conversion

! Conversion explicite de types de données

! Mécanisme de conversion implicite de données


Le processus de conversion d'une valeur d'un type de données en un autre type s'appelle conversion ou casting. Vous pouvez convertir explicitement des valeurs d'un type en un autre type avant leur utilisation : vous évitez ainsi la présence de bogues dans votre code dont l'exécution se trouve accélérée. Visual Basic .NET peut également effectuer quelques conversions de types de données automatiquement ou implicitement, comme la conversion de chaînes en entiers. Toutefois, les conversions implicites peuvent produire des résultats inattendus.

Au cours de cette leçon, vous apprendrez à faire la différence entre la conversion explicite et la conversion implicite. Vous découvrirez également comment utiliser les fonctions de conversion dans Visual Basic .NET pour convertir explicitement des types de données.

Cette leçon comprend les points suivants :

! Présentation des fonctions de conversion ! Conversion explicite de types de données ! Mécanisme de conversion implicite de données


! décrire quelques fonctions de conversion courantes ; ! convertir des variables explicitement d'un type de données en un autre type ; ! expliquer la façon dont la conversion implicite de données fonctionne et

dans quelle situation ne pas l'utiliser.

Introduction




Présentation des fonctions de conversion

Définition : Les fonctions de conversion permettent de convertir explicitement une valeur d'un type de données en un autre

Valeur Integer1234

Valeur String "1234"CStrCStr

Valeur Double 567,9894

Valeur Integer568CIntCInt

Valeur String"12 février 1992"

Valeur Date#2/12/92#CDateCDate

Devient


Vous pouvez utiliser des fonctions de conversion pour forcer le résultat d'une opération à apparaître sous la forme d'un type de données particulier au lieu du type de données par défaut. Par exemple, vous pouvez convertir une valeur de chaîne en une valeur d'entier.

Les fonctions de conversion permettent de convertir explicitement une valeur d'un type de données en un autre type.

Visual Basic offre une liste complète des fonctions de conversion et inclut celles détaillées dans le tableau suivant.

Fonction de conversion

Convertit dans le type de données

Types de données disponibles pour la conversion

CStr String Tout type numérique, Boolean, Char, Date, Object

CInt Integer Tout type numérique, Boolean, String, Object

CDbl Double Tout type numérique, Boolean, String, Object

CDate Date String, Object

CType Type spécifié Même type que celui autorisé pour la fonction de conversion correspondante.

Introduction

Définition

Exemples de fonctions de conversion


Le code suivant montre comment utiliser plusieurs fonctions de conversion :

Private Sub Button1_Click(...) ' Utiliser la conversion de chaîne en Integer Dim myVariable As Integer myVariable = 1234 MessageBox.Show(myVariable) MessageBox.Show(CStr(myVariable) & "1") End Sub Private Sub Button2_Click(...) ' Utiliser la conversion d'entier en Double Dim myVariable As Double myVariable = 567,9894 MessageBox.Show(myVariable) MessageBox.Show(CInt(myVariable)) End Sub Private Sub Button3_Click(...) ' Utiliser la conversion de date en String Dim myVariable As String myVariable = "Février 12, 1992" MessageBox.Show(myVariable) MessageBox.Show(CDate(myVariable)) End Sub


Conversion explicite de types de données

DéclarezDéclarez uneune variable en variable en tanttant queque type de type de donnéesdonnées StringStringDim Dim myStringmyString As StringAs String

ConvertissezConvertissez la la valeurvaleur String en String en valeurvaleur IntegerIntegermyIntegermyInteger = CInt(= CInt(myStringmyString))

DéclarezDéclarez uneune autreautre variable en variable en tanttant queque type de type de donnéesdonnéesIntegerIntegerDim Dim myIntegermyInteger As IntegerAs Integer

AffectezAffectez uneune valeurvaleur àà la variable Stringla variable StringmyStringmyString = = "1234"1234"

11

22

33

44

ExempleExempleExemple

Syntaxe : nomDeLaVariable = FonctionDeConversion(Expression)


Il est recommandé d'utiliser les fonctions de conversion pour convertir explicitement des valeurs avant leur utilisation. Les conversions explicites s'exécutent plus rapidement que les conversions implicites car il n'y a pas d'appel de procédure pour effectuer la conversion. Une conversion implicite est la conversion automatique d'une valeur d'un type de données en un autre type.

Pour utiliser une fonction de conversion, tapez-la dans la partie de droite d'une instruction d'assignation en vous servant de la syntaxe suivante :

NomDeLaVariable = FonctionDeConversion(Expression)

Le paramètre expression peut être n'importe quelle expression valide, tel qu'une variable, le résultat d'une fonction ou une valeur constante.

Une conversion étendue transforme une valeur en un type de données pouvant contenir n'importe quelle valeur possible des données originales, comme la conversion d'un Integer en Long. Une conversion restrictive transforme une valeur en un type de données ne pouvant pas forcément contenir certaines valeurs possibles, comme la transformation de String en Integer, ou de Long en Integer.

Introduction

Syntaxe

Conversions étendues ou restrictives ?


L'exemple suivant montre comment utiliser les fonctions de conversion CStr et CDbl pour écrire du code convertissant des pieds et des pouces en mètres.

Private Sub Calculate_Click(...) Dim feet As Double, inches As Double Dim millimeters As Double, meters As Double 'Tout d'abord, extraire les pieds et les pouces des zones 'de texte. 'La propriété Text renvoie une chaîne, mais il nous faut 'un double, 'donc CDbl( ) est utilisée pour effectuer la conversion. feet = CDbl(FeetTextBox.Text) inches = CDbl(InchesTextBox.Text) 'Ensuite, convertir les pieds et les pouces en 'millimètres. millimeters = (inches * MillimetersPerInch) + _ (feet * MillimetersPerInch * InchesPerFoot) 'Convertir les millimètres en mètres. meters = millimeters / 1000 'Afficher le résultat dans une étiquette. Étant donné que 'la propriété Text 'est une chaîne, utiliser CStr( ) 'pour convertir le double. MeterResult.Text = CStr(meters) End Sub

Dans cet exemple, il est entendu que les valeurs constantes MillimetersPerInch et InchesPerFoot ont été déclarées et que des valeurs appropriées leur ont été affectées au niveau du module.

L'exemple suivant montre comment utiliser la fonction CInt pour convertir une valeur Double en Integer :

Dim myDouble As Double Dim myInt As Integer myDouble = 2345,5678 ' Définir myInt sur 2346 myInt = CInt(myDouble)

L'exemple suivant montre comment utiliser la fonction CDate pour convertir des chaînes en valeurs Date. Généralement, le codage en dur des dates et des heures en tant que chaînes (comme montré dans cet exemple) est déconseillé. Utilisez des littéraux de date et d'heure, tels que #Fév 12, 1969# et #4:45:23 PM# à la place.

Dim myDateString, myTimeString As String Dim myDate, myTime As Date myDateString = "Février 12, 1969" myTimeString = "4:35:47 PM" ' ... ' Convertit en type de données Date myDate = CDate(myDateString) myTime = CDate(myTimeString)

Exemple

Exemple de CInt

Exemple de CDate


Mécanisme de conversion implicite de données

! Les types de données sont convertis automatiquement! Aucune syntaxe spéciale n'est nécessaire dans le code! Exemple de conversion implicite de données :

! Inconvénients :" Suceptibles de produire des résultats inattendus" Exécution du code ralentie

! L'option Strict ne permet aucun type de conversion implicite restrictive

Dim sequence As StringDim number As Integer' ...sequence = "1234"number = sequence' La valeur de la séquence est convertie implicitement' en valeur Integer

Dim sequence As StringDim number As Integer' ...sequence = "1234"number = sequence' La valeur de la séquence est convertie implicitement' en valeur Integer


Visual Basic peut effectuer quelques conversions de types de données implicitement. On appelle conversion implicite la conversion automatique d'une valeur d'un type de données en un autre type telle qu'elle est requise par le code dans lequel le type de données est utilisé. Aucune syntaxe spéciale n'est nécessaire dans le code source.

Si vous placez la chaîne "1234" dans une variable Integer, Visual Basic la convertira automatiquement en nombre entier. De même, si une chaîne telle que "100" est ajoutée à une valeur numérique dans la formule "100" + 10, Visual Basic convertit implicitement la chaîne en valeur de nombre entier 100 et l'ajoute à 10.

Il existe des inconvénients à laisser Visual Basic effectuer des conversions implicites car celles-ci sont susceptibles de produire des résultats inattendus. Par exemple, si deux chaînes sont additionnées entre elles, Visual Basic concatène les chaînes sans tenir compte de leur contenu ; ainsi "100" + "10" = "10010". Si une conversion restrictive est nécessaire, les données peuvent être tronquées. De plus, lorsque Visual Basic effectue des conversions implicites, l'exécution du code est ralentie en raison du travail supplémentaire que Visual Basic doit accomplir.

Lorsque le commutateur Option Strict est défini sur Off (réglage par défaut), toutes les conversions étendues et restrictives peuvent être assurées implicitement. Lorsque le commutateur Option Strict est défini sur On, seules les conversions étendues sont autorisées implicitement ; les conversions restrictives doivent être explicites sinon le compilateur produit une erreur.

Pour plus d'informations sur le commutateur Option Strict du compilateur, consultez la documentation Visual Basic .NET.

Introduction

Exemples

Inconvénients

Incidences de Option Strict sur les conversions de données

Remarque


Atelier 3.1 : Création et utilisation de variables

! Exercice 1 : Utilisation de variables statiques

! Exercice 2 : Création, utilisation et conversion de variables



! déclarer et utiliser des variables ; ! utiliser des fonctions de conversion de données.

Avant de travailler dans cet atelier, vous devez :

! bien connaître l'environnement de développement Visual Studio .NET ; ! avoir acquis une expérience dans la création, l'ouverture et la modification

de formulaires et de contrôles ; ! posséder une expérience dans l'écriture de code pour des événements de

formulaire.

Cet atelier met l'accent sur les concepts dans ce module, par conséquent il est possible qu'il ne se conforme aux recommandations de sécurité émises par Microsoft.

Objectifs


Remarque


Dans les ateliers des modules 2, 4, 5, 6 et 12 du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET, vous créerez une application permettant d'estimer les échéances de remboursement d'un emprunt. Vous concevrez l'application dans son intégralité et par étapes ; chaque étape se basant sur le code créé dans l'atelier précédent.

Bien que le contexte de l'atelier 3.1 soit similaire à l'application de calcul des échéances d'un emprunt, cet atelier ne fait pas partie de cette application. Vous n'utiliserez donc pas le code de la solution de l'atelier 3.1 dans les autres ateliers du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Dans l'atelier 3.1, vous ouvrirez une solution Visual Studio déjà existante qui contient un formulaire. Vous déclarerez et utiliserez les variables nécessaires à une application de simulation d'emprunt, puis vous déclarerez et incrémenterez une variable statique et utiliserez les fonctions de conversion de type de données.

Les fichiers de solution de cet atelier se trouvent dans les dossiers dossier_installation\Labfiles\Lab031\Ex01\Solution et dossier_installation\Labfiles\Lab031\Ex02\Solution.

Scénario




Exercice 1 Utilisation de variables statiques

Dans cet exercice, vous déclarerez une variable statique pour compter le nombre de fois que les utilisateurs auront cliqué sur le bouton Confirmer les choix dans le formulaire, vous incrémenterez la variable chaque fois qu'ils cliquent sur ce bouton et afficherez sa valeur dans un message.

! Ouverture du projet des variables de l'emprunt 1. Démarrez Visual Studio .NET. 2. Ouvrez le projet LoanVariables.sln situé dans le dossier

dossier_installation\Labfiles\Lab031\Ex01\Starter. 3. Ouvrez le formulaire principal à la fois en mode Design et dans l'éditeur de

code pour vous familiariser avec le code et les contrôles existants.

Cet atelier réalisé pour le présent module ne sera pas utilisé comme fichier de démarrage pour les autres modules du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET. Toutefois, les variables créées seront identiques à celles du code de démarrage de l'atelier 4.1, « Création et utilisation de procédures », du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

! Ajout d'une variable statique pour compter le nombre de clics utilisateur sur Confirmer les choix

1. Ouvrez l'éditeur de code pour le formulaire Main.vb. 2. Dans le gestionnaire d'événements ConfirmButton_Click, ajoutez une

variable statique Integer nommée viewChoices. 3. Incrémentez la valeur de la variable viewChoices de 1 chaque fois que

l'utilisateur clique sur Confirmer les choix. Cette variable permet de comptabiliser les clics de l'utilisateur sur Confirmer les choix.

4. Communiquez ce nombre à l'utilisateur au moyen de la fonction MessageBox, comme suit : MessageBox.Show("Nombre de possibilités d'emprunt affichées : " _ & viewChoices)

5. Votre code doit ressembler au texte suivant :

Private Sub ConfirmButton_Click(...) Static viewChoices As Integer viewChoices += 1 MessageBox.Show("Nombre de possibilités d'emprunt affichées : " & viewChoices) End Sub

Important


! Exécution et test de l'application

1. Pour exécuter une application, cliquez sur le bouton Démarrer. 2. Cliquez plusieurs fois sur Confirmer les choix.

Que se passe-t-il ? Le message doit afficher avec précision le nombre de fois que vous avez cliqué sur Confirmer les choix.

3. Quittez l'application.


Exercice 2 Création, utilisation et conversion de variables

Dans cet exercice, vous ajouterez des variables et des constantes au formulaire principal pour accepter et traiter les données entrées par l'utilisateur dans la zone de texte et la zone combinée. Vous modifierez le gestionnaire d'événements ConfirmButton_Click pour autoriser la conversion des données en un type approprié en vue de leur affichage.

! Ajout de variables pour gérer les entrées utilisateur et calculer les intérêts

1. Ouvrez l'éditeur de code pour le fichier Main.vb. Si vous n'avez pas fait l'exercice 1, utilisez le fichier LoanVariables.sln du dossier dossier_installation\Labfiles\Lab031\Ex02\Starter.

2. Ajoutez des variables de niveau formulaire pour stocker le montant de l'emprunt, le taux d'intérêt annuel, le taux d'intérêt mensuel, le nombre d'échéances, comme illustré dans le tableau suivant :

Nom de la variable Type de données

loanAmount Double

interestRate Double

monthRate Double

numberOfPayments Integer

Votre code doit ressembler au texte suivant : Dim loanAmount As Double Dim interestRate As Double Dim monthRate As Double Dim numberOfPayments As Integer

! Ajout de variables constantes pour les échéances et la durée de l'emprunt

• Ajoutez deux constantes de niveau formulaire pour stocker le nombre de mois par an et une durée d'emprunt sur 5 ans. Votre code doit ressembler au texte suivant : Private Const conversionPeriod As Integer = 12 Private Const loanLength As Integer = 5

À ce stade, vous codez en dur la valeur de la variable loanLength sur 5 ans pour les besoins exclusifs de cet atelier. Lorsque vous continuerez le développement de l'application sur l'emprunt dans les autres ateliers, vous affecterez la valeur appropriée à loanLength en fonction du choix effectué par l'utilisateur parmi plusieurs possibilités.

Important


! Affectation de valeurs aux variables et affichage de ces valeurs pour confirmation

1. Dans le gestionnaire d'événements ConfirmButton_Click, écrivez le code permettant d'affecter les valeurs entrées par l'utilisateur dans les zones de texte aux variables loanAmount et interestRate, comme illustré dans le tableau suivant.

Nom de la variable Zone de texte correspondante

loanAmount LoanTextBox

interestRate RateComboBox

Dans les instructions d'assignation, utilisez la fonction de conversion CDbl pour convertir les données de la zone de texte en type de données Double utilisables dans des calculs. Votre code doit ressembler au texte suivant : loanAmount = CDbl(LoanTextBox.Text) interestRate = CDbl(RateComboBox.Text)

2. Divisez le taux d'intérêt annuel par la période de conversion pour calculer

un taux d'intérêt mensuel et assignez le résultat de ce calcul à la variable monthRate, comme suit : monthRate = interestRate / conversionPeriod

3. Calculez le nombre total d'échéances en multipliant la durée de l'emprunt

par la période de conversion et assignez ce résultat à la variable numberOfPayments comme suit : numberOfPayments = loanLength * conversionPeriod

! Création de messages permettant à l'utilisateur de confirmer les données entrées

• Dans le gestionnaire d'événements ConfirmButton_Click, ajoutez juste avant le message existant, des messages permettant de créer des messages de confirmation pour le montant de l'emprunt, le taux d'intérêt annuel, le taux d'intérêt mensuel et le nombre total d'échéances. Votre code doit ressembler au texte suivant : MessageBox.Show("Montant de l'emprunt : " & loanAmount) MessageBox.Show("Taux d'intérêt annuel : " & interestRate) MessageBox.Show("Taux d'intérêt mensuel : " & _ monthRate) MessageBox.Show("Nombre total d'échéances : " & _ numberOfPayments)

! Exécution et test de l'application 1. Pour exécuter l'application, dans la barre d'outils standard, cliquez sur le

bouton Démarrer. 2. Tapez ou sélectionnez les informations appropriées dans le formulaire

principal, cliquez sur Confirmer les choix, puis sur OK dans les messages qui s'affichent. Vous pouvez laisser la durée de 5 ans sélectionnée dans la zone Durée du prêt puisque la durée de l'emprunt est codée en dur pour cet atelier.


3. Les informations s'affichent-t-elle correctement ? Si, par exemple, vous prenez 200 000 comme montant pour l'emprunt et 4,5 comme taux d'intérêt, le taux d'intérêt mensuel doit être de 0,375 et le nombre total d'échéances 60.

4. Une fois la vérification effectuée, quittez la solution, puis Visual Studio.


Leçon : Création et utilisation de structures

Informations connexes du groupe #### structure unique

Nom de l'employéNom de l'employé

Date de naissanceDate de naissance

Date d'embaucheDate d'embauche

FonctionFonction

Stucture de donnéesEmployeeStucture de donnéesEmployee


Dans Visual Basic .NET, vous pouvez combiner des variables de différents types de données pour créer un type défini par l'utilisateur et connu sous le nom de structure. Les structures sont utiles lorsque vous avez besoin de créer une variable unique regroupant plusieurs informations connexes. Cette démonstration illustre la façon de créer et d'utiliser des structures.


! Présentation des structures ! Déclaration de structures ! Utilisation de structures ! Application pratique : Création et utilisation de structures


! décrire une structure et ses éléments ; ! déclarer et utiliser des structures.

Introduction




Présentation des structures

! Types de données composites

! Utilisées pour créer des types de valeurs définis par l'utilisateur

! Les membres peuvent être des variables, des propriétés, des méthodes ou des événements

! Exemple de structure définie par l'utilisateur :

Public Structure EmployeePublic FirstName As StringPublic LastName As StringPublic HireDate As DatePublic JobTitle As StringPrivate Salary As Decimal

End Structure

Public Structure EmployeePublic FirstName As StringPublic LastName As StringPublic HireDate As DatePublic JobTitle As StringPrivate Salary As Decimal

End Structure

! Exemples de structures prédéfinies : Point, Size et Color


Vous pouvez combiner des éléments de données de différents types pour créer un type de données composite élémentaire que l'on appelle structure. Les structures sont utiles lorsque vous voulez une variable unique pouvant contenir plusieurs informations connexes. Une fois cette structure déclarée, vous pouvez procéder à la déclaration des variables de ce type.

Une structure est un type de données composite issu de la combinaison de plusieurs autres types de données. Les structures sont des types valeur, en fait une variable de type structure contient les données de la structure plutôt qu'une simple référence aux données comme le type référence. Les structures peuvent avoir des données, des propriétés, des méthodes et des procédures ; elles peuvent déclencher des événements et les gérer.

L'utilisation la plus simple et la plus courante des structures est l'encapsulation de variables connexes pour créer un type de données défini par l'utilisateur. Par exemple, vous pouvez souhaiter regrouper le nom d'un employé, sa date d'embauche, sa fonction et son salaire. Pour cela, vous pouvez utiliser plusieurs variables, mais rien ne vous empêche de définir une structure et de l'utiliser comme une variable employé simple. L'avantage d'une telle structure devient évident lorsque vous avez beaucoup d'employés et donc de nombreuses instances de cette variable.

Une structure Employee simple est illustrée dans l'exemple suivant :

Public Structure Employee Public FirstName As String Public LastName As String Public HireDate As Date Public JobTitle As String Private Salary As Decimal End Structure

Introduction

Définition

Exemple


L'exemple précédent utilise la structure Employee pour gérer une liste ordinaire d'attributs. La structure Employee peut également posséder des membres tels qu'une méthode Hire et un événement Promoted. Cependant, si l'élaboration de votre application peut gagner à utiliser Employee comme modèle pour un autre élément de programmation tel que Manager ou StaffMember, la création de Employee en tant que classe se révèlera un choix plus judicieux. Outre qu'elles peuvent servir de modèles, les classes sont plus extensibles que les structures. Pour plus d'informations sur les classes, reportez-vous au module 7, « Programmation orientée objet en Visual Basic .NET » du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Visual Basic .NET met également à votre disposition de nombreuses structures prédéfinies. Consultez, à titre d'exemple, la liste suivante : elle détaille plusieurs structures existantes prenant en charge les graphiques sur la plate-forme .NET. Ces structures font partie de l'espace de noms System.Drawing.

! La structure Point représente une paire ordonnée de nombres entiers dont les coordonnées x et y définissent un point sur un plan bidimensionnel. Avec la structure Point, vous pouvez capturer l'emplacement de la souris lorsque l'utilisateur clique dans votre application.

! La structure Size représente la surface d'une zone rectangulaire grâce à une paire ordonnée de largeur et de hauteur. La structure Size sert à modifier la propriété Size d'un formulaire.

! La structure Color représente une couleur ARVB (alpha, rouge, vert, bleu). La structure Color sert à modifier la couleur d'un formulaire ou d'un contrôle.

Remarque

Structures fournies par Visual Basic .NET


Déclaration de structures

! Dans un module, un fichier ou une classe (pas dans une procédure)! Syntaxe :

! Le modificateur d�accès utilisé est :" Public pour un accès illimité " Protected pour un accès uniquement au sein de sa propre classe" Friend pour un accès à partir de n'importe quel emplacement de

l'application ou de l'assembly" Private pour un accès uniquement au sein de son contexte de

déclaration! N'affectez pas de valeurs aux membres des données dans la

déclaration

ModificateurAccès Structure nomDeLaStructure' Déclarer les membres de la structure ici

End Structure

ModificateurAccès Structure nomDeLaStructure' Déclarer les membres de la structure ici

End Structure


La première étape dans la création d'une structure est sa déclaration. Vous pouvez déclarer des structures dans un fichier source, à l'intérieur d'un module ou d'une classe, mais pas dans une procédure.

Vous commencez une déclaration de structure par l'instruction Structure et vous la terminez par l'instruction End Structure. Entre ces deux instructions, vous devez déclarer au moins un membre. Les membres peuvent appartenir à n'importe quel type de données. Utilisez la syntaxe suivante pour déclarer une structure :

ModificateurAccès Structure nomDeLaStructure ' Déclarer les membres de la structure ici End Structure

Vous devez déclarer chaque donnée membre d'une structure et spécifier pour chacune son niveau d'accès. Ceci implique que chaque instruction située dans la section de déclaration des variables de la structure utilise Dim, Friend, Private ou Public. Si Option Explicit est On (activé), l'inclusion de la clause As dans chaque instruction peut se révéler une bonne idée. Les membres déclarés avec Dim bénéficient de l'accès Public par défaut et les membres déclarés sans la clause As reçoivent le type de données Object par défaut.

Il est impossible d'initialiser des données membres dans la déclaration de structure. En déclarant une variable comme étant de type structure, vous affectez des valeurs aux membres alors accessibles par l'intermédiaire de la variable.

Introduction

Syntaxe

Membres de la structure


Les structures sont accessibles de n'importe quel endroit du fichier, du module ou de la classe où elles sont déclarées. Dans un fichier, une structure est Friend par défaut. Vous pouvez spécifier le niveau d'accès d'une structure grâce à un modificateur d'accès Public, Protected, Friend ou Private, comme décrit dans le tableau suivant.

Modificateur d'accès Niveau d'accès

Public Accessible de n'importe quel endroit dans la solution ou de n'importe quel point faisant référence au projet.

Protected Accessible uniquement de l'intérieur de sa propre classe.

Friend Accessible de l'intérieur de l'application où elle est déclarée ou de n'importe quel point dans l'assembly.

Private Accessible uniquement de l'intérieur du module, du fichier ou de tout autre élément de programmation où elle est déclarée, y compris des membres de n'importe quel type imbriqué, comme les procédures.

L'exemple suivant illustre la façon dont une structure Employee doit être déclarée pour définir un ensemble de données connexes concernant un employé. Il montre comment utiliser les modificateurs d'accès Public, Friend et Private pour refléter la sensibilité des éléments de données.

Public Structure Employee ' Membres Public, accessibles dans toute la région de ' déclaration Public FirstName As String Public MiddleName As String Public LastName As String ' Membres Friend, accessibles de n'importe quel endroit ' dans le même assembly Friend EmployeeNumber As Integer Friend BusinessPhone As Long ' Membres Private, accessibles uniquement dans la structure ' elle-même Private HomePhone As Long Private Salary As Double Private Bonus As Double End Structure

Niveaux d'accès

Exemple


Utilisation de structures

ProcédureProcédureProcédure

Déclaration d'une structureDéclaration d'une structure

Déclaration d'une variable du type de la structure déclaréeDéclaration d'une variable du type de la structure déclarée

Affectation de valeurs aux donnéesmembresAffectation de valeurs aux donnéesmembres

Écriture du code permettant d'utiliser les membres de la structureÉcriture du code permettant d'utiliser les membres de la structure


Une fois la structure créée, vous pouvez déclarer des variables de niveau de procédure et de niveau de module comme étant de type structure. Vous pouvez ensuite affecter des valeurs aux membres de données de la structure des variables et écrire le code permettant d'utiliser les membres de la structure.

Généralement, les étapes décrivant l'utilisation de structures se succèdent comme suit :

1. Déclaration d'une structure Vous pouvez, par exemple, créer une structure qui enregistre des informations sur un système informatique, comme ceci : Private Structure computerInfo Public processor As String Public memory As Long Public purchaseDate As Date End Structure

2. Déclaration d'une variable du type de la structure déclarée

À présent qu'une structure est déclarée, vous pouvez créer une variable de ce type de structure, comme suit : Dim mySystem As computerInfo

Introduction

Procédure


3. Affectation de valeurs aux données membres Pour affecter et récupérer des valeurs à partir des différents éléments d'une variable de structure, utilisez le nom de la variable que vous avez créée avec l'élément dans le bloc de la structure. Séparez le nom de l'élément par un point. Vous pouvez, par exemple, accéder aux variables déclarées dans la structure computerInfo et les initialiser comme suit : mySystem.processor = "x86" mySystem.purchaseDate = #1/1/2003# mySystem.memory = TextBox1.Text

4. Écriture du code permettant d'utiliser les membres de la structure

Après avoir affecté des valeurs aux données membres, écrivez le code permettant de les utiliser de n'importe quel endroit de votre code se trouvant dans leur portée. Dans cet exemple, les données membres sont uniquement accessibles de l'intérieur du fichier où la structure est déclarée. Par exemple, vous pouvez vérifier si l'ordinateur a suffisamment de mémoire pour installer une application donnée : If mySystem.memory < 64000 Then NotEnoughMemory = True

Une structure peut contenir n'importe quel type de données défini dans Visual Basic .NET, y compris des tableaux, des objets et d'autres structures. Pour plus d'informations sur la création de structures, consultez « Structures et autres éléments de programmation » dans la documentation Visual Basic .NET.

Remarque


Application pratique : Création et utilisation de structures

Déclarez une structure

Déclarez une variable en tant que type de la structure

Écrivez le code pour utiliser les membres de la structure

Affectez des valeurs aux membres de la structure

Exécutez et testez l'application


Dans cette application pratique, vous créerez une structure, puis vous l'utiliserez et testerez l'application dans laquelle elle est utilisée pour vérifier qu'elle fonctionne.

Réfléchissez au scénario d'une application manipulant les données d'un parc de voitures afin de gérer et tenir à jour les informations sur la location à bail des véhicules et leurs réparations. La solution réside dans l'encapsulation des renseignements de chaque véhicule dans une structure pouvant être utilisée par les développeurs qui créeront les différentes parties de l'application. Les détails concernés se limiteront à la marque du véhicule, au modèle, à son prix d'achat et à la date d'achat.

! Ouverture du code de démarrage de l'application pratique 1. Démarrez Visual Studio .NET. 2. Ouvrez le fichier Structures.sln situé dans dossier_installation\Practices\

Mod03\Structure\Starter.

! Création d'une structure pour stocker les informations sur les véhicules • Déclarez une structure publique appelée CarInfo dans la section des

déclarations de Form1. Intégrez les membres figurant dans le tableau ci-dessous.

Nom de membre Modificateur d'accès Type de données

Make Dim String

Model Dim String

PurchasePrice Dim Single

PurchaseDate Dim Date

Introduction

Scénario

Instructions


! Déclaration d'une variable de type CarInfo et affectation de valeurs à cette variable

1. Dans l'événement Button1_Click, déclarez une variable appelée myCar de type de structure CarInfo. Votre code doit ressembler au texte suivant : Dim myCar As CarInfo

2. Affectez des valeurs aux membres de la structure. Vous pouvez choisir les

valeurs suivantes ou choisir vos propres valeurs. myCar.Make = "Jeep" myCar.Model = "Cherokee" myCar.PurchasePrice = 27999 myCar.PurchaseDate = #06/23/2000#

! Affichage des informations sur les véhicules dans des zones de texte • Définissez les propriétés TextBox pour afficher la structure CarInfo dans

les zones de texte du formulaire. Votre code doit ressembler au texte suivant : TextBox1.Text = myCar.Make TextBox2.Text = myCar.Model TextBox3.Text = myCar.PurchasePrice TextBox4.Text = myCar.PurchaseDate

! Exécution et test de l'application • Exécutez l'application, puis cliquez sur Afficher la structure de la

voiture. Le formulaire qui s'exécute doit ressembler à celui-ci :

Les fichiers de solution correspondant à cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod03\Structure\Solution.



Leçon : Stockage de données dans des tableaux

! Présentation d'un tableau

! Déclaration d'un tableau unidimensionnel

! Utilisation de tableaux multidimensionnels

! Redimensionnement des tableaux


Grâce à l'utilisation de tableaux, vous pouvez stocker un groupe d'éléments partageant le même type de données sous un nom de variable. Vous utilisez un nombre (ou index) pour vous référer à un élément spécifique dans la série. En utilisant des tableaux, vous pouvez rapidement avoir accès, utiliser et stocker des valeurs d'un même type. Cette leçon explique comment déclarer et utiliser des tableaux.


! Présentation d'un tableau ! Déclaration d'un tableau unidimensionnel ! Utilisation de tableaux multidimensionnels ! Redimensionnement des tableaux


! décrire la structure de base d'un tableau ; ! déclarer et initialiser des tableaux ; ! redimensionner les tableaux ; ! utiliser les tableaux multidimensionnels.

Introduction




Présentation d'un tableau

! Définition : Un tableau est une séquences d'éléments de données" Tous les éléments d'un tableau possèdent le même type de données

" Les éléments individuels sont accessibles en utilisant des index d'entiers

! Exemple" Pour déclarer un tableau d'entiers composé de sept éléments :

" Pour accéder au troisième élément du tableau :

(6)(5)(4)(3)(2)(1)(0)

Index 0 Index 6

Dim countHouses(6) As IntegerDim countHouses(6) As Integer

TextBox1.Text = CStr(countHouses(2))TextBox1.Text = CStr(countHouses(2))


Un tableau est un type de données capital dans Visual Basic .NET, comme dans la plupart des langages de programmation. Vous pouvez utiliser des tableaux pour créer un code plus court et plus simple dans de nombreuses situations car vous pouvez définir des structures de décision et des boucles pour récupérer et modifier n'importe quel élément contenu dans un tableau.

Un tableau est une séquence d'éléments de données appartenant à un même type. Vous pouvez accéder aux éléments individuels d'un tableau en utilisant le nom du tableau et un ou plusieurs index (commençant à 0) pour spécifier la position de l'élément dans le tableau. Un tableau peut présenter une ou plusieurs dimensions avec un ou plusieurs éléments dans chaque dimension.

Imaginez un quartier avec une rue de sept maisons pour vous représenter un tableau à dimension unique. Imaginez le quartier comme étant un tableau, la rue la dimension du tableau et les maisons les éléments individuels du tableau. Le type de données des éléments du tableau peut être Integer.

Pour déclarer le tableau décrit précédemment, utilisez le code suivant :

Dim countHouses(6) As Integer

Dans le tableau countHouses, vous accédez à la troisième maison comme suit :

TextBox1.Text = CStr(countHouses(2))

Introduction

Définitions

Analogie

Exemple


Déclaration d'un tableau unidimensionnel

! Vous déclarez un tableau en spécifiant les éléments suivants : " Nom du tableau" Taille (nombre d'éléments)" Type de données des éléments du tableau" Modificateur d'accès (si nécessaire)

Spécifie le nom du tableau

Spécifie le type des donnéesdes éléments du tableau

Spécifie le niveau d'accès du tableau

ModificateurAccès NomDuTableau(Size) As TypeModificateurAccès NomDuTableau(Size) As Type

Spécifie la taille du tableau


Vous déclarez un tableau unidimensionnel en spécifiant son nom, sa taille, le type de données des éléments et son niveau d'accès.

Vous créez ou déclarez des tableaux dans un code de la même façon que vous déclarez d'autres variables. Vous suivez les mêmes directives pour nommer, attribuer une portée et choisir des types de données. Pour déclarer des tableaux, utilisez la syntaxe suivante :

ModificateurAccès NomDuTableau(Size) As Type

L'argument Size spécifie le nombre d'éléments contenu au départ dans le tableau. Vous pouvez parfois ne pas avoir besoin de spécifier un modificateur d'accès car la portée du tableau est déterminée par l'endroit où elle est située dans le code. Dans ce cas, déclarez le tableau à l'aide du mot clé Dim.

Vous pouvez déclarer des tableaux locaux au moyen de l'instruction Dim et en intégrant la déclaration à l'intérieur d'une procédure, comme montré dans l'exemple suivant :

Sub InitializeArray( ) ' Allouer 31 éléments (0) à (30) Dim currentExpense(30) As Decimal Dim number As Integer For number = 0 to 30 currentExpense(number) = 100 Next number End Sub

Cet exemple stocke les dépenses quotidiennes pour chaque jour du mois dans un tableau composé de 31 éléments et nommé currentExpense. Chaque élément du tableau contient une valeur à laquelle vous avez accès en spécifiant l'index de l'élément. Une valeur de 100 est affectée à chaque élément du tableau.

Introduction

Syntaxe

Exemples de tableaux locaux


Pour créer un tableau public, utilisez le mot clé Public à la place de Dim, comme montré dans l'exemple suivant :

Public Counters(14) As Integer Public Sums(20) As Double

La première déclaration crée un tableau unidimensionnel de 15 éléments, avec des nombres index allant de 0 à 14. La deuxième déclaration crée un tableau de 21 éléments avec des nombres index allant de 0 à 20.

Vous pouvez assigner des valeurs aux éléments du tableau après l'avoir déclaré, mais vous pouvez aussi l'initialiser lorsque vous le déclarez en incluant les valeurs entre accolades, comme montré dans l'exemple suivant :

Public Counters( ) As Integer = {1, 2, 3, 4, 5, 6, 7}

Exemples de tableaux publics


Utilisation de tableaux multidimensionnels

! Spécifiez tous les éléments et les dimensions! Total des éléments = produit de toutes les tailles! Pour déclarer une variable de tableau multidimensionnel :

" Ajoutez une paire de parenthèses après le nom de la variable

" Utilisez des virgules à l'intérieur des parenthèses pour séparer les dimensions

" Utilisez l'instruction Dim ou un modificateur d'accès au début de la déclaration

! Exemple :Public ThreeDimensions(3,9,14) As Double' Tableau tridimensionnel

Public ThreeDimensions(3,9,14) As Double' Tableau tridimensionnel


Un tableau peut avoir plusieurs dimensions. La dimensionnalité, ou rang, correspond au nombre d'indices utilisés pour identifier un élément individuel dans le tableau. Vous pouvez spécifier jusqu'à 32 dimensions pour un tableau, cependant vous aurez rarement besoin de plus de 3 dimensions.

Pour déclarer une variable de tableau multidimensionnel, ajoutez une paire de parenthèses après le nom de la variable et utilisez des virgules à l'intérieur pour séparer les dimensions, comme dans l'exemple suivant :

' Tableau quadridimensionnel Dim My4DArray(2, 6, 4, 1) As Integer

En guise de mot clé, utilisez Dim pour un tableau local ou spécifiez un modificateur d'accès comme Public ou Friend pour fournir un niveau de portée différent.

Vous pouvez vous représenter un tableau bidimensionnel comme une grille. L'exemple suivant montre comment déclarer un tableau bidimensionnel de 4 lignes et 3 colonnes.

Dim storageNumber(3, 2) As Double

Pour affecter une valeur à un élément spécifique du tableau, référez-vous aux nombres index de l'élément. Par exemple, le code suivant indique comment affecter une valeur à un élément spécifique dans le tableau déclaré dans le code précédent.

storageNumber(2, 1) = 24

Introduction

Déclaration de variables dans un tableau multidimensionnel

Exemple d'un tableau bidimensionnel


L'illustration suivante est une représentation du tableau bidimensionnel créé dans cet exemple :

L'exemple ci-dessous montre comment créer et accéder à un tableau public qui possède trois dimensions :

Public ThreeDimensions(3, 9, 14) As String

Cette déclaration crée un tableau tridimensionnel, aux dimensions de 4, 10 et 15. Le nombre total d'éléments est le produit de ces trois dimensions, soit 600. Imaginez un tableau tridimensionnel comme un cube.

Le code suivant montre comment affecter la valeur stockée dans un élément spécifique du tableau précédent à la propriété Text d'une zone de texte.

TextBox1.Text = ThreeDimensions(2,6,4)

Lorsque vous ajoutez des dimensions à un tableau, sa capacité totale de stockage nécessaire augmente considérablement. Il est donc préférable d'éviter de déclarer un tableau plus grand que ce dont vous avez besoin.

Exemple d'un tableau tridimensionnel

Remarque


Redimensionnement des tableaux

! Vous pouvez redimensionner un tableau à tout moment

! Utilisez l'instruction ReDim

! Syntaxe :

! Exemple :

ReDim tableauExistant(NouvelleGrandeur)ReDim tableauExistant(NouvelleGrandeur)

Dim myArray(,) ' Déclarer tableauReDim myArray(3, 5) ' Redimensionner tableauDim myArray(,) ' Déclarer tableauReDim myArray(3, 5) ' Redimensionner tableau


Dans Visual Basic .NET, vous pouvez redimensionner un tableau à tout moment en lui spécifiant une nouvelle grandeur. Vous pouvez même changer le nombre de dimensions du tableau. Redimensionner les tableaux permet de gérer plus efficacement la mémoire. Vous pouvez par exemple utiliser un grand tableau pour une courte durée et ensuite le réduire. En agissant ainsi, vous libérez la mémoire dont vous n'avez plus besoin.

Utilisez la syntaxe suivante pour redimensionner un tableau unidimensionnel déjà existant :

ReDim tableauExistant(NouvelleGrandeur)

Si vous hésitez sur la taille du tableau, vous pouvez toujours le déclarer sans mentionner sa grandeur, comme montré dans l'illustration précédente.

L'exemple suivant s'attache à l'utilisation de l'instruction ReDim pour allouer et réorganiser l'espace de stockage des variables de tableau.

Dim number, myArray( ) As Integer ' Déclarer variable et variable de tableau ' Allouer 6 éléments ReDim myArray(5) For number = 0 to 5 ' Initialiser tableau myArray(number) = number Next number

Introduction

Syntaxe

Exemples


L'instruction suivante redimensionne le tableau sans enregistrer le contenu des éléments.

' Redimensionner à 11 éléments ReDim myArray(10) For number = 0 To 10 ' Initialiser tableau myArray(number) = number Next number

Lorsque vous redimensionnez (ReDim) un tableau, ses valeurs existantes sont normalement perdues. Toutefois, vous pouvez les conserver en incluant le mot clé Preserve dans l'instruction ReDim. Par exemple, l'instruction suivante alloue un nouveau tableau, initialise ses éléments à partir des éléments correspondants de myArray existant et assigne le nouveau tableau à myArray.

ReDim Preserve myArray(10)

Préservation des valeurs originales du tableau



! Introduction aux types de données

! Utilisation de variables! Portée des variables ! Conversion des types de

données! Création et utilisation de

structures! Stockage de données dans

des tableaux

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


1. Quel type de données Visual Basic .NET utiliser pour stocker les valeurs True ou False ? Boolean.

2. Déclarer une variable locale appelée myDayOff et lui affecter la valeur 12/25/2001 (25 décembre 2001). Écrire ce code de deux manières différentes. Dim myDayOff As Date

myDayOff = #12/25/2001#

� ou � Dim myDayOff As Date = #12/25/2001#


3. Étudier le code ci-dessous. Public Class BankAccount . . . Public MyVariable As Integer . . . End Class

a. Quel est le niveau de portée de MyVariable ?

Tout le code contenu dans la solution bénéficie d'un accès illimité à MyVariable.

b. Comment récrire le code pour que l'accès à MyVariable se fasse uniquement de l'intérieur du projet où elle a été déclarée ? Remplacer le modificateur d'accès Public par Friend et vérifier qu'il est déclaré au niveau du module.

4. Vrai ou faux ? La valeur d'une variable locale est préservée entre les différents appels de procédure sauf si vous détruisez explicitement l'instance de cette variable. Faux. Les variables locales existent uniquement tant que le bloc ou la procédure où elles sont appelées s'exécute.

5. Quelle est la valeur et quel est le type de données de myInteger après l'exécution du code suivant ? Dim myInteger As Integer Dim myDouble As Double myInteger = 5555 myDouble = CDbl(myInteger)

La valeur de myInteger est définie sur 5555 et myDouble reçoit la valeur de myInteger après sa conversion de Integer en Double. Le type de données reste le même.


6. Créer tout d'abord une structure publique nommée CustomerInfo au moyen des données membres suivantes :

• une variable FirstName accessible de n'importe quel endroit de la solution ;

• une variable LastName accessible de n'importe quel endroit de la solution ;

• une variable AccountNumber accessible de n'importe quel endroit du projet ;

• une variable HomePhone accessible de n'importe quel endroit de la structure.

Déclarer ensuite une variable FirstCustomer de type CustomerInfo. Public Structure CustomerInfo

Public FirstName As String

Public LastName As String

Friend AccountNumber As Integer

Private HomePhone As Long

End Structure

Dim FirstCustomer As InfoClient

7. Écrire le code pour affecter une valeur de 100 au quatrième élément de la deuxième colonne du tableau suivant. Quel est le nombre total d'éléments contenus dans le tableau ? Dim testArray(8,8) As Integer

testArray(3,1) = 100

Le nombre total d'éléments contenus dans le tableau est 81.


Atelier 3.2 : Utilisation de structures et de tableaux

! Exercice 1 : Création d'une structure

! Exercice 2 : Création et utilisation de tableaux



! déclarer et utiliser une structure ; ! déclarer et utiliser un tableau.

Cet atelier met l'accent sur les concepts dans ce module, par conséquent il est possible qu'il ne se conforme aux recommandations de sécurité émises par Microsoft.

Avant de travailler dans cet atelier, vous devez :

! bien connaître l'environnement de développement Visual Studio .NET ; ! être capable de déclarer des variables ; ! être capable de modifier des formulaires et des contrôles.

Pour plus d'informations sur la création de structures, consultez « Structures constituées à partir de vos propres types de données » dans la documentation Visual Studio .NET. Pour en savoir plus sur les tableaux, consultez la documentation Visual Basic .NET.

Dans cet atelier, vous créerez et utiliserez une structure dans une application existante. Vous ajouterez également un tableau pour autoriser l'utilisation de la structure et son affichage trois fois. Bien que le contexte de cet atelier soit celui d'une simulation d'emprunt, il ne fait pas partie du scénario de l'application sur l'emprunt utilisé dans les autres modules du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

Objectifs

Remarque


Remarque

Scénario


Les fichiers de solution de cet atelier se trouvent dans les dossiers dossier_installation\Labfiles\Lab032\Ex01\Solution et dossier_installation\Labfiles\Lab032\Ex02\Solution.




Exercice 1 Création d'une structure

Dans cet exercice, vous déclarerez une structure contenant quatre membres pour simuler les données d'un demandeur d'emprunt. Vous assignerez les données aux membres de la structure et afficherez toutes les données dans un message.

! Ouverture du code de démarrage pour le projet 1. Démarrez Visual Studio .NET. 2. Ouvrez le projet StructuresArrays.sln situé dans le dossier

dossier_installation\Labfiles\Lab032\Ex01\Starter.

Bien que le contexte de cet atelier soit celui d'une simulation d'emprunt, il ne fait pas partie du scénario de l'application sur l'emprunt utilisé dans certains autres modules du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET.

! Ajout d'une structure de données 1. Ouvrez l'éditeur de code pour Form1.vb. 2. Juste au-dessus de l'instruction commentée MessageBox, créez une

structure loanApplicant avec les membres et les types de données suivants :

Nom de membre Type de données

ApplicantNumber Integer

Name String

Salary Decimal

LoanRequested Decimal

Votre code doit ressembler au texte suivant : Public Structure loanApplicant Dim ApplicantNumber As Integer Dim Name As String Dim Salary As Decimal Dim LoanRequested As Decimal End Structure

3. Déclarez une variable applicant de niveau module comme structure

loanApplicant. Votre code doit ressembler au texte suivant : Dim applicant as loanApplicant

Important


! Remplissage des membres de la structure avec les données provenant du formulaire

1. Dans le gestionnaire d'événements AddButton_Click, attribuez un nombre de départ au membre ApplicantNumber de la structure loanApplicant à utiliser pendant l'affichage des informations. (Le code à ajouter est en gras dans l'exemple suivant.) Attribuer un nombre de départ vous permettra également de garder une trace des éléments du tableau dans l'exercice 2. Private Sub AddButton_Click(...) applicant.ApplicantNumber = 1 End Sub

2. Dans le gestionnaire d'événements AddButton_Click, écrivez le code pour

affecter des valeurs de propriété de zones de texte aux membres de la structure, comme suit : (Le code à ajouter est en gras.) Private Sub AddButton_Click(...) applicant.ApplicantNumber = 1 applicant.Name = NameTextBox.Text applicant.Salary = CDec(SalaryTextBox.Text) applicant.LoanRequested = _ CDec(LoanRequestedTextBox.Text) End Sub

! Affichage des informations de la structure pour l'utilisateur 1. Dans le gestionnaire d'événements DisplayButton_Click, n'insérez pas de

commentaire mais examinez la ligne de code fournie dans le code de démarrage. Ce code affiche chaque membre de structure sur des lignes distinctes dans un message. Le code commenté est reproduit ci-dessous : MessageBox.Show("Demandeur d'emprunt N° : " & _ applicant.ApplicantNumber & ControlChars.CrLf & _ "Nom du demandeur d'emprunt : " & applicant.Name & _ ControlChars.CrLf & "Salaire : " & _ applicant.Salary & ControlChars.CrLf _ & "Emprunt demandé : " & applicant.LoanRequested)

Ce code utilise la constante ControlChars.CrLf pour créer des retours à la ligne dans le texte du message. Pour plus d'informations sur ControlChars.CrLf, consultez « Impression et affichage des constantes » dans la documentation Visual Basic .NET.

2. Dans le gestionnaire d'événements DisplayButton_Click, créez un second message pour informer l'utilisateur que l'application va se fermer, puis écrivez le code pour fermer l'application. Votre code doit ressembler au texte suivant : MessageBox.Show("Fermeture de l'application.") Application.Exit( )

Remarque



bouton Démarrer. 2. Tapez des exemples de données dans les zones Nom, Salaire et Emprunt

demandé. 3. Cliquez sur Ajouter à la structure.

Lorsque vous cliquez sur Ajouter à la structure, rien ne semble se passer. 4. Cliquez sur Afficher pour que les éléments de la structure apparaissent dans

un message. 5. Cliquez sur OK pour fermer le message, puis de nouveau sur OK pour

quitter l'application.


Exercice 2 Création et utilisation de tableaux

Dans cet exercice, vous ajouterez un tableau basé sur la structure loanApplicant. Vous modifierez le gestionnaire d'événements AddButton_Click pour autoriser l'ajout de plusieurs demandeurs d'emprunt au tableau et vous modifierez également le gestionnaire d'événements DisplayButton_Click pour contenir le nouveau tableau.

! Création d'un tableau basé sur la structure loanApplicant 1. Ouvrez le fichier StructuresArrays.sln que vous avez créé dans l'exercice 1

de l'atelier 3.2 (s'il n'est pas déjà ouvert). Si vous n'avez pas fait l'exercice 1 de l'atelier 3.2, utilisez le fichier StructuresArrays.sln du dossier dossier_installation\Labfiles\Lab032\ Ex02\Starter.

2. Ouvrez l'éditeur de code pour Form1.vb. 3. Repérez le code qui déclare la variable loanApplicant. À sa place, déclarez

un tableau du type loanApplicant avec trois éléments, comme suit : Dim applicant(2) As loanApplicant

! Comptabilisation du nombre de demandeurs d'emprunt 1. Dans le gestionnaire d'événements AddButton_Click, écrivez le code pour

déclarer une variable statique comme compteur, comme suit : Static countClicks As Integer

2. Dans le gestionnaire d'événements AddButton_Click, juste après la

déclaration de la variable statique, modifiez les références à la variable loanApplicant pour faire référence au tableau à l'aide de countClicks et obtenir le nombre de l'élément du tableau en cours, comme suit : applicant(countClicks).ApplicantNumber = countClicks + 1 applicant(countClicks).Name = NameTextBox.Text applicant(countClicks).Salary = CDec(SalaryTextBox.Text) applicant(countClicks).LoanRequested = _ CDec(LoanRequestedTextBox.Text)

3. Dans le gestionnaire d'événements AddButton_Click, juste après le code

définissant chaque jeu de propriétés du tableau, écrivez le code pour incrémenter countClicks chaque fois que l'utilisateur clique sur Ajouter à la structure et capturer les valeurs courantes en incrémentant le compteur. Votre code doit ressembler au texte suivant : countClicks +=1


! Préparation de la zone de texte pour la nouvelle séquence d'ajout • Dans le gestionnaire d'événements AddButton_Click, juste après le code

incrémentant countClicks, écrivez le code pour définir le focus sur le contrôle NameTextBox et sélectionner tout le texte à l'intérieur. Votre code doit ressembler au texte suivant : NameTextBox.Focus( ) NameTextBox.SelectAll( )

! Écriture du code pour contenir plusieurs demandes d'emprunt 1. Dans le gestionnaire d'événements DisplayButton_Click, modifiez

l'instruction MessageBox pour utiliser le tableau en remplaçant les références de applicant par applicant(0).

2. Ouvrez le fichier MessageBoxCode.txt situé dans le dossier dossier_installation\Labfiles\Lab032\Ex02\Starter, coupez les trois lignes de code et collez-les dans votre code. Vous pouvez aussi copier l'instruction MessageBox dans son intégralité et la coller deux fois après l'instruction MessageBox originale. Si vous choisissez cette seconde solution, augmentez les nombres de référence du tableau pour applicant(1) dans la deuxième instruction et pour applicant(2) dans la troisième instruction.

3. Vérifiez que les deux dernières instructions dans la procédure d'événement DisplayButton_Click sont l'instruction MessageBox indiquant la fermeture de l'application et l'instruction fermant l'application. Votre code pour la procédure complète de l'événement DisplayButton_Click doit ressembler au texte suivant : Private Sub DisplayButton_Click(...) MessageBox.Show("Demandeur d'emprunt N° : " & _ applicant(0).ApplicantNumber & ControlChars.CrLf & _ "Nom du demandeur d'emprunt : " & applicant(0).Name & _ ControlChars.CrLf & "Salaire : " & _ applicant(0).Salary & ControlChars.CrLf & _ "Emprunt demandé : " & applicant(0).LoanRequested) MessageBox.Show("Demandeur d'emprunt N° : " & _ applicant(1).ApplicantNumber & ControlChars.CrLf & _ "Nom du demandeur d'emprunt : " & applicant(1).Name & _ ControlChars.CrLf & "Salaire : " & _ applicant(1).Salary & ControlChars.CrLf & _ "Emprunt demandé : " & applicant(1).LoanRequested) (suite du code à la page suivante)


MessageBox.Show("Demandeur d'emprunt N° : " & _ applicant(2).ApplicantNumber & ControlChars.CrLf & _ "Nom du demandeur d'emprunt : " & applicant(2).Name & _ ControlChars.CrLf & "Salaire : " & _ applicant(2).Salary & ControlChars.CrLf & _ "Emprunt demandé : " & applicant(2).LoanRequested) MessageBox.Show("Fermeture de l'application.") Application.Exit( ) End Sub


bouton Démarrer. 2. Entrez des exemples de données dans les zones Nom, Salaire et Emprunt

demandé. 3. Cliquez sur Ajouter à la structure. 4. Répétez les étapes 2 et 3 deux autres fois pour un total de trois fois. 5. Cliquez sur Afficher, puis sur OK dans tous les messages. 6. Quittez Visual Studio .NET.

Lorsque vous cliquez sur Ajouter à la structure, rien ne semble se passer dans le formulaire et vous êtes renvoyé à la première zone de texte. Toutefois, les membres de la structure sont en cours de remplissage dans la mémoire. Ainsi, lorsque vous cliquerez sur Afficher, vous verrez que les informations de chaque demandeur d'emprunt s'affiche dans un message distinct. L'application déclenchera une exception si vous cliquez sur Ajouter à la structure plus de trois fois. La structure correcte pour gérer ceci est une structure If. . .Then ou une boucle. Pour en savoir plus sur le sujet, consultez le module 5, « Structures de décision et boucles » du cours 2560A, Introduction à la programmation en Visual Basic® NET avec Microsoft® .NET.

Remarque

Table des matières

Vue d'ensemble 1

Leçon : Création de procédures 2

Leçon : Utilisation de procédures 21

Leçon : Utilisation de fonctions prédéfinies 37


Atelier 4.1 : Création et utilisation de procédures 54

Module 4 : Utilisation de procédures

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaines, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs, et toute ressemblance avec des sociétés, produits, noms de domaines, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l'objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d'autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d'un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Module 4 : Utilisation de procédures iii

Notes de l'instructeur L'un des aspects essentiels de la programmation consiste à structurer le code pour pouvoir le réutiliser. Ce module explique aux stagiaires comment créer et appeler les procédures Sub et Function, comment structurer le code en utilisant des modules, comment transmettre des arguments par valeur et par référence, et comment utiliser des fonctions prédéfinies telles que les fonctions de date et d'heure.


! créer et appeler les procédures Sub et Function ; ! écrire des procédures dans des modules pour permettre la réutilisation du

code ; ! transmettre des arguments par valeur et par référence ; ! utiliser des fonctions prédéfinies.


! Fichier Microsoft® PowerPoint® 2560A_04.ppt ! Fichier de démonstration multimédia 2560A_04d005.wmv ! Fichier d'animation multimédia 2560A_Passing.htm


! lire tous les documents de cours relatifs à ce module ; ! réaliser l'application pratique et l'atelier ; ! passer en revue la démonstration multimédia et l'animation de ce module.


Documents de cours

Préparation

iv Module 4 : Utilisation de procédures

Comment animer ce module Cette section contient des informations destinées à vous permettre d'animer ce module.

Leçon : Création de procédures Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon.

L'objectif de cette rubrique consiste à familiariser les stagiaires avec la terminologie de base : procédures Sub et Function, appel d'une procédure et modificateurs d'accès. Précisez que les procédures sont également appelées méthodes dans certaines références. Ne consacrez pas trop de temps à expliquer en détail les différences entre les procédures Sub et Function. Les détails seront traités dans les rubriques ultérieures de cette leçon et dans la leçon suivante. Les procédures de propriétés seront traitées dans un module ultérieur du cours 2560A, Introduction à la programmation en Visual Basic.NET avec Microsoft .NET.

Cette rubrique explique la syntaxe permettant de créer une procédure Sub. Dans les modules antérieurs du cours 2560A, Introduction à la programmation en Visual Basic.NET avec Microsoft .NET, les gestionnaires d'événements ont été présentés aux stagiaires. Les modules seront traités plus en détail dans la leçon suivante, mais vous pouvez d'ores et déjà expliquer la différence entre une procédure Sub écrite dans un gestionnaire d'événements et une procédure Sub écrite dans un module.

Cette rubrique explique la syntaxe utilisée pour créer une procédure Function. Comparez les procédures Function et Sub (une procédure Function peut renvoyer une valeur) et expliquez les deux méthodes qui permettent d'affecter une valeur de retour dans une procédure Function.

Cette rubrique explique les concepts d'argument et de paramètre ainsi que la transmission d'arguments par valeur et par référence. La syntaxe de déclaration des arguments est identique pour une procédure Sub et pour une procédure Function. N'oubliez pas de mentionner que les arguments transmis à la procédure ne doivent pas nécessairement porter les mêmes noms que ceux utilisés pour définir les paramètres de la procédure appelée. L'animation qui suit cette rubrique explique la différence entre la transmission d'un argument par référence et sa transmission par valeur.

Cette animation présente la différence entre la transmission d'un argument par référence et la transmission par valeur. Pour exécuter l'animation, cliquez sur l'icône au centre de la diapositive correspondant à cette rubrique.

Cette rubrique explique comment déclarer des arguments facultatifs dans la définition d'une procédure.

Présentation des procédures

Création de procédures Sub

Création de procédures Function

Déclaration d'arguments dans les procédures

Présentation multimédia : Transmission d'arguments

Utilisation d'arguments facultatifs

Module 4 : Utilisation de procédures v

Cette démonstration explique comment structurer le code pour permettre une meilleure réutilisation, comment créer une procédure dans un module, et comment transmettre des arguments et renvoyer une valeur à partir d'une fonction. Dans cette démonstration, le code issu d'un événement Button Click est transféré dans une procédure dans un module. Des arguments sont ensuite transmis à cette procédure, et cette dernière renvoie une valeur.

Pour exécuter cette démonstration, cliquez sur l'icône au centre de la diapositive correspondant à cette rubrique. Si vous préférez présenter cette animation multimédia sous la forme d'une présentation dirigée, les étapes que vous devez suivre sont indiquées dans la section Démonstrations des notes de l'instructeur.

Pour savoir quels paramètres utiliser pour une visualisation optimale des animations multimédias, reportez-vous à la Liste de préparation du cours incluse dans le kit de l'instructeur.

Cette rubrique compare l'utilisation des structures, des modules et des classes pour créer du code réutilisable. Les structures et les classes sont traitées de manière plus approfondie dans d'autres modules du cours 2560A, Introduction à la programmation en Visual Basic.NET avec Microsoft .NET. Dans cette rubrique, l'accent est porté sur l'utilisation des modules pour regrouper des fonctions d'utilitaire. Pour expliquer cette rubrique, ouvrez Microsoft Visual Studio® et ajoutez un module dans un projet.

Dans cette application pratique, les stagiaires devront écrire une fonction simple, nommée Area, qui utilise height et width comme arguments et renvoie une valeur nommée Area. Encouragez les stagiaires à écrire autant de code que possible sans regarder la réponse. Avant que les stagiaires ne commencent, vous pouvez parler du scénario et décider du meilleur type de données à utiliser pour les arguments et la valeur de retour. Assurez-vous que les stagiaires enregistrent leur travail, car dans la seconde application pratique de ce module, ils devront créer une application simple qui appelle cette fonction et utilise la valeur de retour. 10 minutes environ doivent être consacrées à cette application pratique.

Leçon : Utilisation de procédures Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon.

Cette rubrique peut être traitée assez rapidement. Consacrez quelques minutes aux exemples figurant dans les notes du stagiaire. Une application pratique facultative figure à la fin de cette rubrique. Dans cette application pratique, les stagiaires créent du code qui appelle une procédure, puis observent l'incidence de la transmission d'une variable par référence par rapport à la transmission par valeur.

Donnez aux stagiaires plusieurs exemples des deux méthodes d'appel d'une fonction, de transmission d'arguments et de retour d'une valeur. Soulignez la différence entre la méthode d'utilisation d'une fonction et la méthode d'appel d'une routine Sub.

Présentation multimédia : Écriture de code réutilisable

Réutilisation du code

Application pratique : Création d'une fonction dans un module

Utilisation des procédures Sub

Utilisation des procédures Function

vi Module 4 : Utilisation de procédures

Dans cette application pratique, les stagiaires devront créer une application simple qui calcule la superficie d'un rectangle, en fonction de sa hauteur et de sa largeur. Pour commencer, les stagiaires peuvent soit utiliser le projet créé dans l'application pratique de la leçon antérieure (Création d'une fonction dans un module), soit utiliser le code de démarrage qui leur a été fourni. 15 minutes environ doivent être consacrées à cette application pratique.

Cette rubrique explique comment transmettre un tableau à une procédure, et comment utiliser ParamArray pour déclarer un tableau de paramètres. Si ParamArray est utilisé dans la définition de la procédure, la procédure appelante n'a pas besoin de déclarer le tableau avant de le transmettre. La taille du tableau est déterminée individuellement par chaque appel de la procédure.

L'objectif principal de cette rubrique consiste à présenter aux stagiaires la procédure Sub Main. Pour traiter au mieux cette rubrique, il convient de la présenter dans l'environnement de développement Visual Studio .NET. Créez un nouveau projet et expliquez l'objet de démarrage figurant par défaut dans les propriétés de projet de Form1. Créez une procédure appelée Sub Main, puis expliquez comment sélectionner cette procédure comme objet de démarrage dans la fenêtre Propriétés du projet.

Dans cette application pratique, les stagiaires devront écrire du code pour une application constituée de trois formulaires, puis ils devront créer une procédure Sub Main comme objet de démarrage du projet. 30 minutes environ doivent être consacrées à cette application pratique.

Leçon : Utilisation de fonctions prédéfinies Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon.

L'objectif de cette leçon consiste à faire connaître aux stagiaires certaines fonctions prédéfinies de Microsoft Visual Basic® .NET. Les stagiaires se familiariseront également avec l'utilisation de la documentation de Visual Studio afin de savoir comment utiliser les fonctions. Les rubriques de cette leçon présentent les catégories générales de fonctions aux stagiaires et proposent un ou deux exemples spécifiques.

Pour traiter au mieux cette rubrique, il convient de la présenter dans l'environnement de développement Visual Studio .NET. Lorsque vous expliquez la rubrique, précisez que Microsoft IntelliSense® demande à l'utilisateur d'entrer les paramètres définis par la fonction.

Cette rubrique est axée sur les fonctions DateAdd et DateDiff. L'exemple correspondant à la fonction DateDiff utilise la propriété Now. Vous pouvez saisir cette occasion pour présenter aux stagiaires des propriétés telles que Now et Today. Now est également traitée à la fin de cette leçon.

Cette rubrique est axée sur les fonctions Trim, Len et Left. Le dernier exemple des notes du stagiaire propose un scénario dans lequel les stagiaires peuvent utiliser Len et Left pour supprimer l'extension d'un nom de fichier.

Cette rubrique est axée sur les fonctions FormatCurrency et FormatDateTime. Les stagiaires utiliseront la fonction FormatCurrency dans l'atelier 4.1, Création et utilisation de procédures. Faites en sorte que les stagiaires comprennent parfaitement ce que sont les paramètres régionaux.

Application pratique : Utilisation de la valeur de retour d'une fonction

Transmission de tableaux à des procédures

Création d'une procédure Sub Main

Application pratique : Création d'une procédure Sub Main

Utilisation de la fonction InputBox

Utilisation des fonctions de date et d'heure

Utilisation des fonctions de chaîne

Utilisation des fonctions de format

Module 4 : Utilisation de procédures vii

Cette rubrique est axée sur les fonctions Pmt et Rate. Les stagiaires utiliseront la fonction Pmt dans l'atelier 4.1, Création et utilisation de procédures.

Cette leçon propose des informations sur quelques fonctions prédéfinies uniquement. Cette application pratique permet aux stagiaires d'utiliser la documentation de Visual Studio pour apprendre à connaître d'autres fonctions prédéfinies susceptibles d'être utilisées dans leur code. L'application pratique est axée sur la rubrique « Membres de la bibliothèque runtime Visual Basic », une liste exhaustive des fonctions, méthodes et propriétés disponibles dans la bibliothèque d'exécution. Les fonctions que les stagiaires étudieront dans cette application pratique sont utilisées dans l'atelier et dans d'autres ateliers du cours 2560A, Introduction à la programmation en Visual Basic.NET avec Microsoft .NET.

Contrôle des acquis Les questions du contrôle des acquis sont principalement basées sur la compréhension des concepts et sur les procédures qui ont été traitées de manière approfondie dans le module. Vous pouvez utiliser un format de discussion pour répondre aux questions afin que chaque personne puisse connaître les réponses correctes.

1. Cette question permet de vérifier que les stagiaires comprennent les valeurs par défaut correspondant à l'accessibilité dans les modules. Elle réitère également le fait que ByVal est la méthode de transmission par défaut dans Visual Basic® .NET. Cet élément est particulièrement important pour les stagiaires qui ont déjà utilisé les versions précédentes de Visual Basic dans lesquelles ByRef est la méthode de transmission par défaut.

2. Cette question permet de vérifier que les stagiaires maîtrisent les concepts de transmission d'un argument par référence et par valeur. Le code utilisé pour la question est issu de l'animation de ce module. Si la question est source de confusion, vous pouvez réexécuter l'animation.

3. Cette question permet de vérifier que les stagiaires peuvent reconnaître la syntaxe d'appel d'une fonction, de transmission d'un argument à la fonction et d'affectation d'une valeur de retour.

4. Vous pouvez demander aux stagiaires de partager leurs exemples des emplacements auxquels les fonctions prédéfinies de date et d'heure peuvent être utilisées dans une application.

Atelier 4.1 : Création et utilisation de procédures

Dans le cours 2560A, Introduction à la programmation en Visual Basic.NET avec Microsoft .NET, les stagiaires créeront une application complète lors de plusieurs ateliers. Chaque atelier se poursuit avec le code créé dans l'atelier du scénario précédent. Au début de chaque atelier, les stagiaires peuvent continuer avec leurs propres fichiers ou commencer avec les fichiers fournis.

Dans l'atelier 4.1, les stagiaires devront créer des procédures pour un calcul d'amortissement à utiliser dans l'application d'estimation de remboursement de l'emprunt. Cet atelier se poursuit avec la solution d'atelier créée dans l'atelier 2.1, Création de l'interface utilisateur, du module 2 « Utilisation de formulaires et de contrôles » du cours 2560A, Introduction à la programmation en Visual Basic.NET avec Microsoft .NET.

Utilisation des fonctions financières

Application pratique : Étude des fonctions prédéfinies

viii Module 4 : Utilisation de procédures

Démonstrations Cette section inclut des instructions détaillées concernant les démonstrations, notamment les étapes que vous devez effectuer dans toutes les démonstrations multimédias dirigées.

Pour savoir quels paramètres utiliser pour une visualisation optimale des animations multimédias, reportez-vous à la Liste de préparation du cours incluse dans le kit de l'instructeur.

Présentation multimédia : Écriture de code réutilisable Cette démonstration explique aux stagiaires le concept des procédures. Elle précise en particulier comment structurer le code pour optimiser sa réutilisation, comment créer une procédure dans un module et comment transmettre des arguments et renvoyer une valeur à partir d'une fonction.

Dans cette démonstration, le code issu d'un événement Button Click est transféré dans une procédure dans un module. Des arguments sont ensuite transmis à cette procédure, et cette dernière renvoie une valeur.

! Démarrage de Visual Studio .NET et chargement du projet de démonstration


2. Dans la page de démarrage, sous Commencer, cliquez sur Ouvrir un projet.

3. Dans la boîte de dialogue Ouvrir un projet, recherchez dossier_installation\Democode\Mod04\CircleAreaApplication, puis double-cliquez sur CircleAreaApplication.sln.


1. Cliquez sur le bouton Démarrer. 2. Dans la fenêtre Surface du cercle, dans la zone Diamètre, tapez 10 puis

cliquez sur Calculer. La superficie du cercle s'affiche sous la forme 78,54.

3. Fermez le formulaire.

! Transfert du code dans une procédure 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Form1.vb,

puis cliquez sur Afficher le code. Notez que le code qui calcule la superficie du cercle est contenu dans l'événement Click du bouton Calculer. La fonctionnalité de ce code peut être utile dans d'autres parties de cette application, voire dans d'autres applications. Le transfert du code de l'événement Click de ce contrôle à une procédure facilite la réutilisation de cette fonctionnalité.

2. Sélectionnez le code entre les instructions Private Sub Calculate_Click et End Sub.

3. Dans le menu Edition, cliquez sur Couper.

Module 4 : Utilisation de procédures ix

4. Dans l'Éditeur de code, sous la ligne End Sub, tapez Private Sub Get_Area

puis appuyez sur ENTRÉE. Notez que la ligne End Sub est ajoutée par l'environnement de développement.

5. Dans le menu Edition, cliquez sur Coller. Pour gérer la fonctionnalité du bouton Calculer dans cette application, appelez cette nouvelle procédure à partir de l'événement Click du bouton Calculer.

6. Après Private Sub Calculate_Click, tapez le code suivant sur une nouvelle ligne : Get_Area

! Test de l'application


cliquez sur Calculer. La superficie du cercle s'affiche sous la forme 78,54. Le code qui calcule cette valeur est à présent contenu dans une procédure dans le formulaire.


! Transfert du code dans un fichier de module Pour l'instant, la procédure Get_Area peut être appelée uniquement à partir de Form1. Or, il serait bon que vous puissiez appeler la procédure depuis n'importe quel endroit dans l'application. Pour activer cette fonctionnalité, vous devez transférer la procédure dans un fichier de module. 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

CircleAreaApplication, pointez sur Ajouter, puis cliquez sur Ajouter un nouvel élément.

2. Dans la boîte de dialogue Ajouter un nouvel élément, sous Modèles, cliquez sur Module puis sur Ouvrir.

3. Dans l'Éditeur de code Form1.vb, sélectionnez toutes les lignes de code de Private Sub Get_Area à End Sub.

4. Dans le menu Edition, cliquez sur Couper. 5. Dans l'Éditeur de code Module1.vb, cliquez sur la ligne entre

Module Module1 et End Module.

x Module 4 : Utilisation de procédures

6. Dans le menu Edition, cliquez sur Coller. 7. Dans le menu Affichage, pointez sur Afficher les tâches, puis cliquez sur

Tout. Observez la fenêtre Liste des tâches. Notez que les variables Diameter et CircleArea ne sont pas déclarées. Lorsque la procédure était située dans le code d'un formulaire, Diameter était une référence à la zone de texte qui contenait la valeur du diamètre du cercle. CircleArea était le contrôle Label qui affichait le résultat du calcul. À présent que la procédure est située dans un module, ces variables ne sont pas définies. Pour corriger ces erreurs, vous devez modifier la procédure afin qu'elle accepte un paramètre (le diamètre du cercle) et qu'elle retransmette la valeur de la superficie du cercle calculée.

! Modification de la procédure 1. Remplacez la ligne

Private Sub Get_Area( )

par Private Sub Get_Area(Diameter as Double)

Cette opération modifie la définition de cette procédure, qui accepte à présent un paramètre, le diamètre du cercle. Diameter est désormais une variable de type Double qui peut être utilisée durant toute cette procédure. L'erreur dans la fenêtre Liste des tâches est à présent remplacée par 'Text' n'est pas un membre de 'Double'. Cette erreur doit être corrigée.

2. Remplacez la ligne Radius = CDbl(Diameter.Text) / 2

par Radius = Diameter / 2

Il n'est plus nécessaire de convertir le type de données de Diameter car il est à présent défini en tant que type Double. L'erreur finale est corrigée en changeant la procédure Sub dans une fonction qui renvoie la superficie du cercle comme résultat de la procédure, au lieu de charger la valeur dans une étiquette dans sur le formulaire.

3. Remplacez la ligne Private Sub Get_Area(ByVal Diameter As Double)

par Public Function Get_Area(ByVal Diameter As Double) _ As Double

Notez que l'environnement de développement remplace automatiquement la ligne de code End Sub par End Function. Observez également les mots As Double à la fin de l'instruction. Cette instruction déclare que cette fonction renverra une valeur de type de données Double.

Module 4 : Utilisation de procédures xi

4. Remplacez la ligne CircleArea.Text = Area.ToString("0.00")

par Return Area

Cette ligne signale au système qu'il doit renvoyer la valeur de la variable Area comme résultat de la fonction.

5. Dans Form1.vb, remplacez la ligne Get_Area

par CircleArea.Text = Get_Area(CDbl(Diameter.Text))

Le résultat de la fonction doit être affiché dans l'étiquette appelée CircleArea. Le diamètre issu de la zone de texte doit être transmis en tant que paramètre à la fonction Get_Area. Si vous le souhaitez, vous pouvez également écrire du code pour mettre en forme le résultat. Dans cet exemple, le résultat sera affiché en tant que type Double et ne sera pas arrondi.

! Test de l'application


cliquez sur Calculer. Le code qui calcule cette valeur est à présent contenu dans une procédure Function dans un module. Cette fonction n'est dépendante d'aucun formulaire ou contrôle. Elle utilise un paramètre (le diamètre du cercle) et renvoie la superficie de ce cercle. À présent, cette procédure peut être utilisée de nouveau dans cette application. Elle peut également être utilisée dans une autre application si vous incluez ce fichier de module dans cette application. Prenez l'habitude d'éliminer la duplication du code ou les situations dans lesquelles différentes sections de code offrent la même fonctionnalité. Toute fonctionnalité destinée à être utilisée plusieurs fois doit être créée sous la forme d'un bloc de code réutilisable.


Module 4 : Utilisation de procédures 1

Vue d'ensemble

! Création de procédures

! Utilisation de procédures

! Utilisation de fonctionsprédéfinies

Debugand Deploy

Écriturede code

Accèsaux données

Utilisationde Visual

Studio .NET


Créationd'une

interface

********************DOCUMENT A L�USAGE EXCLUSIF DE L�INSTRUCTEUR********************

Pour simplifier la programmation d'une application, en particulier un projet important, vous pouvez la décomposer en plus petits éléments. Les procédures peuvent vous aider à regrouper votre code dans des sections logiques, et à condenser les tâches répétées ou partagées, telles que les calculs fréquemment utilisés. Dans ce module, vous apprendrez à créer et à utiliser des procédures.


! faire la distinction entre une procédure Sub et une procédure Function ; ! créer et appeler les procédures Sub et Function ; ! écrire des procédures dans des modules pour permettre la réutilisation du

code ; ! transmettre des arguments par valeur et par référence ; ! utiliser des fonctions prédéfinies dans le code de votre application.

Introduction

Objectifs

2 Module 4 : Utilisation de procédures

Leçon : Création de procédures

! Présentation des procédures

! Création de procédures Sub

! Création de procédures Function

! Déclaration d'arguments dans les procédures

! Utilisation d'arguments facultatifs

! Réutilisation du code


Cette leçon explique comment créer des procédures Sub et Function, comment déclarer des arguments dans une procédure et comment créer des procédures dans un module.

Cette leçon inclut les rubriques et les activités suivantes :

! Présentation des procédures ! Création des procédures Sub ! Création des procédures Function ! Déclaration d'arguments dans les procédures ! Présentation multimédia : Transmission d'arguments ! Utilisation d'arguments facultatifs ! Présentation multimédia : Écriture de code réutilisable ! Réutilisation du code ! Application pratique : Création d'une fonction dans un module


! décrire et créer une procédure Sub ; ! décrire et créer une procédure Function ; ! expliquer la différence entre la transmission d'arguments à une procédure

par valeur et la transmission par référence ; ! déclarer des arguments, notamment des arguments facultatifs, dans une

procédure ; ! créer des procédures dans un module.

Introduction




Présentation des procédures

! Les procédures représentent les instructions du code exécutable dans un programme. Elles sont insérées entreune instruction de déclaration et une instruction End

! Il existe trois types de procédures :

" Procédures Sub(y compris les procédures d'événement Sub)

" Procédures Function

" Procédures Property

! Permettent la réutilisation du code

! Sont déclarées en tant que procédures publiques par défaut


Les procédures représentent les instructions du code exécutable dans un programme. Dans une procédure, les instructions sont insérées entre une instruction de déclaration et une instruction End.

En fonction des références, les termes méthodes, procédures et fonctions peuvent être utilisés indifféremment. Ce module adopte la terminologie utilisée dans la documentation de Microsoft® Visual Studio® .NET.

Il existe trois types de procédures dans Visual Basic® .NET : les procédures Sub, Function et Property.

! Les procédures Sub effectuent des actions mais ne renvoient aucune valeur à la procédure appelante. Les gestionnaires d'événements sont des procédures Sub qui sont exécutées en réponse à un événement.

! Les procédures Function peuvent renvoyer une valeur à la procédure appelante. L'instruction MessageBox.Show constitue un exemple d'une fonction.

! Les procédures Property renvoient et affectent des valeurs de propriétés de classe, des structures ou des modules.

Pour plus d'informations sur la création et l'utilisation des procédures Property, reportez-vous au module 7, Programmation orientée objet en Visual Basic .NET, du cours 2560A intitulé Introduction à la programmation en Visual Basic .NET avec Microsoft .NET.

Définition

Remarque

Types de procédures

Remarque


Une procédure peut être invoquée, ou appelée, à partir d'une autre procédure. Lorsqu'une procédure appelle une autre procédure, le contrôle est transféré à la seconde procédure. Lorsque l'exécution du code de la seconde procédure est terminée, le code renvoie le contrôle à la procédure qui l'a appelé.

Du fait de cette fonctionnalité, les procédures sont utiles pour effectuer des tâches répétées ou partagées. Au lieu d'écrire le même code à plusieurs reprises, vous pouvez écrire une procédure puis l'appeler depuis différents endroits de votre application ou depuis d'autres applications.

Vous pouvez utiliser un modificateur d'accès pour définir l'accessibilité des procédures que vous écrivez ; en d'autres termes, l'autorisation pour un autre code d'appeler la procédure. Si vous ne stipulez aucun modificateur d'accès, les procédures sont déclarées en tant que procédures publiques par défaut.

Le tableau suivant présente les options d'accessibilité pour la déclaration d'une procédure dans un module.

Modificateur d'accès Description

Public Aucune restriction d'accès

Friend Accessible à partir du programme qui contient la déclaration et à partir de tout autre endroit dans le même assemblage

Private Accessible uniquement dans le module qui contient la déclaration

Le modificateur d'accès Protected peut être utilisé uniquement pour les procédures déclarées dans une classe. Pour plus d'informations sur la déclaration de procédures dans une classe, reportez-vous au module 7, Programmation orientée objet en Visual Basic .NET, du cours 2560A intitulé Introduction à la programmation en Visual Basic .NET avec Microsoft .NET.

Utilisation de procédures

Accessibilité des procédures

Remarque


Création de procédures Sub

Private Sub AboutHelp( )

MessageBox.Show("MonProgramme V1.0", "Aide de MonProgramme")

End Sub

Private Sub AboutHelp( )

MessageBox.Show("MonProgramme V1.0", "Aide de MonProgramme")

End Sub

[Modificateur d'accès] Sub NomDeLaProcédure _[(Liste des arguments)]

' Instructions de la procédure Sub

End Sub

[Modificateur d'accès] Sub NomDeLaProcédure _[(Liste des arguments)]

' Instructions de la procédure Sub

End Sub

Exemple :

Les procédures Sub effectuent des actions mais nerenvoient pas de valeur à la procédure appelante


Une procédure Sub est une série d'instructions Visual Basic insérées entre les instructions Sub et End Sub. Les procédures Sub effectuent des actions mais ne renvoient pas de valeur à la procédure appelante.

Utilisez la syntaxe suivante pour créer une procédure Sub :

[Modificateur d'accès] Sub NomDeLaProcédure _ [(Liste des arguments)] ' Emplacement des instructions de la procédure Sub End Sub

Le code suivant crée une procédure Sub AboutHelp qui utilise un message pour afficher le nom d'un produit et le numéro de version :

Private Sub AboutHelp( ) MessageBox.Show("MonProgramme V1.0", "Aide de MonProgramme") End Sub

Définition

Syntaxe pour créer une procédure Sub

Exemple de procédure Sub


Création de procédures Function

Public Function DoubleTheValue(ByVal J As Double) As _ Double

. . .Return J*2

. . .End Function

Public Function DoubleTheValue(ByVal J As Double) As _ Double

. . .Return J*2

. . .End Function

[Modificateur d'accès] Function NomDeLaFonction _[(Liste des arguments)] As TypeDeDonnées

' Instructions de la fonction, y compris l'instruction' Return facultative

End Function

[Modificateur d'accès] Function NomDeLaFonction _[(Liste des arguments)] As TypeDeDonnées

' Instructions de la fonction, y compris l'instruction' Return facultative

End Function

Exemple :

Les procédures Function effectuent des actions et peuvent retourner une valeur au programme appelant


Une procédure Function est une série d'instructions Visual Basic insérées entre les instructions Function et End Function. Les procédures Function sont similaires aux procédures Sub, mais les fonctions peuvent renvoyer une valeur au programme appelant.

Utilisez la syntaxe suivante pour créer une procédure Function :

[Modificateur d'accès] Function NomDeLaFonction _ [(Liste des arguments)] As TypeDeDonnées ' Emplacement des instructions de la fonction, y compris ' l'instruction Return End Function

Le code suivant crée une fonction appelée Square qui renvoie la racine carrée d'un entier :

Function Square(SquareValue As Integer) As Integer Square = SquareValue * SquareValue End Function

La valeur qu'une procédure Function renvoie au programme appelant est appelée sa valeur de retour. La fonction utilise l'une des deux méthodes suivantes pour renvoyer la valeur :

! Elle affecte une valeur au nom de sa fonction dans une ou plusieurs instructions de la procédure. Le contrôle n'est pas renvoyé au programme appelant tant qu'une instruction Exit Function ou End Function n'est pas exécutée. L'instruction Exit Function entraîne une sortie immédiate d'une procédure Function. Le nombre d'instructions Exit Function figurant (où que ce soit) dans la procédure n'est pas limité.

! Elle utilise une instruction Return pour spécifier la valeur de retour et renvoie immédiatement le contrôle au programme appelant.

Définition

Syntaxe pour créer une procédure Function

Exemple de procédure Function

Renvoi de valeurs


L'affectation de la valeur de retour au nom de la fonction est plus intéressant dans la mesure où le contrôle n'est pas renvoyé à partir de la fonction tant que le programme ne rencontre pas d'instruction Exit Function ou End Function. Vous pouvez ainsi affecter une valeur préliminaire et la modifier par la suite, si nécessaire.

L'exemple suivant affecte la valeur de retour au nom de fonction DoubleTheValue puis utilise l'instruction Exit Function pour renvoyer le contrôle à la procédure appelante :

Function DoubleTheValue(ByVal j As Integer) As Double . . . DoubleTheValue = j*2 ' Le contrôle reste dans la fonction . . . Exit Function ' Le contrôle revient à la fonction appelante . . . End Function

Si vous quittez la fonction sans affecter de valeur de retour, la fonction renvoie la valeur par défaut correspondant au type de données de la fonction. Par exemple, elle renvoie 0 pour les types de données Byte, Char, Decimal, Double, Integer, Long, Short et Single.

L'instruction Return affecte la valeur de retour et quitte la fonction, dans le même temps, comme l'indique l'exemple suivant :

Function DoubleTheValue(ByVal j As Integer) As Double . . . Return j*2 ' Le contrôle revient immédiatement à la fonction appelante . . . End Function

Exemple d'affectation de la valeur de retour

Exemple d'utilisation de l'instruction Return


Déclaration d'arguments dans les procédures

! Les Arguments sont les données transmises aux procédures! Vous pouvez transmettre des arguments via ByVal ou ByRef

" ByVal : La procédure ne peut pas modifier la valeur de la variable d'origine

" ByRef : La procédure peut modifier la valeur de la variable d'origine

" Exception : Les arguments non variables ne sont jamais modifiés dans le code appelant, même s'ils sont transmis par référence

! Dans Visual Basic .NET, la méthode de transmission par défaut estla transmission par valeur (ByVal)

! Syntaxe et exemple :

([ByVal|ByRef] nomArgument As TypeDeDonnées)([ByVal|ByRef] nomArgument As TypeDeDonnées)

(ByVal Name As String)(ByVal Name As String)


Une procédure qui exécute des tâches partagées ou répétées utilise différentes informations pour chaque appel. Ces informations peuvent être composées de variables, de constantes et d'expressions qui sont transmises à la procédure par la procédure appelante. Une valeur transmise à une procédure est appelée argument.

Lorsque vous définissez une procédure dans Visual Basic .NET, vous décrivez les données et le type de données que la procédure va accepter à partir d'une procédure appelante. Les éléments définis dans la procédure sont appelés paramètres.

Lorsque vous appelez la procédure, vous remplacez chaque paramètre par une valeur réelle. Les valeurs que vous affectez à la place des paramètres sont appelées arguments.

Bien qu'il existe une différence subtile entre un argument et un paramètre, ces termes sont souvent utilisés indifféremment. Ce module adopte la terminologie utilisée dans la documentation de Visual Studio .NET.

Introduction

Comparaison entre les paramètres et les arguments

Remarque


Lorsque vous définissez une procédure, vous définissez les méthodes qui peuvent être utilisées par d'autres procédures pour transmettre des arguments à la procédure. Vous pouvez choisir de transmettre des arguments par référence (ByRef) ou par valeur (ByVal). Dans Visual Basic .NET, la méthode de transmission par défaut est la transmission par valeur. Si vous ne spécifiez ni ByVal ni ByRef dans la définition de vos paramètres, ByVal est automatiquement ajouté à la définition des paramètres.

Méthode de transmission

Explication

Implications

Avantage

Par valeur

Mot clé : ByVal

La procédure appelée reçoit une copie des données.

Si la procédure appelée modifie la copie, la valeur initiale de la variable ne change pas. Lorsque l'exécution revient à la procédure appelante, la variable contient la valeur qu'elle avait avant la transmission de la valeur.

Évite que la variable ne soit modifiée par la procédure appelée.

Par référence

Mot clé : ByRef

La procédure appelée reçoit une référence aux données initiales (l'adresse des données en mémoire).

La procédure appelée peut modifier directement la variable. Lorsque l'exécution revient à la procédure appelante, la variable contient la valeur modifiée.

La procédure appelée peut utiliser l'argument pour renvoyer une nouvelle valeur au code appelant.

L'élément de programmation sur lequel repose un argument peut être un élément variable (dont la valeur peut être modifiée) ou un élément non variable. Les arguments non variables ne sont jamais modifiés dans le code appelant, même s'ils sont transmis par référence. La procédure appelée peut modifier sa copie de ce type d'argument, mais cette modification n'a aucune incidence sur l'élément sous-jacent dans le code appelant.

Le tableau suivant répertorie les éléments variables et non variables.

Éléments variables (susceptibles d'être modifiés)

Éléments non variables

Variables déclarées, notamment les variables objet

Constantes

Champs (de classes) Littéraux

Éléments de tableaux Énumérations

Éléments de structure Expressions

Transmission via ByVal et ByRef

Exceptions


La syntaxe utilisée pour déclarer les arguments des procédures Sub et des procédures Function est la même. Vous déclarez un argument d'une procédure de la même manière que vous déclarez une variable, en spécifiant le nom de l'argument et le type de données. Vous pouvez également spécifier la méthode de transmission et indiquer si l'argument est facultatif.

La syntaxe de chaque argument dans la liste des arguments d'une procédure est la suivante :

([ByVal|ByRef] [ParamArray] nomArgument As TypeDeDonnées)

Pour plus d'informations sur la syntaxe de ParamArray, reportez-vous à la rubrique Transmission de tableaux à des procédures dans ce module.

Si l'argument est facultatif, vous devez inclure le mot clé Optional et indiquer une valeur par défaut dans la déclaration, comme suit :

Optional [ByVal|ByRef] nomArgument _ As TypeDeDonnées=valeurParDefaut

Pour plus d'informations sur les arguments facultatifs, reportez-vous à la rubrique Utilisation d'arguments facultatifs dans ce module.

Dans l'exemple suivant, la procédure Sub Hello est destinée à transmettre un argument Name de type String par valeur à partir d'une procédure appelante.

Public Sub Hello(ByVal Name As String) MessageBox.Show("Bonjour, " & Name & "!") End Sub

Le nom des arguments utilisés lors de l'appel d'une procédure ne doit pas nécessairement correspondre au nom des paramètres utilisés pour définir la procédure.

Déclaration d'arguments

Remarque

Remarque

Exemple de déclaration d'un argument

Remarque


Présentation multimédia : Transmission d'arguments


Cette animation explique les différences entre la transmission d'arguments aux procédures par valeur et leur transmission par référence.

Lorsque vous transmettez un argument à une procédure, vous pouvez choisir de transmettre l'argument par référence ou par valeur. Cette animation explique les différences entre la transmission par référence et la transmission par valeur d'un argument.

En premier lieu, optez pour la transmission de l'argument par valeur, car il s'agit de la procédure de transmission par défaut dans Visual Basic® .NET.

Lorsque vous transmettez un argument par valeur, à l'aide de ByVal, une copie de la valeur est créée puis transmise à la procédure que vous appelez. Lorsque vous transmettez un argument ByVal, les modifications apportées par la procédure sont effectuées uniquement sur la copie de l'argument. L'argument d'origine n'est pas modifié.

Pour comprendre l'utilisation de ce concept, prenons l'exemple de code suivant :

Sub Count(ByVal number As Integer) number = number + 1 End Sub Sub Test( ) Dim myNumber As Integer = 10 Count(myNumber) MessageBox.Show(myNumber) End Sub

Introduction

Script d'animation


La procédure Sub Count prend un paramètre, number, par valeur. Elle ajoute 1 à cette valeur.

Dans la procédure d'appel :

! La première ligne de code affecte la valeur 10 à la variable myNumber. ! La deuxième ligne de code transmet myNumber à la procédure Sub Count. ! La troisième ligne de code affiche la valeur de la variable myNumber dans

un message.

En vous basant sur ce que vous avez appris sur la transmission par valeur, quelle sera la valeur affichée dans le message ?

La réponse est 10. Pourquoi ?

Lorsque vous appelez la procédure Count, une copie de myNumber est transmise à la procédure. La copie de myNumber est remplacée par 11, mais cette copie est détruite lorsque la procédure Count a terminé d'exécuter le code. Elle n'est pas retransmise à la procédure d'appel. Le message affiche la valeur initiale de myNumber, soit 10.

À présent, prenons l'exemple de la transmission d'une valeur par référence. Lorsque vous transmettez une valeur par référence, à l'aide de ByRef, la procédure appelée reçoit une référence aux données proprement dites, et non une copie des données. La routine appelée recourt à cette référence pour utiliser et modifier la valeur des données.

Pour transmettre la valeur par référence, vous devez simplement apporter une modification à ce code en remplaçant le mot ByVal dans la déclaration de procédure par ByRef. Bien qu'il s'agisse d'une modification mineure du code, ses implications sont importantes, comme l'illustre le code suivant :

Sub Count(ByRef number As Integer) number = number + 1 End Sub Sub Test( ) Dim myNumber As Integer = 10 Count(myNumber) MessageBox.Show(myNumber) End Sub

La zone de message dans la procédure d'appel affiche à présent 11 comme valeur de myNumber. Pourquoi ?

Lorsque vous appelez la procédure Count, une référence de la variable est transmise à la procédure. La procédure Count remplace la valeur de la variable par 11. Lorsque le message dans la procédure d'appel extrait la valeur de myNumber, elle extrait la nouvelle valeur.


Lors de la conception de procédures dans votre application, n'oubliez pas de déterminer, pour chaque argument déclaré, si l'argument doit être transmis par valeur ou par référence.

! L'avantage de la transmission par référence réside dans le fait que la procédure peut utiliser l'argument pour renvoyer une valeur au code appelant.

! L'avantage de la transmission par valeur réside dans le fait que la variable ne peut pas être modifiée par la procédure appelée.

! Dans Visual Basic .NET, la méthode de transmission par défaut est la transmission par valeur.


Utilisation d'arguments facultatifs

! Règles de déclaration des arguments facultatifs :

" Vous devez spécifier une valeur par défaut

" La valeur par défaut doit être une expression de constante

" Chaque argument qui suit un argument facultatif doitégalement être facultatif

! Syntaxe :

Function Add (ByVal value1 As Integer, ByVal value2 As _ Integer, Optional ByVal value3 As Integer = 0) As Integer

Function Add (ByVal value1 As Integer, ByVal value2 As _ Integer, Optional ByVal value3 As Integer = 0) As Integer

(Optional [ByVal|ByRef] nomArgument As _ TypeDeDonnées=valeurParDefaut)

(Optional [ByVal|ByRef] nomArgument As _ TypeDeDonnées=valeurParDefaut)

! Exemple :


Vous pouvez spécifier qu'un argument d'une procédure est facultatif et qu'il ne doit pas être indiqué lorsque la procédure est appelée. Vous disposez ainsi d'une certaine liberté lorsque votre procédure est appelée par une autre procédure. L'utilisateur peut choisir de fournir, ou non, un argument.

Les arguments facultatifs sont indiqués par le mot clé Optional dans la définition de la procédure. Par ailleurs, lorsque vous déclarez un argument facultatif, vous devez respecter les règles suivantes :

! Vous devez spécifier une valeur par défaut pour tous les arguments facultatifs.

! La valeur par défaut d'un argument facultatif doit être une expression de constante.

! Chaque argument qui suit un argument facultatif dans la définition de la procédure doit également être facultatif.

Le code suivant présente la syntaxe de la déclaration d'un argument facultatif :

Optional [ByVal|ByRef] nomArgument As _ TypeDeDonnées=valeurParDefaut

L'exemple suivant présente la déclaration d'une procédure contenant un argument facultatif :

Function Add(ByVal value1 As Integer, ByVal value2 As _ Integer, Optional ByVal value3 As Integer = 0) As Integer ' La valeur par défaut de l'argument facultatif est 0

Introduction

Déclaration d'un argument facultatif

Exemple d'argument facultatif


L'exemple suivant contient une erreur ; n'oubliez pas que les arguments qui suivent un argument facultatif doivent également être facultatifs.

Function Add(ByVal value1 As Integer, Optional ByVal _ value2 As Integer = 0, ByVal value3 As Integer) As Integer ' Engendre une erreur

Lorsque vous appelez une procédure contenant un argument facultatif, vous pouvez, à votre convenance, spécifier ou non l'argument. Si vous ne spécifiez pas l'argument, la procédure utilise la valeur par défaut déclarée pour cet argument.

Lorsque vous n'indiquez pas un ou plusieurs arguments facultatifs dans la liste des arguments, vous devez utiliser des virgules pour séparer les espaces signalant leur position. L'appel suivant spécifie le premier et le quatrième argument, mais pas le second ni le troisième :

SubCount(arg1, , , arg4) ' Ne spécifie pas les arguments 2 et 3 (arg2 et arg3)

Exemple d'argument facultatif incorrect

Appel de procédures contenant des arguments facultatifs


Présentation multimédia : Écriture de code réutilisable


Cette démonstration présente le concept des procédures. Elle explique en particulier comment structurer le code pour optimiser sa réutilisation, comment créer une procédure dans un module et comment transmettre des arguments et renvoyer une valeur à partir d'une fonction.


Réutilisation du code

[Public|Friend] Module NomDuModule. . .

End Module

[Public|Friend] Module NomDuModule. . .

End Module

! Création d'un module :

ÉlémentsÉÉlléémentsments FonctionFonctionFonction

StructureStructure Crée des objets qui ne doivent pas êtreétendus

Crée des objets qui ne doivent pas êtreétendus

ExemplesExemplesExemples

SizePoint

SizePoint

ModuleModule Fournit des fonctions d'utilitaire et des donnéesglobales

Fournit des fonctions d'utilitaire et des donnéesglobales

Conversion de températures

Conversion de températures

ClasseClasse Étend des objets, ou pour les objets dont les ressources doivent être nettoyées

Étend des objets, ou pour les objets dont les ressources doivent être nettoyées

FormsButton

FormsButton


La création d'un code qui puisse être réutilisé constitue l'une des procédures les plus importantes lorsque vous créez une application Visual Basic. La manière dont vous rédigez le code a une incidence sur ses possibilités de réutilisation.

Vous pouvez écrire du code destiné à être réutilisé dans des structures, des modules ou des classes. Le tableau suivant présente les situations dans lesquelles vous choisissez chacune de ces options.

Élément Fonction Exemple

Structure Crée des objets qui ne doivent pas être étendus et qui ont une petite taille d'instance

Size et Point sont des structures qui sont disponibles dans la bibliothèque de classes Microsoft .NET Framework

Module Fournit des fonctions d'utilitaire et des données globales qui peuvent être utilisées par de nombreux modules et classes

Fonctions d'utilitaire telles que la conversion de températures, le calcul d'une superficie ou l'accès aux données, requises par de nombreux modules

Classe Étend des objets, ou pour les objets dont les ressources doivent être nettoyées

Classe Forms, Button, etc.

Introduction

Écriture du code en vue d'une réutilisation


Le code suivant indique comment vous pouvez écrire une procédure dans une structure. Supposons que les variables x, y et z dans l'exemple ont déjà été déclarées.

Structure TableDimensions Private legHeight, topWidth, topDepth As Integer Public Sub New(ByVal legHeight As Integer, _ ByVal topWidth As Integer, ByVal topDepth as Integer) Me.legHeight = x Me.topWidth = y Me.topDepth = z End Sub End Structure

Pour créer un module, vous devez tout d'abord ajouter un module dans votre projet. Ensuite, vous écrivez les instructions de code qui définissent les données et les procédures de votre module.

! Pour ajouter un module dans un projet 1. Si l'Explorateur de solutions n'est pas ouvert, cliquez sur Explorateur de

solutions dans le menu Affichage. 2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur votre

projet, pointez sur Ajouter, puis cliquez sur Ajouter un nouvel élément. 3. Dans la boîte de dialogue Ajouter un nouvel élément, dans la zone Nom,

tapez un nom pour votre module, sélectionnez Module sous Modèles, puis cliquez sur Ouvrir.

La syntaxe suivante déclare un bloc de module :

[Public|Friend] Module NomDuModule ' Ajoutez les classes, propriétés, méthodes, champs et ' événements du module End Module

Tout comme pour les procédures et les variables, vous pouvez utiliser des modificateurs d'accès pour définir l'accessibilité d'un module. Si vous n'utilisez aucun modificateur d'accès, les modules sont déclarés en tant que Friend par défaut.

Le tableau suivant définit les modificateurs d'accès disponibles pour un module.

Modificateur d'accès Définition

Public Aucune restriction d'accès

Friend Accessible à partir du programme qui contient la déclaration et à partir de tout autre endroit dans le même assemblage

Pour plus d'informations sur les classes, reportez-vous au module 7, Programmation orientée objet en Visual Basic .NET, du cours 2560A, intitulé Introduction à la programmation en Visual Basic .NET avec Microsoft .NET.

Écriture de procédures dans une structure

Création d'un module

Syntaxe

Accessibilité d'un module

Remarque


Application pratique : Création d'une fonction dans un module

Ouvrez un nouveau projet

Ajoutez un nouveau module au projet

Écrivez le code de la fonction

Créez une fonction dans le module


Dans cette application pratique, vous devrez ajouter un module dans un projet et créer une fonction dans le module. La fonction transmettra height et width en tant qu'arguments et renverra Area.

Le code que vous créez dans cette application pratique sera utilisé comme code de démarrage de l'application pratique Utilisation de la valeur de retour d'une fonction, figurant plus loin dans ce module.

! Création d'une fonction dans un module 1. Ouvrez un nouveau projet dans Visual Basic .NET. Utilisez le modèle

Application Windows. Utilisez le nom de projet CalculateArea, l'emplacement dossier_installation\Practices\Mod04\Area, puis cliquez sur OK.

2. Ajoutez un nouveau module au projet. Pour ce faire, dans le menu Projet, cliquez sur Ajouter un nouvel élément. Dans le volet Modèles, cliquez sur Module, conservez le nom par défaut, puis cliquez sur Ouvrir.

3. Dans le module, créez une nouvelle fonction appelée Area, qui renvoie un type de données Single. a. La fonction doit transmettre deux arguments appelés height et width par

valeur. Déclarez chaque argument en tant que Single. b. Dans le corps de la fonction, écrivez le code pour multiplier height par

width, et pour affecter la valeur de retour à Area, comme l'indique le code suivant : Area = height * width

Remarque


4. Enregistrez votre projet. Votre code final doit se présenter comme suit : Module Module1 Function Area(ByVal height As Single, _ ByVal width As Single) As Single Area = height * width End Function End Module

Vous ne pourrez pas tester la fonction avant d'avoir réalisé l'application pratique Utilisation de la valeur de retour d'une fonction.

Les fichiers solution sont situés dans le dossier dossier_installation\Practices\ Mod04\Area\Solution.

Remarque

Fichiers solution


Leçon : Utilisation de procédures

! Utilisation des procédures Sub

! Utilisation des procédures Function

! Transmission de tableaux à des procédures

! Création d'une procédure Sub Main


Une utilisation efficace des procédures offre un avantage important dans la mesure où elle permet de réutiliser le code. Les procédures que vous créez pour un programme peuvent être utilisées dans l'ensemble de ce programme et dans d'autres projets, et bien souvent sans aucune modification ou simplement avec quelques modifications. Les procédures sont utiles pour les tâches répétées ou partagées, telles que les calculs fréquemment utilisés.

Cette leçon explique comment utiliser les procédures Sub et Function, comment utiliser la syntaxe ParamArray pour transmettre des arguments, et comment modifier le démarrage de l'application en créant une procédure Sub Main.


! Utilisation des procédures Sub ! Utilisation des procédures Function ! Application pratique : Utilisation de la valeur de retour d'une fonction ! Transmission de tableaux à des procédures ! Création d'une procédure Sub Main ! Application pratique : Création d'une procédure Sub Main


! appeler et transmettre des arguments à une procédure Sub ; ! transmettre des arguments à une fonction et utiliser une valeur de retour ; ! utiliser ParamArray pour déclarer un tableau dans un argument d'une

procédure ; ! modifier le démarrage de l'application en créant une procédure Sub Main.

Introduction




Utilisation des procédures Sub

Public Sub Hello(ByVal name As String)

MessageBox.Show("Bonjour " & Name)

End Sub

Public Sub Hello(ByVal name As String)

MessageBox.Show("Bonjour " & Name)

End Sub

Sub Test( )

Hello("John")

End Sub

Sub Test( )

Hello("John")

End Sub


Pour utiliser une procédure Sub, vous devez l'appeler à partir d'une autre procédure.

Chaque fois qu'une procédure Sub est appelée, ses instructions sont exécutées, en commençant par la première instruction exécutable qui suit l'instruction Sub, et en se terminant par la première instruction End Sub, Exit Sub ou Return rencontrée. Une fois que la procédure Sub a exécuté son code, elle renvoie l'exécution du programme à la ligne de code qui suit la ligne ayant appelé la procédure Sub.

La syntaxe d'appel d'une procédure Sub est la suivante :

[Call] NomDeLaFonction [(Liste des arguments)]

! Vous devez appeler la procédure Sub sur une ligne distincte dans votre code (vous ne pouvez pas l'appeler en utilisant son nom dans une expression).

! L'instruction appelante doit spécifier des valeurs pour tous les arguments qui ne sont pas facultatifs.

! Vous pouvez éventuellement utiliser l'instruction Call pour appeler une procédure Sub. L'utilisation de l'instruction Call peut optimiser la lisibilité de votre programme.

Les procédures Sub ne renvoient pas de valeur à l'instruction appelante. Une procédure Sub peut toutefois retransmettre des informations au code appelant en modifiant les arguments transmis par référence.

Le code suivant présente une procédure d'événement qui appelle une procédure Sub nommée SetData :

Sub DataButton_Click(...) SetData( ) End Sub

Introduction

Flux du code

Appel d'une procédure Sub

Remarque

Exemple d'un appel simple


Vous pouvez également utiliser le code suivant pour effectuer la même tâche :

Sub DataButton_Click(...) Call SetData( ) End Sub

L'appel suivant contient une erreur :

Sub DataButton_Click(...) MessageBox.Show(SetData( )) End Sub ' Génère une erreur, car la méthode Show attend un type de ' données String, et non une procédure

Examinez la définition suivante pour la procédure Sub SetData :

Public Sub SetData(ByVal cars As Integer, ByVal trucks As _ Integer, ByVal vans As Integer) ' Code de la procédure SetData End Sub

La syntaxe utilisée pour appeler cette procédure inclut le nom de la procédure et la liste des arguments entre parenthèses, comme l'indique le code suivant :

Sub DataButton_Click(...) SetData(10, 20, 30) End Sub

L'appel suivant de la procédure SetData définie dans l'exemple ci-avant contient une erreur.

Sub DataButton_Click( ) SetData(10, 20) End Sub ' Génère une erreur, car le 3ème paramètre de la procédure ' SetData ne comporte aucune valeur. L'instruction appelante ' doit spécifier des valeurs pour tous les arguments qui ne ' sont pas facultatifs.

Exemple d'utilisation de l'instruction Call

Exemple d'un appel simple incorrect

Exemple d'un appel incluant des arguments

Exemple incorrect d'un appel incluant des arguments


Dans cette application pratique, vous devrez créer deux procédures. La première procédure transmettra un argument par référence. La seconde procédure appellera la première procédure et transmettra une valeur par référence. Vous devrez observer l'incidence de l'appel d'une procédure et de la transmission d'une valeur par référence.

! Création de l'interface utilisateur 1. Ouvrez un nouveau projet dans Visual Basic .NET. Utilisez le modèle

Application Windows. Utilisez le nom de projet ByRefTest, l'emplacement dossier_installation\Practices\Mod04\ ByRefTest, puis cliquez sur OK.

2. Ouvrez le formulaire Form1 en mode Design. 3. Ouvrez la boîte à outils. Ajoutez un contrôle TextBox et un contrôle Button

dans votre formulaire. Disposez les contrôles de sorte que votre formulaire ressemble à la capture d'écran suivante :

! Création d'une procédure qui transmet un argument par référence 1. Ouvrez l'Éditeur de code correspondant à Form1. 2. Créez une procédure appelée Hello qui transmet un argument, Name, de

type String par référence. Votre code doit se présenter comme suit : Public Sub Hello(ByRef Name As String) End Sub

3. Pour voir l'incidence de la transmission d'une variable par référence lorsque

vous appelez une seconde procédure, ajoutez les trois lignes de code suivantes à la procédure Hello : a. Affichage de la valeur actuelle de Name dans un message. b. Affectation de la valeur Samantha à la variable Name. c. Affichage de la nouvelle valeur de Name dans un message. Votre code doit se présenter comme suit : Public Sub Hello(ByRef Name As String) MessageBox.Show("Bonjour, " & Name & "!") Name = "Samantha" MessageBox.Show("Bonjour, " & Name & "!") End Sub

Application pratique (facultative) Transmission d'arguments par référence


! Appel d'une procédure et transmission d'un argument • Ajoutez un gestionnaire d'événements pour l'événement Button1_Click.

Dans le gestionnaire d'événements, appelez la procédure Hello et transmettez la propriété Text de TextBox1 en tant qu'argument. Votre code doit se présenter comme suit : Private Sub Button1_Click(...) Handles Button1.Click Hello(TextBox1.Text) End Sub

! Exécution de l'application et test des résultats 1. Exécutez l'application. 2. Tapez votre nom dans TextBox1. 3. Cliquez sur Button1, vérifiez que votre nom apparaît, puis cliquez sur OK.

Le second message contenant le nom « Samantha » s'ouvre instantanément. 4. Avant de cliquer sur OK, observez la zone de texte. Lorsque vous cliquez

sur OK, observez la modification dans la zone de texte. Le nom « Samantha » apparaît dans la zone de texte dès que le message se ferme, bien qu'aucun code destiné à affecter une nouvelle valeur à la propriété TextBox1.Text n'ait été écrit.

Les fichiers solution correspondant à cette application pratique sont situés dans le dossier dossier_installation\Practices\Mod04\ ByRefTest\Solution.

Fichiers solution


Utilisation des procédures Function

! Appel d'une fonction

" Vous devez inclure le nom de la fonction à droite d'uneinstruction d'assignation

" Vous devez utiliser le nom de la fonction dans uneexpression

Dim celsiusTemperature As Single

celsiusTemperature = FtoC(80)

Dim celsiusTemperature As Single

celsiusTemperature = FtoC(80)

If FtoC(userValue) < 0 Then ...

End If

If FtoC(userValue) < 0 Then ...

End If


Une procédure Function est différente d'une procédure Sub dans la mesure où elle peut renvoyer une valeur à la procédure appelante.

Pour appeler une procédure Function, vous devez inclure son nom et ses arguments soit à droite d'une instruction d'assignation, soit dans une expression. Examinons la fonction suivante, qui convertit une température en Fahrenheit en une température en Celsius.

Function FtoC(ByVal temperature As Single) As Single ' Convertit les Fahrenheit en Celsius FtoC = (temperature - 32.0) * (5 / 9) End Function

L'exemple suivant illustre la méthode d'appel de cette fonction que vous pouvez utiliser :

Dim celsiusTemperature As Single celsiusTemperature = FtoC(80) ' Appelez la procédure en incluant son nom et ses arguments ' à droite d'une instruction d'assignation. Dans cet appel, ' la valeur 80 est transmise à la fonction FtoC, et la ' valeur de retour est assignée à celsiusTemperature. If FtoC(userValue) < 0 Then . . . ' Appelez la procédure en l'utilisant dans une expression. ' Dans cet appel, la fonction FtoC est utilisée dans le ' cadre d'une expression. End If

Chaque fois que la fonction est appelée, ses instructions sont exécutées, en commençant par la première instruction exécutable qui suit l'instruction Function, et en se terminant par la première instruction End Function, Exit Function ou Return rencontrée.

Introduction

Appel d'une fonction

Flux du code


Application pratique : Utilisation de la valeur de retour d'une fonction

Créez l'interface utilisateur

Écrivez le code de l'application


Dans cet exercice, vous devrez créer une application simple qui calcule la superficie d'un rectangle, en fonction de sa hauteur et de sa largeur.

En premier lieu, vous devrez créer l'interface utilisateur de l'application. L'utilisateur saisira les valeurs correspondant à la hauteur et à la largeur dans deux zones de texte sur un formulaire, puis il cliquera sur un bouton pour calculer la superficie du rectangle d'après les dimensions données. Le résultat s'affichera sous forme d'une étiquette sur le formulaire.

Ensuite, vous devrez écrire le code pour l'application. Vous appellerez la fonction Area que vous avez créée dans la première application pratique de ce module (Création d'une fonction dans un module), transmettrez les arguments à la fonction, puis renverrez une valeur.

! Création de l'interface utilisateur 1. Ouvrez le projet CalculateArea que vous avez créé dans l'application

pratique Création d'une fonction dans un module. Ce projet est situé dans le dossier dossier_installation\Practices\ Mod04\Area. Si vous n'avez pas réalisé cette application pratique, ouvrez le fichier solution CalculateArea.sln situé dans le dossier dossier_installation\Practices\Mod04\FunctionReturnValue\Starter, puis familiarisez-vous avec le formulaire et le module dans le projet.

2. Ouvrez le formulaire Form1 en mode Design.


3. Ouvrez la boîte à outils. Ajoutez quatre contrôles Label, deux contrôles TextBox et un contrôle Button au formulaire. Disposez les contrôles de sorte que votre formulaire ressemble à la capture d'écran suivante :

4. Définissez les propriétés des contrôles en vous reportant aux valeurs du tableau suivant.

Contrôle Propriété Nouvelle valeur Label1 Text Hauteur Label2 Text Largeur Label3 Text Aire Label4 Text aucune

TextBox1 Text aucune

TextBox2 Text aucune

! Écriture du code de l'application 1. Ajoutez un gestionnaire d'événements pour l'événement Button1_Click.

Dans le gestionnaire d'événements : a. Appelez la fonction Area. b. Transmettez la propriété Text de TextBox1 et TextBox2 en tant

qu'argument. c. Assignez la valeur de retour à la propriété Text de Label4. Votre code doit se présenter comme suit : Private Sub Button1_Click(...) Label4.Text = Area(TextBox1.Text, TextBox2.Text) End Sub

2. Exécutez l'application. 3. Tapez des valeurs numériques dans les zones de texte Hauteur et Largeur. 4. Cliquez sur Button1 et vérifiez que la réponse correcte apparaît. 5. Quittez l'application.

Les fichiers solution correspondant à cette application pratique sont situés dans dossier_installation\Practices\Mod04\ FunctionReturnValue\Solution.

Fichiers solution


Transmission de tableaux à des procédures

! Transmettez un tableau comme vous transmettez d'autresarguments :

! Déclarez un tableau de paramètres :

! Appelez une procédure comportant un tableau de paramètres :

Sub StudentScores(ByVal name As String, ByVal _ ParamArray scores( ) As String)

' Instructions de la procédure SubEnd Sub

Sub StudentScores(ByVal name As String, ByVal _ ParamArray scores( ) As String)

' Instructions de la procédure SubEnd Sub

Sub PassArray(ByVal testScores As Integer( ))...

End Sub

Dim scores( ) As Integer = {80, 92, 73}PassArray(scores)

Sub PassArray(ByVal testScores As Integer( ))...

End Sub

Dim scores( ) As Integer = {80, 92, 73}PassArray(scores)

StudentScores("Anne","10","26","32","15","22","16")StudentScores("Anne","10","26","32","15","22","16")


Vous pouvez transmettre des tableaux en tant qu'arguments à une procédure tout comme vous transmettez d'autres arguments. Visual Basic .NET inclut également le mot clé ParamArray pour déclarer un tableau de paramètres dans la définition des paramètres d'une procédure.

Pour transmettre des tableaux à une dimension ou à plusieurs dimensions à des procédures, vous pouvez procéder de la même manière que pour la transmission d'autres arguments.

L'exemple suivant indique comment transmettre un tableau à une dimension à une procédure :

Sub PassArray(ByVal testScores As Integer( )) ... End Sub Dim scores( ) As Integer = {80, 92, 73} PassArray(scores)

L'exemple suivant indique comment transmettre un tableau à deux dimensions à une procédure :

Sub Pass2DArray(ByVal rectangle As Integer(,)) ... End Sub Dim rectangle(,) As Integer = {{12, 1}, {0, 12}} Pass2DArray(rectangle)

Introduction

Transmission de tableaux


En général, vous ne pouvez pas appeler une procédure qui comporte un nombre d'arguments plus élevé que celui spécifié par la déclaration de la procédure. Lorsque vous devez utiliser un nombre d'arguments indéfini, vous pouvez déclarer un tableau de paramètres, lequel permet à une procédure d'accepter un tableau de valeurs pour un argument. Il n'est pas important que vous connaissiez le nombre d'éléments dans le tableau de paramètres lorsque vous définissez la procédure. La taille du tableau est déterminée individuellement par chaque appel de la procédure.

Le mot clé ParamArray vous permet de signaler un tableau de paramètres. Ce mot clé indique qu'un argument d'une procédure est un tableau facultatif d'éléments d'un type spécifié. Les règles suivantes s'appliquent :

! Une procédure peut comporter un seul tableau de paramètres, et il doit être le dernier argument dans la définition de la procédure.

! Le tableau de paramètres doit être transmis par valeur. Prenez l'habitude d'inclure le mot clé ByVal de manière explicite dans la définition de la procédure.

! Le code dans la procédure doit traiter le tableau de paramètres en tant que tableau à une dimension, chaque élément du tableau étant du même type de données que le type de données ParamArray.

! Le tableau de paramètres est facultatif. Sa valeur par défaut est un tableau vide à une dimension du type d'élément du tableau de paramètres.

! Tous les arguments qui précèdent le tableau de paramètres sont obligatoires. Le tableau de paramètres doit être le seul argument facultatif.

Lorsque vous appelez une procédure contenant un argument tableau de paramètres, vous pouvez transmettre l'un des éléments suivants pour le tableau de paramètres :

! Rien. C'est-à-dire que vous pouvez omettre l'argument ParamArray. Dans ce cas, un tableau vide est transmis à la procédure. Vous pouvez également transmettre le mot clé Nothing pour obtenir le même résultat.

! Une liste comportant un nombre indéfini d'arguments, séparés par des virgules. Le type de données de chaque argument doit pouvoir être implicitement converti au type d'élément ParamArray.

! Un tableau doté du même type d'élément que le tableau de paramètres.

Le code suivant indique comment définir une procédure comportant un tableau de paramètres :

Sub StudentScores(ByVal name As String, ByVal ParamArray _ scores( ) As String) ' Instructions de la procédure Sub End Sub

Les exemples suivants illustrent les appels possibles de StudentScores.

StudentScores("Anne", "10", "26", "32", "15", "22", "16") StudentScores("Mary", "Haut", "Bas", "Moyenne", "Haut") Dim JohnScores( ) As String = {"35", "Absent", "21", "30"} StudentScores("John", JohnScores)

Utilisation de ParamArray

Appel d'une procédure comportant un argument tableau de paramètres

Exemple d'une déclaration ParamArray

Exemples d'appels d'une procédure comportant un tableau de paramètres


Création d'une procédure Sub Main

! Sub Main : Point de départ de votre application

! Application.Run : Démarre l'application

! Application.Exit : Quitte l'application


Pour lancer et quitter une application, la bibliothèque de classes .NET Framework propose la classe Application. La classe Application fournit des méthodes (procédures) et des propriétés pour gérer une application, notamment des méthodes pour lancer et quitter une application, des méthodes pour traiter les messages Microsoft Windows® et des propriétés pour obtenir des informations concernant une application.

Lorsque vous créez des applications avec le modèle Application Windows dans Visual Basic .NET, Visual Basic crée automatiquement une procédure Sub masquée, appelée Sub Main, pour la classe Form. Cette procédure est utilisée comme point de départ de votre application.

Dans la procédure Sub Main, Visual Basic .NET appelle la méthode Application.Run pour démarrer l'application. Pour modifier ce comportement, vous pouvez créer votre propre procédure Sub Main et faire en sorte qu'elle soit l'objet de démarrage. Vous pouvez créer la procédure Sub Main dans un module ou dans une autre classe. Après avoir créé une procédure Sub Main, vous devez faire en sorte que cette nouvelle procédure devienne l'objet de démarrage en utilisant la fenêtre Propriétés.

! Pour remplacer l'objet de démarrage par Sub Main 1. Si l'Explorateur de solutions n'est pas ouvert, cliquez sur Explorateur de

solutions dans le menu Affichage. 2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du

projet, puis cliquez sur Propriétés. 3. Dans le volet gauche, sous Propriétés communes, vérifiez que Général est

sélectionné. 4. Dans la liste Objet de démarrage, cliquez sur Sub Main pour que cette

procédure devienne le nouvel objet de démarrage de votre projet.

Introduction

Procédure Sub Main

Création d'une nouvelle procédure Sub Main


Pour quitter une application, vous devez appeler la méthode Application.Exit à l'aide de la syntaxe suivante :

Application.Exit( )

Par exemple, vous pouvez placer ce code dans le gestionnaire d'événements Click pour un bouton. Lorsque l'utilisateur clique sur le bouton, l'application se ferme.

Les événements Form.Closed et Form.Closing ne sont pas déclenchés lorsque la méthode Application.Exit est appelée pour quitter votre application. Si ces événements contiennent du code qui doit être exécuté, appelez la méthode Form.Close pour chaque formulaire ouvert individuellement avant d'appeler la méthode Application.Exit.

Utilisation de Application.Exit

Remarque


Application pratique : Création d'une procédure Sub Main

Déclarez des variables au niveau dumodule

Créez une procédure Sub Main et définissez-la comme objet de démarrage

Écrivez le code pour quitter l'application

Écrivez le code correspondant au formulaire Selection

Testez l'application


Dans cette application pratique, vous devrez écrire du code pour une application constituée de trois formulaires, puis créer une procédure Sub Main comme objet de démarrage du projet.

! Ouverture du projet • Ouvrez le projet MultipleForms.sln, situé dans le dossier

dossier_installation\Practices\Mod04\Forms\Starter, et familiarisez-vous avec les formulaires et les modules du projet.

! Déclaration des variables • Déclarez les variables suivantes dans le fichier du module Starter.

Nom de la variable Modificateur d'accès Type de données

carLoanForm Friend CarLoan

homeLoanForm Friend HomeLoan

selectionForm Private Selection

Votre code doit se présenter comme suit : Friend carLoanForm As CarLoan Friend homeLoanForm As HomeLoan Private selectionForm As Selection


! Création d'une procédure Sub Main 1. Déclarez une procédure Sub Main publique dans le module Starter. Votre

code doit se présenter comme suit : Public Sub Main( ) End Sub

2. Écrivez le reste de la procédure Sub Main.

a. Créez une nouvelle instance du formulaire Selection et affectez-la à selectionForm.

b. Appelez la méthode SelectionForm.Show pour afficher le formulaire. c. Lancez l'application en appelant la méthode Application.Run. Votre code doit se présenter comme suit : Public Sub Main( ) selectionForm = New Selection( ) selectionForm.Show( ) Application.Run( ) End Sub

3. Définissez la procédure Sub Main comme objet de démarrage de

l'application.

! Écriture du code correspondant au formulaire Selection 1. Ouvrez l'Éditeur de code correspondant au formulaire Selection. 2. Ajoutez un gestionnaire d'événements Click pour le bouton Next. 3. Rédigez le code correspondant au gestionnaire d'événements.

a. Si CarLoanRadioButton est sélectionné, créez une nouvelle instance du formulaire CarLoan. Votre code doit se présenter comme suit : If CarLoanRadioButton.Checked Then carLoanForm = New CarLoan( )

Les instructions If�Then seront traitées ultérieurement dans le cours 2560A « Introduction à la programmation en Visual Basic.NET avec Microsoft .NET ».

b. Utilisez la méthode Show pour afficher le formulaire CarLoan. c. Utilisez la méthode Close pour fermer le formulaire Selection, comme

suit : carLoanForm.Show( ) Me.Close( )

d. Si HomeLoanRadioButton est sélectionné, créez une nouvelle instance

du formulaire HomeLoan. Votre code doit se présenter comme suit : ElseIf HomeLoanRadioButton.Checked Then homeLoanForm = New HomeLoan( )

e. Utilisez la méthode Show pour afficher le formulaire HomeLoan.

Remarque


f. Utilisez la méthode Close pour fermer le formulaire Selection, comme suit : homeLoanForm.Show( ) Me.Close( )

g. Si aucune option n'est sélectionnée, utilisez un message pour inviter

l'utilisateur à effectuer une sélection. Votre code doit se présenter comme suit : Else MessageBox.Show("Sélectionnez un type d'emprunt", _ "Type d'emprunt", MessageBoxButtons.OK, _ MessageBoxIcon.Error) End If

! Écriture du code pour quitter l'application 1. Créez un gestionnaire d'événements Click pour le bouton Sortir sur le

formulaire Selection. Appelez Application.Exit pour quitter l'application. 2. Créez un gestionnaire d'événements Click pour le bouton Terminé sur le

formulaire HomeLoan. Appelez Application.Exit pour quitter l'application. 3. Créez un gestionnaire d'événements Closing pour le formulaire HomeLoan.

Appelez Application.Exit pour quitter l'application. 4. Créez un gestionnaire d'événements Click pour le bouton Terminé sur le

formulaire CarLoan. Appelez Application.Exit pour quitter l'application. 5. Créez un gestionnaire d'événements Closing pour le formulaire CarLoan.

Appelez Application.Exit pour quitter l'application.

Il est important d'appeler Application.Exit à un moment ou un autre dans l'application qui autorise l'utilisateur à fermer l'application. Si le code de fermeture approprié n'est pas appelé, l'exécution de l'application se poursuit, bien que le formulaire fermé ne soit plus accessible. Dans une application plus complexe, le code de fermeture inclurait probablement du code supplémentaire, tel que du code pour enregistrer les modifications, pour fermer les connexions de données, pour confirmer que l'utilisateur veut quitter l'application, etc.

Remarque


! Test de l'application 1. Exécutez l'application. Cliquez sur Car Loan, puis cliquez sur le bouton

Suivant. Vérifiez que le formulaire Car Loan s'ouvre. 2. Quittez l'application en cliquant sur le bouton Fermer situé dans le coin

supérieur droit du formulaire. 3. Réexécutez l'application. Cliquez sur Home Loan, puis cliquez sur le

bouton Suivant. Vérifiez que le formulaire Home Loan s'ouvre. 4. Quittez l'application en cliquant sur le bouton Terminé. 5. Réexécutez l'application. Cliquez sur le bouton Suivant sans cliquer sur un

type d'emprunt. Vérifiez qu'un message invite l'utilisateur à choisir un type d'emprunt.

6. Quittez l'application en utilisant le bouton Sortir sur le formulaire Selection.

Les fichiers solution correspondant à cette application pratique sont situés dans le dossier dossier_installation\Practices\Mod04\Forms\Solution.

Fichiers solution


Leçon : Utilisation de fonctions prédéfinies

! Utilisation de la fonction InputBox

! Utilisation des fonctions de date et d'heure

! Utilisation des fonctions de chaîne

! Utilisation des fonctions de format

! Utilisation des fonctions financières


La bibliothèque runtime Visual Basic contient de nombreuses fonctions prédéfinies que vous pouvez utiliser dans votre code. La méthode d'appel de ces fonctions est identique à celle de vos propres fonctions.

Ce module présente la fonction InputBox ainsi que des exemples de fonctions de date et d'heure, de chaîne, de format et financières. Pour obtenir la liste complète des fonctions prédéfinies, reportez-vous à la section « Membres de la bibliothèque runtime Visual Basic » dans la documentation de Visual Studio .NET.


! Utilisation de la fonction InputBox ! Utilisation des fonctions de date et d'heure ! Utilisation des fonctions de chaîne ! Utilisation des fonctions de format ! Utilisation des fonctions financières ! Application pratique : Étude des fonctions prédéfinies

À la fin de cette leçon, vous serez en mesure d'utiliser des fonctions prédéfinies dans le code de votre application, notamment la fonction InputBox, des fonctions de date et d'heure, des fonctions de chaîne, des fonctions de format et des fonctions financières.

Introduction




Utilisation de la fonction InputBox

! Affiche une invite dans une boîte de dialogue, puis renvoiel'entrée utilisateur sous la forme d'une chaîne

Dim FileName As String

FileName = InputBox("Veuillez entrer un nom de fichier", "Recherche")

Dim FileName As String

FileName = InputBox("Veuillez entrer un nom de fichier", "Recherche")


La fonction InputBox est une fonction prédéfinie qui vous permet d'interagir avec les utilisateurs. La fonction InputBox affiche une invite dans une boîte de dialogue, attend que l'utilisateur entre du texte ou clique sur un bouton, puis renvoie une chaîne qui inclut le contenu de la zone de texte.

La déclaration de fonction suivante indique les paramètres de la fonction InputBox :

Public Function InputBox(ByVal Prompt As String, _ Optional ByVal Title As String = "", _ Optional ByVal DefaultResponse As String = "", _ Optional ByVal XPos As Integer = -1, _ Optional ByVal YPos As Integer = -1 ) As String

Vous pouvez noter que les arguments Title, DefaultResponse, XPos et YPos sont facultatifs. Le tableau suivant explique les valeurs par défaut qui s'appliquent si vous choisissez de ne pas transmettre l'un de ces arguments facultatifs à la fonction InputBox.

Paramètre Définition Valeur par défaut

Title Texte placé dans la barre de titre Nom de l'application

DefaultResponse Valeur affichée dans la zone de texte comme valeur par défaut si l'utilisateur ne saisit aucune donnée

La zone de texte affichée est vide

XPos Spécifie la distance entre le bord gauche de la boîte de dialogue et le bord gauche de l'écran

La boîte de dialogue est centrée horizontalement

YPos Spécifie la distance entre le bord supérieur de la boîte de dialogue et le bord supérieur de l'écran

La boîte de dialogue est positionnée verticalement à un emplacement correspondant à la fin du premier tiers de l'écran

Introduction

Paramètres


Le code suivant crée une zone de saisie appelée Search (Recherche) qui invite l'utilisateur à entrer un nom de fichier et qui stocke la réponse de l'utilisateur sous la forme d'une variable appelée FileName.

Dim FileName As String FileName = InputBox("Veuillez entrer un nom de fichier", "Recherche")

La capture d'écran suivante présente la zone de saisie créée par le code ci-dessus.

Pour plus d'informations sur la fonction InputBox, reportez-vous à la section « InputBox, fonction » dans la documentation de Visual Studio .NET.

Exemple d'utilisation de la fonction InputBox

Résultat

Remarque


Utilisation des fonctions de date et d'heure

! Effectuent des calculs impliquant des dates et des heures

! Exemples :

" DateAdd : Ajoute ou retranche une durée donnée àune date

" DateDiff : Détermine le nombre de durées spécifiéesqui existent entre deux valeurs date/heure

DateAdd(DateInterval.Day, 10, billDate)DateAdd(DateInterval.Day, 10, billDate)

DateDiff(DateInterval.Day, Now, secondDate)DateDiff(DateInterval.Day, Now, secondDate)


Visual Basic propose de nombreuses fonctions de date et d'heure que vous pouvez utiliser dans vos applications. Dans cette section, vous apprendrez à utiliser deux fonctions prédéfinies pour effectuer des calculs impliquant des dates et des heures.

Vous pouvez utiliser la fonction DateAdd pour ajouter ou retrancher une durée donnée à une date. Vous transmettez à la fonction la date et les informations concernant la durée, et la fonction DateAdd renvoie une valeur Date contenant la valeur date/heure, à laquelle une durée spécifiée a été ajoutée ou retranché.

La fonction DateAdd contient trois paramètres, qui sont tous obligatoires, comme l'indique le tableau suivant.

Paramètre Définition

Interval Expression de chaîne ou valeur d'énumération DateInterval représentant la durée que vous voulez ajouter.

Pour plus d'informations sur les paramètres de l'argument Interval, reportez-vous à la section « DateAdd, Fonction » dans la documentation de Visual Studio .NET.

Number Expression en virgule flottante représentant les durées que vous voulez ajouter. Number peut être positif (pour obtenir des valeurs date/heure dans le futur) ou négatif (pour obtenir des valeurs date/heure dans le passé).

DateValue Expression représentant la date et l'heure auxquelles la durée doit être ajoutée.

Le code suivant utilise la fonction DateAdd pour calculer la date d'échéance d'une facture, d'après la date de facturation. Dans ce scénario, la facture est échue 20 jours après la date de facturation. Par conséquent, Interval est DateInterval.Day, et Number est 20.

billDate = #12/31/2000# DateAdd(DateInterval.Day, 20, billDate)

Introduction

Utilisation de la fonction DateAdd

Paramètres

Exemple d'utilisation de la fonction DateAdd


Vous pouvez utiliser la fonction DateDiff pour déterminer le nombre de durées spécifiées qui existent entre deux valeurs date/heure. Par exemple, vous pouvez utiliser DateDiff pour calculer le nombre de jours entre deux dates ou le nombre de semaines entre la date du jour et la fin de l'année.

La fonction DateDiff comporte cinq paramètres, et deux d'entre eux sont facultatifs. Ces paramètres sont répertoriés le tableau suivant.


Interval Expression de chaîne ou valeur d'énumération DateInterval représentant la durée que vous voulez utiliser comme unité de différence entre Date1 et Date2.

Pour plus d'informations sur les paramètres de l'argument Interval, reportez-vous à la section «DateDiff, Fonction » dans la documentation de Visual Studio .NET.

Date1, Date2 Il s'agit des deux valeurs date/heure que vous voulez utiliser dans le calcul. La valeur de Date1 est retranchée de la valeur de Date2 pour produire la différence. Aucune des deux valeurs n'est modifiée dans le programme appelant.

DayOfWeek (Facultatif)

Valeur choisie dans l'énumération FirstDayOfWeek, qui spécifie le premier jour de la semaine.

FirstDayOfWeek.Sunday est la valeur par défaut.

WeekOfYear (Facultatif)

Valeur choisie dans l'énumération FirstWeekOfYear, qui spécifie la première semaine de l'année.

FirstWeekOfYear.Jan1 est la valeur par défaut.

Cet exemple utilise la fonction DateDiff pour indiquer le nombre de jours écoulés entre une date donnée et la date du jour.

Dim firstDate, msg As String Dim secondDate As Date ' Déclaration des variables firstDate = InputBox("Entrez une date") ' Obtention d'une date donnée de la part de l'utilisateur secondDate = CDate(firstDate) msg = "Jours à compter d'aujourd'hui : " & _ DateDiff(DateInterval.Day, Now, secondDate) MessageBox.Show(msg) ' Création d'un message qui utilise la fonction ' DateDiff et affiche le nombre de jours entre une date ' donnée et la date du jour

Pour plus d'informations sur les autres fonctions de date et d'heure, reportez-vous à la section Microsoft.VisualBasic.DateandTime section de « Membres de la bibliothèque runtime Visual Basic » dans la documentation de Visual Studio .NET.

Utilisation de la fonction DateDiff

Paramètres

Exemple d'utilisation de la fonction DateDiff

Remarque


Utilisation des fonctions de chaîne

! Extraient uniquement une partie d'une chaîne ! Renvoient des informations concernant une chaîne! Affichent des informations dans un format donné! Exemples :

" Trim

" Len

" LeftLength = Len(customerName)Length = Len(customerName)

Microsoft.VisualBasic.Left(customerName, 5)Microsoft.VisualBasic.Left(customerName, 5)

NewString = Trim(MyString)NewString = Trim(MyString)


Très souvent, les chaînes doivent être manipulées, mises en forme ou évaluées. Par exemple, lorsque le nom d'une personne est saisi, le nom doit apparaître avant le prénom. Ou encore, un fichier peut contenir des champs qui sont séparés par des virgules. Les fonctions de chaîne de Visual Basic peuvent analyser et manipuler des chaînes dans des applications. Ces fonctions permettent de renvoyer des informations concernant une chaîne, d'extraire uniquement une partie d'une chaîne, ou d'afficher des informations dans un format donné.

Vous pouvez utiliser la fonction Trim pour éliminer les espaces de début et de fin dans une chaîne.

L'exemple suivant explique comment la fonction Trim peut renvoyer une chaîne contenant une copie d'une chaîne spécifiée, sans aucun espace de début ni de fin :

Dim MyString, NewString As String ' Initialisation de la chaîne MyString = " 1234 Street " ' NewString = "1234 Street" NewString = Trim(MyString)

Vous pouvez utiliser la fonction Len pour rechercher le nombre de caractères dans une chaîne ou le nombre d'octets requis pour stocker une variable.

Le code suivant présente la déclaration de fonction pour la fonction Len : le paramètre Expression dans cette déclaration peut être tout nom de variable ou toute expression de chaîne valide.

Public Shared Function Len(ByVal Expression As datatype) As _ Integer

Introduction

Utilisation de la fonction Trim

Exemple d'utilisation de Trim

Utilisation de la fonction Len


Dans le code suivant, la fonction Len renvoie le nombre de caractères contenu dans une chaîne :

Dim customerName As string Dim length As Integer customerName = InputBox("Comment vous appelez-vous ?") length = Len(customerName)

Vous pouvez utiliser la fonction Left pour renvoyer un nombre spécifié de caractères à partir de la gauche d'une chaîne.

Le code suivant présente la déclaration de fonction pour la fonction Left : le paramètre Str dans cette déclaration est l'expression de chaîne à partir de laquelle les caractères les plus à gauche seront renvoyés par la fonction. Le paramètre Length est un entier indiquant le nombre de caractères à renvoyer.

Public Shared Function Left(ByVal Str As String, _ ByVal Length As Integer) As String

! Si la valeur de Length est 0, une chaîne de longueur zéro (" ") est renvoyée. ! Si la valeur de Length est supérieure ou égale au nombre de caractères de

Str, l'intégralité de la chaîne est renvoyée. ! Si vous utilisez cette fonction dans un formulaire Windows ou dans une

classe dotée d'une propriété Left, vous devez appeler la fonction en utilisant son nom qualifié complet : Microsoft.VisualBasic.Left.

Dans le code suivant, la fonction Left renvoie cinq caractères à partir de la gauche d'une chaîne :

Microsoft.VisualBasic.Left(customerName, 5)

Le code suivant utilise les fonctions Len et Left pour supprimer une extension (les quatre derniers caractères) d'un nom de fichier :

fileName = Left(fileName, Len(fileName) - 4)

Pour plus d'informations sur les autres fonctions de chaîne, reportez-vous à la section Microsoft.VisualBasic.Strings de « Membres de la bibliothèque runtime Visual Basic » dans la documentation de Visual Studio .NET.

Exemple d'utilisation de Len

Utilisation de la fonction Left

Exemple d'utilisation de Left

Exemple d'utilisation de Len et de Left

Remarque


Utilisation des fonctions de format

! Mettent en forme les nombres, les dates et les heures selonles standards reconnus

! Affichent les différents formats sans qu'il soit nécessaire de modifier le code pour chaque nationalité ou pays

! Exemples :

" FormatCurrency

" FormatDateTime

FormatCurrency(amountOwed, , , TriState.True,TriState.True)FormatCurrency(amountOwed, , , TriState.True,TriState.True)

FormatDateTime(myDate, DateFormat.LongDate)FormatDateTime(myDate, DateFormat.LongDate)


Il existe plusieurs formats numériques, de date et d'heure qui sont universellement reconnus. Visual Basic offre de nombreuses possibilités pour l'affichage des formats numériques, outre les formats de date et d'heure. Il existe par ailleurs un autre avantage : les différents formats numériques, de date et d'heure s'affichent facilement, sans qu'il ne soit nécessaire de modifier le code pour chaque nationalité ou pays.

Dans cette section, vous apprendrez à utiliser deux fonctions de format prédéfinies.

Vous pouvez utiliser la fonction FormatCurrency pour renvoyer une expression formatée en tant que valeur de devise qui utilise le symbole de la devise défini dans le Panneau de configuration de l'ordinateur. Par exemple, vous pouvez utiliser FormatCurrency pour formater le montant stipulé sur une facture.

La fonction FormatCurrency comporte cinq paramètres, et quatre d'entre eux sont facultatifs. Si un ou plusieurs paramètres facultatifs sont omis, les valeurs de correspondance des paramètres régionaux de l'ordinateur sont utilisées par défaut. Les paramètres de la fonction FormatCurrency sont répertoriés le tableau suivant.


Expression Expression qui doit être formatée.

NumDigitsAfterDecimal

(Facultatif)

Valeur numérique précisant le nombre de chiffres à afficher après la virgule.

La valeur par défaut est -1, ce qui indique que les paramètres régionaux de l'ordinateur sont utilisés.

Introduction

Utilisation de la fonction FormatCurrency

Paramètres


(suite) Paramètre Définition

IncludeLeadingDigit

(Facultatif)

Indique si un zéro s'affiche au début pour les valeurs des fractions.

Les paramètres utilisent Tristate pour que le paramètre corresponde à True, False, ou UseDefault. Par exemple : TriState.True, TriState.False ou TriState.UseDefault.

UseParensForNegativeNumbers

(Facultatif)

Indique si une valeur négative doit être placée entre parenthèses.


GroupDigits

(Facultatif)

Indique si les chiffres sont regroupés à l'aide du délimiteur de groupe spécifié dans les paramètres régionaux de l'ordinateur, par exemple, en utilisant une virgule pour former des groupes de trois chiffres à gauche d'une virgule.


L'exemple suivant utilise la fonction FormatCurrency pour formater une chaîne représentant amountOwed :

Dim amountOwed As Double = 4456.43 Dim myString As String myString = FormatCurrency(amountOwed, , , TriState.True, _ TriState.True) ' Renvoie "4 456,43" lorsque les paramètres régionaux sont ' définis à Français (France)

Vous pouvez utiliser la fonction FormatDateTime pour qu'une expression adopte un format de date ou d'heure. Par exemple, vous pouvez utiliser FormatDateTime pour remplacer l'expression 05/21/01 par l'expression Lundi, 21 mai, 2001.

La fonction FormatDateTime comporte deux paramètres, comme l'indique le tableau suivant.


Expression Expression qui doit être formatée.

NamedFormat

(Facultatif)

Indique le format à utiliser. Si ce paramètre n'est pas précisé, GeneralDate est utilisé.

Exemple d'utilisation de la fonction FormatCurrency

Utilisation de la fonction FormatDateTime

Paramètres


Le tableau suivant décrit les valeurs susceptibles d'être affectées au paramètre NamedFormat.

Constante Description

DateFormat.GeneralDate Affiche une date et/ou une heure. Si une date est présente, elle s'affiche au format court. Si une heure est présente, elle s'affiche au format long. Si les deux sont présentes, les deux s'affichent.

DateFormat.LongDate Affiche une date au format long spécifié dans les paramètres régionaux de l'ordinateur.

DateFormat.ShortDate Affiche une date au format court spécifié dans les paramètres régionaux de l'ordinateur.

DateFormat.LongTime Affiche une heure au format spécifié dans les paramètres régionaux de l'ordinateur.

DateFormat.ShortTime Affiche une heure au format 24 heures (hh:mm).

L'exemple suivant utilise la fonction FormatDateTime pour formater l'expression 5/21/01 :

Dim myDate As DateTime = #5/21/01# Dim myString As String myString = FormatDateTime(myDate, DateFormat.LongDate) ' Renvoie "lundi 21 mai 2001" lorsque les paramètres ' régionaux sont définis à Français (France)

Pour plus d'informations sur les autres fonctions de format, reportez-vous à la section Membres de la bibliothèque runtime Visual Basic dans la documentation de Visual Studio .NET.

Exemple d'utilisation de la fonction FormatDateTime

Remarque


Utilisation des fonctions financières

! Effectuent des calculs et réalisent des opérations liésaux finances, tels que les taux d�intérêt

! Exemples :

" Pmt

" Rate

payment = Pmt(0.0083, 24, -5000, 0, DueDate.BegOfPeriod)payment = Pmt(0.0083, 24, -5000, 0, DueDate.BegOfPeriod)

ratePerPeriod = Rate(24, 228, -5000, 0, DueDate.BegOfPeriod, _ 0.8)*100



Visual Basic propose plusieurs fonctions financières que vous pouvez utiliser dans vos applications. Dans cette section, vous apprendrez à utiliser deux fonctions prédéfinies pour effectuer des calculs et réaliser des opérations impliquant des montants.

Vous pouvez utiliser la fonction Pmt pour calculer le règlement d'une annuité reposant sur des versements périodiques fixes et un taux d'intérêt fixe. Une annuité représente une série de règlements fixes, effectués sur une certaine durée ; par exemple, une hypothèque sur une maison ou un prêt pour l'achat d'un véhicule.

La fonction Pmt comporte cinq paramètres, et deux d'entre eux sont facultatifs. Pour tous les arguments, les sommes déboursées (telles que les provisions d'épargne) sont représentées par des nombres négatifs. Les sommes reçues (telles que les chèques de dividendes) sont représentées par des nombres positifs. Les cinq paramètres de la fonction Pmt sont répertoriés dans le tableau suivant.


Rate Taux d'intérêt par période, exprimé en tant que valeur de type Double.

Par exemple, si vous obtenez un prêt pour l'achat d'un véhicule à un taux annuel de 10 % et vous effectuez des remboursements mensuels, le taux par période est 0,1/12, soit 0,0083.

NPer Nombre total de périodes de remboursement durant l'annuité, exprimé en tant que valeur de type Double.

Par exemple, si vous effectuez des remboursements mensuels d'un prêt pour l'achat d'un véhicule s'étendant sur deux ans, votre prêt comprend un total de 24 (2 x 12) périodes de remboursement.

Le calcul de NPer doit utiliser des périodes de remboursement exprimées dans les mêmes unités que les périodes de Rate. Par exemple, si Rate est par mois, NPer doit être par mois.

Introduction

Utilisation de la fonction Pmt

Paramètres


(suite) Paramètre Définition

PV Valeur actuelle d'une série de règlements à effectuer dans le futur, exprimée en tant que type Double.

Par exemple, lorsque vous achetez une voiture, le montant du prêt est la valeur actuelle des remboursements mensuels que vous effectuerez.

FV

(Facultatif)

Valeur future, ou solde de trésorerie, dont vous souhaitez disposer après avoir effectué le dernier remboursement, exprimée en tant que type Double.

Si vous ne spécifiez aucune valeur, la valeur par défaut est 0.

Due

(Facultatif)

Date à laquelle les remboursements sont échus. Il s'agit soit de la fin de la période (spécifiée sous la forme DueDate.EndOfPeriod), soit du début de la période (spécifié sous la forme DueDate.BegOfPeriod).

Si vous ne spécifiez aucune valeur, la valeur par défaut est DueDate.EndOfPeriod.

Le code suivant utilise la fonction Pmt pour calculer le remboursement mensuel d'un prêt de 5 0000 dollars pour l'achat d'un véhicule, étalé sur 24 mois, et avec taux annuel de 10 %.

payment = Pmt(0.0083, 24, -5000, 0, DueDate.BegOfPeriod)

Vous pouvez utiliser la fonction Rate pour calculer le taux d'intérêt, par période, d'une annuité.

Les paramètres de la fonction Rate sont identiques à ceux de la fonction Pmt, à quelques exceptions près :

! La fonction utilise un argument Pmt, et non un argument Rate. Pmt est un argument obligatoire qui représente le remboursement à effectuer pour chaque période. Il est exprimé en tant que type Double.

! Elle utilise un argument facultatif Guess. Il s'agit de la valeur qui sera renvoyée par Rate. Elle est exprimée en tant que type Double. Si vous ne spécifiez aucune valeur, la valeur par défaut est 0,1 (10 %).

Le code suivant utilise la fonction Rate pour calculer le taux d'intérêt par période dans le cas d'un prêt de 5 000 dollars étalé sur 24 mois, et avec des remboursements mensuels de 228 dollars.


Remarque Pour plus d'informations sur les autres fonctions financières, reportez-vous à la section Microsoft.VisualBasic.Financial de « Membres de la bibliothèque runtime Visual Basic » dans la documentation de Visual Studio .NET.

Exemple d'utilisation de la fonction Pmt

Utilisation de la fonction Rate

Paramètres

Exemple d'utilisation de la fonction Rate


Application pratique : Étude des fonctions prédéfinies

Ouvrez le document « Membres de la bibliothèque runtime Visual Basic »

Répondez aux questions sur les fonctionsspécifiques, telles que InStr, Mid et Right

Étudiez les fonctions, les méthodes et les propriétés que vous pouvez utiliser dansvotre code


Dans cette application pratique, vous utiliserez la documentation de Visual Studio pour étudier les fonctions prédéfinies et apprendre à les utiliser dans votre code.

! Ouverture de la référence du langage Visual Basic 1. Cliquez sur Démarrer, pointez sur Tous les programmes, sur Microsoft

Visual Studio .NET, puis cliquez sur Documentation Microsoft Visual Studio .NET.

2. Dans le menu ?, cliquez sur Rechercher. 3. Dans la fenêtre de recherche, dans la zone Rechercher, tapez membres de

la bibliothèque runtime. Vérifiez que la recherche est filtrée d'après Visual Basic et associé, sélectionnez Rechercher dans les titres seulement, puis cliquez sur Rechercher.

4. Dans la fenêtre des résultats de la recherche, double-cliquez sur Membres de la bibliothèque runtime Visual Basic.

5. Ne cliquez sur aucun lien dans la page et examinez le contenu de cette bibliothèque. Notez que cette page décrit les fonctions, les méthodes et les propriétés que vous pouvez utiliser dans votre code.


! Utilisation du contenu de la bibliothèque Utilisez le document « Membres de la bibliothèque runtime Visual Basic » et les documents liés pour répondre aux questions posées dans la liste suivante. Pour revenir au document « Membres de la bibliothèque runtime Visual Basic » à partir d'autres documents, utilisez le bouton Précédent de la barre d'outils. 1. Comment est organisé le contenu du document « Membres de la

bibliothèque runtime Visual Basic » ? Le contenu est regroupé en fonction des catégories de fonctionnalités. ____________________________________________________________

____________________________________________________________

2. À quelle fin la fonction InStr est-elle destinée ? La fonction InStr renvoie un entier qui spécifie la position initiale de la première occurrence d'une chaîne incluse dans une autre chaîne. ____________________________________________________________

____________________________________________________________

3. Quelle sera la valeur renvoyée par la fonction InStr si cette dernière ne peut pas trouver la seconde chaîne ? La fonction renverra 0. ____________________________________________________________

____________________________________________________________

4. Quels sont les paramètres de la fonction Mid ? Précisez si les paramètres sont obligatoires ou facultatifs. La fonction Mid utilise deux paramètres obligatoires (Str et Start) et un paramètre facultatif (Length). ____________________________________________________________

____________________________________________________________

5. D'après la réponse que vous avez apportée à la question précédente, quelle valeur le code suivant doit-il affecter aux variables myAnswer et secondAnswer ? Dim myString, myAnswer, secondAnswer As String myString = "Utilisation de la fonction Mid" myAnswer = Mid(myString, 7, 3) secondAnswer = Mid(myString, 7)

La valeur renvoyée pour myAnswer est « Mid ». La valeur renvoyée pour secondAnswer est « Mid Function ». ____________________________________________________________

____________________________________________________________


6. Dans la ligne figurant sous le code suivant, ajoutez du code qui utilise la fonction Right pour renvoyer la chaîne « Doe » à partir de la chaîne « John Doe ». Dim myString As String = "John Doe" Dim subString As String

subString = Microsoft.VisualBasic.Right(myString, 3)

____________________________________________________________

____________________________________________________________

7. Est-ce que Now est une fonction prédéfinie ? Non. Now est une propriété publique de la structure DateTime dans l'espace de noms System. ____________________________________________________________

____________________________________________________________

8. Répertoriez quatre rubriques fournies par la Référence du langage Visual Basic en tant que liens associés à la rubrique de référence qui décrit Now. La section Voir aussi, qui figure au bas de la rubrique Propriété Now, comporte 13 rubriques. Ces rubriques incluent Fonction Day, Fonction Hour, Fonction Month et Propriété Today. ____________________________________________________________

____________________________________________________________



! Création de procédures

! Utilisation de procédures

! Utilisation de fonctionsprédéfinies

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


1. Expliquez les valeurs par défaut dans Visual Basic .NET pour les éléments suivants : a. Accessibilité pour une procédure écrite dans un module b. Méthode de transmission pour la transmission d'arguments à des

procédures c. Accessibilité pour un module a. Public. Cela signifie qu'il n'existe aucune restriction d'accès. b. ByVal. Cela signifie qu'une copie des données est transmise à la

procédure appelée. La procédure appelée ne peut pas modifier la valeur initiale des données.

c. Friend. Cela signifie que le module est accessible à partir du programme qui contient la déclaration du module.


2. Étant donné le code suivant, quelle valeur doit apparaître dans le message dans la procédure Sub Test ? Pourquoi ? Sub Count(ByRef number As Integer) number = number + 1 End Sub Sub Test( ) Dim myNumber As Integer = 10 Count(myNumber) MessageBox.Show(myNumber) End Sub

Le message doit afficher 11, car la variable est transmise à la procédure Sub Count par référence, ce qui permet à Sub Count de modifier la valeur initiale de la variable.

3. Quelle instruction parmi les suivantes appelle la fonction CheckPassword et transmet le contenu de la zone de texte Password ? d. myAnswer = CheckPassword.Text(Password)

e. Password.Text(CheckPassword) f. CheckPassword( ) = Password.Text g. myAnswer = CheckPassword(Password.Text) d. myAnswer = CheckPassword(Password.Text)

4. Décrivez l'une des fonctions prédéfinies de date et d'heure incluses dans Visual Basic .NET et donnez un exemple de son utilisation. La fonction DateAdd ajoute ou retranche une durée spécifique à une date. Exemple : Vous pouvez utiliser DateAdd pour calculer la date d'échéance d'une facture si vous connaissiez la date de la facture et le nombre de jours entre la date de la facture et la date à laquelle la facture arrive à échéance. La fonction DateDiff détermine le nombre de durées spécifiées qui existent entre deux valeurs date/heure. Exemple : Vous pouvez utiliser DateDiff pour calculer le nombre de jours qui sépare la date du jour et la fin de l'année.


Atelier 4.1 : Création et utilisation de procédures

! Exercice 1 : Création de fonctions dans un module

! Exercice 2 : Utilisation du formulaireprincipal



! créer des procédures Function dans un module ; ! transmettre des paramètres à une procédure ; ! appeler des procédures qui sont dans un module.

Cet atelier traite des concepts étudiés dans ce module. Par conséquent, il est possible qu'il ne soit pas conforme aux recommandations de Microsoft en termes de sécurité.

Avant de poursuivre, vous devez disposer des connaissances suivantes :

! Maîtriser l'utilisation des variables et des constantes dans Visual Basic .NET.

! Maîtriser les méthodes de création et d'appel de procédures dans Visual Basic .NET.

! Maîtriser l'utilisation des contrôles et des formulaires dans Visual Basic .NET.

Objectifs

Remarque



Dans les ateliers correspondant aux modules 2, 4, 5, 6 et 12 du cours 2560A, Introduction à la programmation en Visual Basic .NET avec Microsoft .NET, vous créerez une application pour l'estimation du remboursement d'un prêt. Vous créerez l'application complète en plusieurs étapes, chaque étape se poursuivant avec le code créé dans l'atelier précédent. Au début de chaque atelier, vous pourrez continuer avec vos propres fichiers ou commencer avec les fichiers fournis.

Dans l'atelier 4.1, « Création et utilisation de procédures », vous créerez des procédures destinées au calcul d'un prêt.

Dans ces ateliers, la méthode Form.Close est utilisée afin de fermer l'application pour l'estimation du remboursement du prêt. Dans une application comportant un seul formulaire, Form.Close ferme l'application et il n'est pas nécessaire d'appeler Application.Exit. En revanche, dans une application comportant plusieurs formulaires, vous devez appeler Application.Exit pour quitter l'application. Qui plus est, dans la mesure où les événements Form.Closed et Form.Closing ne sont pas déclenchés lorsque la méthode Application.Exit est appelée, vous devez appeler Form.Close pour chaque formulaire avant d'appeler Application.Exit si les événements Closed et Closing comportent du code qui doit être exécuté.

Les fichiers solution correspondant à cet atelier sont situés dans les dossiers dossier_installation\Labfiles\Lab041\Ex01\Solution et dossier_installation\Labfiles\Lab041\Ex02\Solution.

Scénario

Important

Fichiers solution



Exercice 1 Création de fonctions dans un module

Dans cet exercice, vous devrez créer des fonctions dans un module d�utilitaires . Ces fonctions calculeront le remboursement mensuel et le montant total payés pendant la durée du prêt.

! Ouverture du projet d'application pour un prêt • Ouvrez le projet correspondant à l'application de prêt de l'atelier 2.1

(Création de l'interface utilisateur) du module 2 intitulé « Utilisation de formulaires et de contrôles » dans le cours 2560A, Introduction à la programmation en Visual Basic .NET avec Microsoft .NET. Si vous n'avez pas réalisé l'atelier 2.1, utilisez le projet LoanApplication.sln figurant dans le dossier dossier_installation\Labs\Lab041\Ex01\Starter.

! Ajout d'un nouveau module au projet 1. Dans le menu Projet, cliquez sur Ajouter un nouvel élément. 2. Dans la boîte de dialogue Ajouter un nouvel élément, cliquez sur Module

dans le volet Modèles. 3. Remplacez le nom du module par Utility.vb, puis cliquez sur Ouvrir. 4. Déclarez une constante au niveau du module pour représenter le nombre de

mois dans une année. Votre code doit se présenter comme suit : Private Const conversionPeriod As Integer = 12

! Calcul du remboursement mensuel 1. Ajoutez la fonction publique suivante à la définition du module.

Nom de la fonction Paramètres Valeur retournée

MonthlyPayment loanAmount As Double, rate As Double, loanLength As Integer

Double

2. Écrivez le reste de la fonction : a. Déclarez une variable Double appelée interestRate qui inclut le taux

d'intérêt. b. Déclarez une variable Double appelée monthRate qui inclut le taux

d'intérêt mensuel. c. Déclarez une variable Integer appelée numberOfPayments qui inclut le

nombre de remboursements. d. Calculez le taux d'intérêt à l'aide de la ligne de code suivante :

interestRate = rate / 100

e. Calculez le taux d'intérêt mensuel et enregistrez cette valeur sous monthRate, comme l'indique le code suivant : monthRate = interestRate / conversionPeriod


f. Calculez le nombre de remboursements qui seront effectués et enregistrez cette valeur sous numberOfPayments, comme l'indique le code suivant : numberOfPayments = loanLength * conversionPeriod

g. Utilisez la fonction Visual Basic Pmt pour calculer le montant du

remboursement mensuel et spécifiez ce montant comme valeur de retour de la fonction, comme l'indique le code suivant : MonthlyPayment = Pmt(monthRate, numberOfPayments, _ -loanAmount)

! Calcul du remboursement total 1. Ajoutez la fonction publique suivante à la définition du module.

Nom de la fonction Paramètres Valeur retournée

TotalPaid loanAmount As Double, rate As Double, loanLength As Integer

Double

2. Écrivez le reste de la fonction : a. Déclarez une variable Integer, appelée numberOfPayments, qui inclut le

nombre de remboursements. b. Calculez le nombre de remboursements qui seront effectués et

enregistrez cette valeur sous numberOfPayments, comme l'indique le code suivant : numberOfPayments = loanLength * conversionPeriod

c. Appelez la fonction MonthlyPayment pour calculer le remboursement

mensuel. Multipliez la valeur renvoyée de la fonction MonthlyPayment par le nombre total de remboursements. Spécifiez cette valeur comme valeur de retour de la fonction TotalPaid. Votre code doit se présenter comme suit : TotalPaid = MonthlyPayment(loanAmount, rate, _ loanLength) * numberOfPayments

! Création du projet • Construisez le projet et corrigez toute erreur éventuelle.


Exercice 2 Utilisation du formulaire principal

Dans cet exercice, vous ajouterez deux boutons dans le formulaire principal. Ces boutons exécuteront le code qui calcule le remboursement mensuel et le remboursement total du montant du prêt.

L'illustration suivante indique l'emplacement des nouveaux boutons que vous ajouterez au formulaire dans la première procédure.

! Ajout de contrôles dans le formulaire principal 1. Ouvrez le fichier Main.vb en mode Design. Si vous n'avez pas réalisé

l'exercice 1, utilisez le projet figurant dans le dossier dossier_installation\ Labfiles\Lab041\Ex02\Starter.

2. Ajoutez deux contrôles Button dans le formulaire. 3. Définissez les propriétés des contrôles en vous reportant aux valeurs du

tableau suivant.

Nom actuel Propriété Nouvelle valeur

Button1 Name MonthlyPaymentButton

Text Mensualité

Button2 Name TotalPaidButton

Text Total remboursé


! Stockage de la durée du prêt 1. Dans la classe MainForm, déclarez une variable Integer privée, au niveau

de la classe, appelée loanTerm. Initialisez-la à 5. Votre code doit se présenter comme suit : Public Class MainForm Inherits System.Windows.Forms.Form Private loanTerm As Integer = 5 End Class

2. Pour chacune des trois cases d'option, ajoutez un gestionnaire d'événements

CheckedChanged. 3. Dans chaque gestionnaire d'événements, faites correspondre la valeur de

loanTerm à la valeur appropriée associée à la case d'option. Votre code doit se présenter comme suit : Private Sub Length5RadioButton_CheckedChanged(...) loanTerm = 5 End Sub Private Sub Length15RadioButton_CheckedChanged(...) loanTerm = 15 End Sub Private Sub Length30RadioButton_CheckedChanged(...) loanTerm = 30 End Sub

! Ajout d'un gestionnaire d'événements pour MonthlyPaymentButton • Dans le gestionnaire d'événements MonthlyPaymentButton_Click,

effectuez les opérations suivantes : a. Appelez la fonction MonthlyPayment créée dans l'exercice 1. b. Utilisez la fonction de conversion de type de données CDbl pour

convertir les types de données du taux du prêt et du montant du prêt avant de transmettre ces valeurs à la fonction.

c. Utilisez un message pour afficher le remboursement renvoyé à partir de la fonction.

Votre code doit se présenter comme suit : MessageBox.Show(MonthlyPayment(CDbl(LoanTextBox.Text), _ CDbl(RateComboBox.Text), (loanTerm)


! Ajout d'un gestionnaire d'événements pour TotalPaidButton • Dans le gestionnaire d'événements TotalPaidButton_Click, effectuez les

opérations suivantes : a. Appelez la fonction TotalPaid créée dans l'exercice 1. b. Utilisez la fonction de conversion de type de données CDbl pour

convertir les types de données du taux du prêt et du montant du prêt avant de transmettre ces valeurs à la fonction.

c. Utilisez un message pour afficher le remboursement renvoyé à partir de la fonction.

Votre code doit se présenter comme suit : MessageBox.Show(TotalPaid(CDbl(LoanTextBox.Text), _ CDbl(RateComboBox.Text), (loanTerm)

! Test de l'application • Construisez, exécutez et testez l'application en entrant le montant des prêts

puis en choisissant les taux d'intérêt et la durée des prêts. Notez que les valeurs de devise ne sont pas formatées.

! Mise en forme des valeurs de devise 1. Dans les instructions du message qui appelle la fonction MonthlyPayment

et la fonction TotalPaid, utilisez la fonction FormatCurrency pour formater le montant mensuel du prêt et le total réglé avant d'afficher ces valeurs. Votre code doit se présenter comme suit : MessageBox.Show(FormatCurrency(MonthlyPayment(CDbl _ (LoanTextBox.Text), CDbl(RateComboBox.Text), _ loanTerm))) MessageBox.Show(FormatCurrency(TotalPaid(CDbl _ (LoanTextBox.Text), CDbl(RateComboBox.Text), _ loanTerm)))

2. Testez de nouveau l'application et vérifiez que les valeurs de devise sont

formatées correctement.

Table des matières

Vue d'ensemble 1

Leçon : Utilisation d'expressions conditionnelles 2

Leçon : Utilisation de structures de décision 14

Atelier 5.1 : Utilisation de structures de décision 21

Leçon : Utilisation de structures de boucles conditionnelles 26


Module 5 : Structures de décision et boucles

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaines, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs et toute ressemblance avec des sociétés, produits, noms de domaines, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l�objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d�autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d'un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Module 5 : Structures de décision et boucles iii

Notes de l'instructeur Ce module explique comment implémenter les structures de décision et les structures en boucle pour contrôler les sorties et l'exécution du programme.


! créer des formules et des expressions conditionnelles à l'aide d'opérateurs arithmétiques, logiques et de comparaison ;

! utiliser des instructions If�Then pour évaluer si une condition est vraie ou fausse et canaliser le flux du programme en conséquence ;

! utiliser des instructions Select Case pour tester les différentes valeurs d'une même expression et exécuter les instructions correspondantes ;

! utiliser des instructions Do�Loop pour exécuter des instructions jusqu'à ce qu'une condition spécifique soit remplie ou pendant qu'elle est remplie ;

! utiliser des instructions For�Next pour exécuter des instructions un nombre de fois déterminé ;

! choisir la structure de décision ou la boucle appropriées en fonction des conditions requises par l'application.


! Fichier Microsoft PowerPoint® 2560A_05.ppt ! Application pratique ExpressionPractice


! lire tous les documents de cours relatifs à ce module ; ! réaliser les applications pratiques et l'atelier.


Documents de cours

Préparation

iv Module 5 : Structures de décision et boucles


Leçon : Utilisation d'expressions conditionnelles Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Cette leçon explique comment élaborer des expressions conditionnelles à l'aide d'opérateurs arithmétiques, logiques et de comparaison. Insistez sur le fait que les stagiaires utiliseront des expressions conditionnelles dans les structures de décision mais que l'utilisation de ces expressions n'est pas limitée aux structures de décision ; ils peuvent les utiliser dans des variables et dans des tableaux.

Cette rubrique définit les expressions conditionnelles. Précisez aux stagiaires qu'ils devront élaborer des expressions conditionnelles pour des branches de décision dans leurs applications. Expliquez que les conditions sont déclarées True (Vraies) ou False (Fausses) et qu'ils utiliseront des opérateurs logiques et des opérateurs de comparaison pour constituer ces expressions.

Cette rubrique décrit les opérateurs arithmétiques utilisés dans Microsoft Visual Basic .NET. Expliquez que ces opérateurs donnent la possibilité d'utiliser les fonctions mathématiques classiques, telles que l'addition, la soustraction, la multiplication, la division et les fonctions exponentielles.

Cette rubrique présente les six opérateurs de comparaison. Assurez-vous que les stagiaires comprennent bien que ce sont les opérateurs qui définissent les conditions permettant de contrôler si une expression est True ou False. Expliquez-leur qu'ils peuvent utiliser des opérateurs de comparaison pour tester les nombres ou les chaînes.

Cette rubrique décrit les six opérateurs logiques utilisés dans Microsoft Visual Basic .NET. Si certains de vos stagiaires ont déjà utilisé Visual Basic 6.0, précisez éventuellement que les deux opérateurs logiques Eqv et Imp ne sont pas pris en charge dans Visual Basic .NET mais qu'ils peuvent remplacer Eqv par l'opérateur de comparaison = et Imp par une expression incluant les opérateurs Not et Or.

Cette rubrique détaille la façon dont il faut associer les opérateurs de comparaison aux opérateurs logiques. Expliquez aux stagiaires qu'ils associeront souvent des opérateurs de comparaison aux opérateurs logiques et que, pour ce faire, ils devront connaître l'ordre dans lequel Visual Basic .NET évalue les opérateurs.

Au cours de cette application pratique, les stagiaires utiliseront une application concrète pour calculer les résultats des expressions conditionnelles. Une durée de 20 minutes environ est prévue pour cette application pratique.

Présentation des expressions conditionnelles

Utilisation d'opérateurs arithmétiques

Utilisation d'opérateurs de comparaison

Utilisation d'opérateurs logiques

Association d'opérateurs logiques et d'opérateurs de comparaison

Application pratique : Évaluation d'expressions conditionnelles

Module 5 : Structures de décision et boucles v

Leçon : Utilisation de structures de décision Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Cette leçon expose la façon dont les structures de décision If�Then et Select Case doivent être utilisées. Elle s'attache également au moyen d'incorporer des expressions conditionnelles dans ces structures afin de produire le résultat voulu.

Cette rubrique présente la structure de base If�Then. Soulignez que cette structure est appropriée lorsque la logique du programme est tributaire de la véracité ou de la fausseté d'une instruction.

Cette rubrique présente la structure If�Then�Else. Précisez qu'il s'agit d'une extension de If�Then. Il est important que les stagiaires s'attachent à la façon dont les lignes de code qu'ils écrivent sont exécutées ; ainsi il est bon de leur spécifier que si plusieurs des conditions stipulées dans une structure conditionnelle sont vraies, seules les instructions de code englobées par la première condition vraie sont exécutées.

Cette rubrique présente la structure If�Then�ElseIf. Précisez que ces instructions If�Then�ElseIf sont identiques aux instructions If�Then�Else à ceci près qu'elles permettent aux stagiaires de définir plus de deux choix.

Cette rubrique développe l'instruction Select Case. Expliquez que cette instruction fonctionne comme une structure If�Then�Else imbriquée et complexe, mais que l'instruction Select Case est plus facile à gérer.

Cette rubrique regroupe les directives permettant de choisir une structure de décision. Mettez l'accent sur les choix optimaux, surtout lorsqu'il s'agit de choisir la structure Select Case à la place de structures imbriquées et complexes If�Then�ElseIf.

Atelier 5.1 : Utilisation de structures de décision Avant de démarrer cet atelier, les stagiaires doivent s'assurer qu'ils ont réalisé toutes les applications pratiques et répondu aux questions de contrôle des acquis. Les stagiaires seront à même de mettre en pratique la plupart des connaissances qu'ils ont apprises dans les leçons et les applications pratiques. Cet atelier fait partie de l'application sur le calcul des échéances de remboursement d'un emprunt. Au début de cet atelier, les stagiaires peuvent continuer à travailler avec leurs propres fichiers ou utiliser les fichiers prévus à cet effet.

Utilisation d'instructions If�Then

Utilisation d'instructions If�Then�Else

Utilisation d'instructions If�Then�ElseIf

Utilisation d'instructions Select Case

Principes de sélection d'une structure de décision

vi Module 5 : Structures de décision et boucles

Leçon : Utilisation de structures de boucles conditionnelles Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Cette leçon explique comment utiliser les boucles conditionnelles pour décider de l'exécution du code et du moment de son exécution. Elle s'attache également à la prise de décision concernant l'utilisation d'une instruction Exit pour quitter une boucle.

Cette rubrique présente la structure For�Next. Précisez que l'utilisation de cette instruction est recommandée pour ceux qui connaissent la condition à tester et le nombre de fois qu'une boucle doit être exécutée. Expliquez aux stagiaires qu'ils utiliseront des instructions For�Next pour les compteurs.

Cette rubrique développe la structure For Each�Next. Expliquez le concept de collection et précisez aux stagiaires qu'ils utiliseront ces instructions en vue d'exécuter des blocs d'instructions pour les éléments des collections ou des tableaux.

Signalez aux stagiaires qu'ils utiliseront ces instructions en boucle pour définir des compteurs. Expliquez que, pour connaître l'instruction en boucle à utiliser, ils doivent comprendre à quel moment les instructions situées à l'intérieur de la boucle sont exécutées. Soulignez qu'un mot clé While ou Until est requis dans la structure Do�Loop. Insistez sur le fait que la différence entre ces instructions réside dans le moment où la condition est vérifiée : pour l'instruction Do�Loop Until, la condition est vérifiée après l'exécution du code tandis qu'elle est contrôlée avant l'exécution pour l'instruction Do Until�Loop. Cette rubrique s'attache également à développer les instructions Do�Loop While et Do While�Loop. Insistez sur le fait que la différence entre ces instructions réside dans le moment où la condition est vérifiée : pour l'instruction Do�Loop While, la condition est vérifiée après l'exécution du code tandis qu'elle est contrôlée avant l'exécution pour l'instruction Do While�Loop.

Cette rubrique présente l'instruction Exit. Signalez aux stagiaires qu'ils utiliseront des instructions Exit pour quitter les boucles. Expliquez que les instructions Exit sont utilisables dans les structures Do�Loop et For...Next.

Dans la première partie de cette application pratique, les stagiaires doivent résoudre des problèmes de programmation dans quatre scénarios à l'aide d'une structure en boucle spécifique. Vous pouvez exploiter cette partie comme un cours ouvrant sur un débat, mais vous pouvez aussi donner des instructions aux stagiaires pour qu'ils travaillent individuellement sur les solutions. Dans la seconde partie de cette application pratique, les stagiaires se serviront d'une boucle For...Next pour créer une table de multiplication. Une durée de 25 minutes environ est prévue pour cette application pratique.

Utilisation d'instructions For�Next

Utilisation d'instructions For Each�Next

Utilisation d'instructions Do�Loop

Utilisation de l'instruction Exit

Application pratique : Élaboration de structures en boucle

Module 5 : Structures de décision et boucles vii

Contrôle des acquis Les questions sont basées principalement sur la théorie et sur les procédures détaillées dans le module. Vous pouvez préférer la forme d'une discussion pour aborder ces questions afin que chacun profite des réponses.

1. Si les stagiaires ont du mal à répondre à cette question, approfondissez la comparaison des chaînes.

2. Si les stagiaires ont du mal à répondre à cette question, revoyez l'opérateur de comparaison >= (supérieur ou égal à) et l'instruction If�Then.

3. Si les stagiaires ont du mal à répondre à cette question, approfondissez la structure en boucle For�Next. Les stagiaires seront probablement amenés à utiliser souvent cette structure.

4. Cette question aide les stagiaires à lire des exemples de code en s'attachant à rechercher des valeurs vraies ou fausses.

5. Cette question donne la possibilité aux stagiaires d'écrire une structure Select Case. Cette question peut être traitée avec l'ensemble de la classe.

Module 5 : Structures de décision et boucles 1

Vue d'ensemble

! Utilisation d�expressionsconditionnelles

! Utilisation de structures de décision

! Utilisation de structures de boucles conditionnelles

Debugand Deploy

Écriturede code

Accès auxdonnées


Studio .NET

Débogage et déploiement

Créationd�une

interface


La plupart des applications Microsoft® Visual Basic® sont élaborées en créant des procédures exécutables au moment où un événement particulier survient. Par exemple, vous écrivez le code d'une procédure Button_Click pour qu'elle s'exécute seulement lorsqu'un utilisateur clique sur le bouton.

Il est possible d'étendre ce modèle de programmation événementielle à l'aide de structures de décision et de boucles. Vous utilisez les structures de décision pour comparer des valeurs et ensuite exécuter une certaine section du code en fonction des résultats. Vous utilisez en revanche les structures en boucle pour exécuter de façon répétitive un ensemble d'instructions jusqu'à ce qu'une condition soit remplie. Ce module explique comment implémenter les structures de décision et les structures en boucle pour contrôler les sorties et l'exécution du programme.


! créer des formules et des expressions conditionnelles à l'aide d'opérateurs arithmétiques, logiques et de comparaison ;

! utiliser des instructions If�Then pour évaluer si une condition est vraie ou fausse et canaliser le flux du programme en conséquence ;

! utiliser des instructions Select Case pour tester les différentes valeurs d'une même expression et exécuter les instructions correspondantes ;

! utiliser des instructions Do�Loop pour exécuter des instructions jusqu'à ce qu'une condition spécifique soit remplie ou pendant qu'elle est remplie ;

! utiliser des instructions For�Next pour exécuter des instructions un nombre de fois déterminé ;

! choisir la structure de décision ou la boucle appropriées en fonction des conditions requises par l'application.

Introduction

Objectifs

2 Module 5 : Structures de décision et boucles

Leçon : Utilisation d'expressions conditionnelles

! Présentation des expressions conditionnelles

! Utilisation d�opérateurs arithmétiques

! Utilisation d�opérateurs de comparaison

! Utilisation d�opérateurs logiques

! Association d�opérateurs logiques et d�opérateurs de comparaison


Lorsque vous écrivez des applications dans Microsoft Visual Basic® .NET, vous devez utiliser des expressions que l'ordinateur peut évaluer. Les expressions correspondant à True ou à False s'appellent des expressions conditionnelles. Cette leçon explique comment élaborer des expressions conditionnelles à l'aide d'opérateurs arithmétiques, logiques et de comparaison.


! Présentation des expressions conditionnelles ! Utilisation d'opérateurs arithmétiques ! Utilisation d'opérateurs de comparaison ! Utilisation d'opérateurs logiques ! Association d'opérateurs logiques et d'opérateurs de comparaison ! Application pratique : Évaluation d'expressions conditionnelles


! décrire les opérateurs arithmétiques, logiques et de comparaison ; ! utiliser des opérateurs arithmétiques, logiques et de comparaison pour créer

des formules et évaluer des conditions.




Présentation des expressions conditionnelles

! Expressions conditionnelles :

" Incluent une condition à tester True ou False

" Incluent un opérateur permettant de spécifier de queltest de la condition il s�agit

Si le mot de passe est correct, la condition est True

True

False

MotDePasseEntré=

MotDePasseStocké

MotDePasseEntré=

MotDePasseStocké


Les expressions conditionnelles permettent de développer une application pour effectuer des tâches de manière sélective, en se basant sur les valeurs générées par l'application ou sur les valeurs saisies par l'utilisateur. Les expressions conditionnelles sont très utiles en programmation, mais elles sont couramment employées dans les instructions contrôlant l'exécution du programme.

Les expressions conditionnelles doivent renvoyer soit True soit False. La forme de l'expression peut être aussi simple qu'une variable définie de type Boolean (ou d'un type de variable pouvant être converti implicitement en type Boolean), mais elle peut être également une combinaison de variables et de littéraux regroupés par un opérateur qui renvoie un résultat de type Boolean.

Le tableau suivant synthétise des exemples d'expressions conditionnelles avec les valeurs qu'elles renvoient.

Expression conditionnelle Valeur renvoyée par l'expression

5 > 2 Correspond à True.

DateToday = #11/30/99# Correspond à False le jour où vous la lisez.

EnteredPassword = StoredPassword Correspond à True si EnteredPassword est identique à StoredPassword.

MyFirstName = "John" Correspond à True si vous vous appelez John. Correspond à False si vous vous appelez autrement.

Conditions de test

Exemples d'expressions conditionnelles


Utilisation d'opérateurs arithmétiques

! Syntaxe :

expression1 opérateur arithmétique expression2expression1 opérateur arithmétique expression2

Dim x As Integerx = 52 * 17x = 120 / 4x = 67 + 34x = 32 � 12x = 23 ^ 3

Dim x As Integerx = 52 * 17x = 120 / 4x = 67 + 34x = 32 � 12x = 23 ^ 3

! Exemple :

! Symboles évaluant des expressions conditionnelles

! Peuvent effectuer des opérations arithmétiques


Les opérateurs arithmétiques sont utilisés pour effectuer de nombreuses opérations arithmétiques courantes qui impliquent le calcul de valeurs numériques représentées par des littéraux, des variables, d'autres expressions, des appels de propriétés et de fonctions, et des constantes.

Les opérateurs arithmétiques que vous utiliserez le plus fréquemment dans Visual Basic .NET sont répertoriés dans le tableau suivant.

Opérateur arithmétique Description

* Multiplication

/ Division

+ Addition

- Soustraction

^ Exponentiation

La syntaxe générale des opérateurs arithmétiques est la suivante :

expression1 opérateur arithmétique expression2

L'exemple suivant illustre les opérateurs arithmétiques les plus couramment utilisés :

Dim x As Integer x = 52 * 17 x = 120 / 4 x = 67 + 34 x = 32 - 12 x = 23 ^ 3

Opérateurs arithmétiques

Syntaxe

Exemple d'utilisation d'opérateurs arithmétiques


Utilisation d'opérateurs de comparaison

! Symboles évaluant des expressions conditionnelles et renvoyant une valeur de type Boolean

! Peuvent comparer des nombres et des chaînes

! Syntaxe :

expression1 opérateur de comparaison expression2expression1 opérateur de comparaison expression2

Dim Quantity As Integer

Dim LargeOrder As Boolean

LargeOrder = Quantity > 1000

Dim Quantity As Integer

Dim LargeOrder As Boolean

LargeOrder = Quantity > 1000

! Exemple :


Un opérateur de comparaison effectue une opération avec deux valeurs et renvoie un résultat de type Boolean. Visual Basic NET prend en charge six opérateurs de comparaison.

Lorsque Visual Basic .NET compare deux expressions, il renvoie une des deux valeurs : True ou False. Ces valeurs sont appelées valeurs de type Boolean. Lorsque des valeurs de type Boolean sont converties en types numériques, False se transforme en 0 et True en -1. Les opérateurs de comparaison renvoient une de ces valeurs de type Boolean lorsqu'ils testent une expression conditionnelle.

Les six opérateurs de comparaison utilisables dans Visual Basic .NET sont les suivants :

Opérateur Description

< Inférieur à

<= Inférieur ou égal à

> Supérieur à

>= Supérieur ou égal à

= Égal à

<> Différent de

La syntaxe générale des opérateurs de comparaison est la suivante :

expression1 opérateur de comparaison expression2

Valeurs de type Boolean

Opérateurs de comparaison

Syntaxe


Par exemple, vous voulez que votre application de traitement des commandes clients offre une remise sur toutes les commandes passées pour un article dont la quantité est supérieure à 1000. Le code suivant montre comment référencer ce test plus d'une fois, vous décidez donc de stocker le résultat du test dans une variable de type Boolean nommée LargeOrder.

Dim Quantity As Integer Dim LargeOrder As Boolean LargeOrder = Quantity > 1000

Lorsque Visual Basic .NET compare deux chaînes, il compare chaque chaîne, caractère par caractère, jusqu'à l'apparition de la première non-correspondance. Une chaîne est égale à une autre uniquement si les deux chaînes ont la même longueur et si elles contiennent exactement la même séquence de caractères. Chaque caractère possède une valeur numérique afin de permettre la comparaison.

Expressions de chaîne Résultat

"CHIEN" = "CHIEN" True. Les deux chaînes sont identiques.

"CHIEN" = "chien" False. Bien que les deux chaînes contiennent le nom chien, une chaîne est en majuscules et l'autre en minuscules.

Exemple d'utilisation d'opérateurs de comparaison

Exemples de chaînes de comparaison


Utilisation d'opérateurs logiques

! Les opérateurs logiques procèdent à une évaluationlogique des expressions et renvoient une valeur de type Boolean

! Syntaxe :

expression1 opérateur logique expression2expression1 opérateur logique expression2

OrderedLastMonth And OrderDeliveredOrderedLastMonth And OrderDelivered

! Exemple :


Les opérateurs logiques sont utilisés pour évaluer une ou plusieurs expressions conditionnelles et renvoyer une valeur de type Boolean unique True ou False. Vous pouvez utiliser six opérateurs logiques dans Visual Basic .NET.

Le tableau suivant regroupe les six opérateurs logiques utilisés dans Microsoft Visual Basic .NET. Notez que tous les opérateurs sauf Not fonctionnent avec deux expressions, également appelées opérandes.

Opérateur Fonction

And Associe deux expressions. Chaque expression doit être True pour que l'expression entière soit True.

True And True = True

False And False = False

True And False = False

False And True = False Or Associe deux expressions. Si une expression est True, toute l'expression

est True.

True Or True = True

True Or False = True

False Or True = True

False Or False = False

Not Donne le sens logique négatif de la saisie.

Not(True) = False

Not(False) = True

AndAlso Si la première expression d'une expression AndAlso correspond à False, la deuxième expression n'est pas évaluée et la valeur False est renvoyée pour l'expression AndAlso.

Opérateurs logiques


(suite) Opérateur Fonction

OrElse Si la première expression d'une expression OrElse correspond à True, la seconde expression n'est pas évaluée et la valeur True est renvoyée pour l'expression OrElse.

Xor Associe deux expressions. L'expression entière est considérée comme True si les deux expressions ne sont ni toutes les deux True ni toutes les deux False.

True Xor True = False

True Xor False = True

False Xor True = True

False Xor False = False

La syntaxe générale des opérateurs logiques est la suivante :

expression1 opérateur logique expression2

Le tableau suivant fournit des exemples d'opérateurs logiques And et Or.

Exemple de code Résultat

OrderedLastMonth And OrderDelivered

Renvoie la valeur True si la dernière commande a été passée le mois précédent et qu'elle a été livrée. OrderedLastMonth et OrderDelivered sont des variables de type Boolean.

ChildMembership Or AdultMembership

Renvoie la valeur True si le membre en question est indifféremment un enfant ou un adulte.

Syntaxe

Exemples d'opérateurs logiques


Association d'opérateurs logiques et d'opérateurs de comparaison

! Vous pouvez combiner des opérateurs de comparaison avec des opérateurs logiques à l�aided�instructions conditionnelles

! Exemple :

LateActiveCustomer = DaysOverDue >= 60 And ActiveCustomerLateActiveCustomer = DaysOverDue >= 60 And ActiveCustomer

Opérateurs de comparaison

Opérateur logique


Il est possible de combiner des opérateurs de comparaison à des opérateurs logiques dans vos expressions conditionnelles. Lorsque vous associez des opérateurs, vous devez prendre en compte l'ordre dans lequel Visual Basic .NET résout les opérateurs. Visual Basic .NET se base sur un ensemble de règles appelées priorité des opérateurs pour effectuer de nombreuses opérations dans une expression.

L'exemple suivant associe des opérateurs de comparaison à un opérateur logique :

LateActiveCustomer = DaysOverDue >= 60 And ActiveCustomer

Lorsque vous combinez des opérateurs de comparaison à des opérateurs logiques sur une seule ligne de code, les opérateurs de comparaison sont évalués après les opérateurs arithmétiques et les opérateurs de concaténation, mais avant les opérateurs logiques.

Le résultat de l'exemple suivant est 130 parce que la multiplication est prioritaire :

x = 100 + 10 * 3

Les opérateurs logiques sont évalués selon l'ordre suivant :

1. Not 2. And 3. Or 4. Xor

Si vous utilisez le même opérateur logique ou de comparaison plusieurs fois sur une seule ligne de code, les opérateurs sont évalués de gauche à droite.

Exemple de combinaison d'opérateurs

Priorité des opérateurs


La priorité des opérateurs est souvent à l'origine d'erreurs de logique dans un programme. Incluez des parenthèses pour forcer l'ordre d'évaluation. Par exemple, le tableau logique de l'expression suivante est affiché ci-dessous :

Réponse = A And B Or C And D

A B C D Réponse

False False False False False

False False False True False

False False True False False

False False True True True

False True False False False

False True False True False

False True True False False

False True True True True

True False False False False

True False False True False

True False True False False

True False True True True

True True False False True

True True False True True

True True True False True

True True True True True

Forçage de l'ordre d'évaluation des opérateurs


À présent, réexaminez ce tableau logique une fois l'ordre d'évaluation modifié. Les différences sont représentées en gras :

Réponse = A And (B Or C) And D

A B C D Réponse

False False False False False

False False False True False

False False True False False

False False True True False

False True False False False

False True False True False

False True True False False

False True True True False

True False False False False

True False False True False

True False True False False

True False True True True

True True False False False

True True False True True

True True True False False

True True True True True


Application pratique : Évaluation d'expressions conditionnelles

! Utilisez l�application exemple pour calculer les résultats de ces expressions :

TestString = TestStringTestString = TestString 0 And 00 And 0

TestString = TeststringTestString = Teststring -1 And 0-1 And 0

TestString < TestStringTestString < TestString -1 And -1-1 And -1

Test < TestStringTest < TestString -1 Or -1-1 Or -1

100 > 10100 > 10 -1 Xor -1-1 Xor -1

10 < 1010 < 10 -1 Xor 0-1 Xor 0

10 <= 1010 <= 10 0 Xor 00 Xor 0


! Démarrage de Microsoft Visual Studio® .NET et chargement du projet de démonstration


2. Sur la page de démarrage, cliquez sur Commencer, puis sur Ouvrir un projet. Dans la boîte de dialogue Ouvrir un projet, accédez au dossier dossier_installation\Practices\Mod05\ExpressionPractice et double-cliquez sur ExpressionPractice.sln.


1. Dans la barre d'outils standard, cliquez sur le bouton Démarrer. 2. Calculez la réponse pour les expressions répertoriées dans le tableau suivant

et utilisez l'application pour vérifier vos calculs. a. Pour vérifier les expressions suivantes, transmettez les valeurs comme

des valeurs String en n'activant pas la case à cocher Traiter les valeurs en tant que nombres.

Expression

Résultat (Écrire le résultat de l'application ci-dessous.)

TestString = TestString True (-1)

TestString = Teststring False (0)

TestString < TestString False (0)

Test < TestString True (-1)


b. Pour vérifier les expressions suivantes, transmettez les valeurs comme des valeurs Numeric en sélectionnant Traiter les valeurs en tant que nombres. Dans les expressions utilisant des opérateurs logiques, souvenez-vous que -1 correspond à True et 0 à False.

Expression

Résultat (Écrire le résultat de l'application ci-dessous.)

100 > 10 True (-1)

10 < 10 False (0)

10 <= 10 True (-1)

0 And 0 False (0)

-1 And 0 False (0)

-1 And -1 True (-1)

-1 Or -1 True (-1)

-1 Xor -1 False (0)

-1 Xor 0 True (-1)

0 Xor 0 False (0)

! Fermeture de l'application • Quittez l'application.


Leçon : Utilisation de structures de décision

! If�ThenIf Ventes > 10000 Then

Prime = 0.10 * VentesEnd If

If Ventes > 10000 Then Prime = 0.10 *

VentesEnd If

If Ventes > 10000 Then Prime = 0.10 * Ventes

ElsePrime = 0

End If


ElsePrime = 0

End If


ElseIf Ventes > 5000 Then Prime = 0.05 * VentesElsePrime = 0.02 * VentesEnd If


ElseIf Ventes > 5000 Then Prime = 0.05 * VentesElsePrime = 0.02 * VentesEnd If

Select Case RankCase 1Prime = 0

Case 2, 3Prime = 0.05 * Ventes

Case 4 to 6Prime = 0.10 * Ventes

Case ElsePrime = 0.15 * Ventes

End Select

Select Case RankCase 1Prime = 0

Case 2, 3Prime = 0.05 * Ventes

Case 4 to 6Prime = 0.10 * Ventes

Case ElsePrime = 0.15 * Ventes

End Select

! If�Then�Else

! If�Then�ElseIf ! Select Case


Dans votre programme, vous voulez exécuter quelques sections de votre code uniquement lorsqu'une condition particulière est remplie. Utilisez une structure de décision pour accomplir cela. Cette leçon expose la façon dont les structures de décision If�Then et Select Case doivent être utilisées. Vous apprendrez également à incorporer des expressions conditionnelles dans ces structures.


! Utilisation d'instructions If�Then ! Utilisation d'instructions If�Then�Else ! Utilisation d'instructions If�Then�ElseIf ! Utilisation d'instructions Select Case ! Principes de sélection d'une structure de décision


! utiliser des instructions If�Then ; ! utiliser des instructions If�Then�Else ; ! utiliser des instructions If�Then�ElseIf ; ! utiliser des instructions Select Case ; ! choisir la structure de décision appropriée pour un scénario donné.




Utilisation d'instructions If�Then

! À utiliser pour une décision True ou False

! Si la condition est True, les instructions suivantl�instruction If sont exécutées

! Si la condition est False, les instructions suivantl�instruction If ne sont pas exécutées


End If


End If


En règle générale, vous utilisez la structure If�Then lorsque votre programme doit déterminer si une instruction est vraie ou fausse.

Les instructions If�Then jugent si une condition est vraie ou fausse et canalisent le flux du programme en conséquence.

Les instructions If�Then prennent indifféremment la syntaxe d'une ligne unique comme celle d'un bloc. Remarquez que la version à ligne unique ne nécessite pas l'utilisation de l'instruction End If. L'instruction If�Then à ligne unique est généralement utilisée pour exécuter une instruction sous condition uniquement. Dans les instructions en bloc If�Then, l'usage veut que le code soit en retrait entre les instructions If et End If. La meilleure habitude est celle qui privilégie la lisibilité.

Vous pouvez utiliser la syntaxe à ligne unique suivante :

If condition Then clause

Sinon, n'hésitez pas à utiliser la syntaxe en bloc suivante :

If condition Then instructions End If

Cet exemple compare la valeur d'un entier nommé Ventes à 10 000. Si Ventes dépasse 10 000, une prime de 10 pour -cent est calculée. Si la valeur de Ventes ne dépasse pas 10 000, la ligne de code située derrière Then est ignorée et la prime n'est pas calculée.

If Ventes > 10000 Then Prime = 0.10 * Ventes End If

Syntaxe

Exemple d'instruction If�Then


Utilisation d'instructions If�Then�Else

! À utiliser avec une décision offrant au moins deux choix

! Chaque instruction If doit avoir une instruction End If correspondante

! Si la condition est True, les instructions suivantl�instruction If sont exécutées

! Si la condition est False, les instructions suivantl�instruction If ne sont pas exécutéesIf Ventes > 10000 Then

Prime = 0.10 * VentesElse

Prime = 0End If


ElsePrime = 0

End If


Les instructions If�Then�Else sont une extension du concept If�Then. Grâce à l'utilisation d'un bloc If�Then�Else, vous pouvez définir deux blocs de code, mais votre programme n'exécutera que l'un ou l'autre de ces blocs selon le résultat de la condition posée. Si plusieurs conditions incluses dans la structure conditionnelle sont vraies, seules les instructions de code englobées par la première condition vraie sont exécutées.

Une instruction If�Then�Else comprend les composants suivants :

! une condition qui évalue si True ou False ; ! une ou plusieurs instructions d'exécution en fonction du résultat de la

condition de test ; ! une instruction End If dans le cas d'un bloc.

Pour utiliser une instruction If�Then�Else, utilisez la syntaxe suivante :

If condition Then instructions Else instructions End If

Cet exemple compare la valeur d'un entier nommé Ventes à 10 000. Si Ventes dépasse 10 000, une prime de 10 pour cent est calculée. Si la valeur de Ventes ne dépasse pas 10 000, la prime est égale à zéro.

If Ventes > 10000 Then Prime = 0.10 * Ventes Else Prime = 0 End If

Introduction

Syntaxe

Exemple d'instruction If�Then�Else


Vous pouvez utiliser autant d'instructions If�Then que vous voulez dans une structure If�Then. L'ajout d'instructions If�Then dans une structure If�Then s'appelle l'imbrication.

À titre d'exemple, le code suivant montre comment attribuer une prime sur les ventes à un employé à temps partiel dont la prime est inférieure à celle d'un employé à temps plein.

If Ventes > 10000 Then If ContratEmployé = "Temps plein" Then Prime = 0.10 * Ventes Else Prime = 0.08 * Ventes End If Else Prime = 0 End If

Imbrication d'instructions If�Then

Exemple d'imbrication


Utilisation d'instructions If�Then�ElseIf

! À utiliser pour imbriquer des instructions de décision! Chaque instruction If doit avoir une instruction End If

correspondante! Les instructions ElseIf n�ont pas leur propre End If! Les instructions ElseIf ne peuvent pas suivre Else! Si la condition est True, les instructions suivant If sont

exécutéesIf Ventes > 10000 Then

Prime = 0.10 * VentesElseIf Ventes > 5000 Then

Prime = 0.05 * VentesElse

Prime = 0.02 * VentesEnd If


ElseIf Ventes > 5000 Then Prime = 0.05 * Ventes

ElsePrime = 0.02 * Ventes

End If


Les instructions If�Then�ElseIf sont identiques aux instructions If�Then�Else à ceci près qu'elles permettent à votre programme de choisir entre plusieurs solutions (plus de 2).

Pour utiliser une instruction If�Then�ElseIf, utilisez la syntaxe suivante :

If condition Then instructions ElseIf condition2 Then instructions Else instructions End If

Cet exemple compare tout d'abord la valeur d'un entier nommé Ventes à 10 000, puis à 5 000. Si Ventes dépasse 10 000, une prime de 10 pour-cent est calculée. Si Ventes dépasse 5 000, une prime de 5 pour cent est calculée. Si la valeur de Ventes ne dépasse ni 10 000 ni 5 000, une prime de 2 pour cent est calculée.

If Ventes > 10000 Then Prime = 0.10 * Ventes ElseIf Ventes > 5000 Then Prime = 0.05 * Ventes Else Prime = 0.02 * Ventes End If

Introduction

Syntaxe

Exemple d'instruction If�Then�ElseIf


Utilisation d'instructions Select Case

! Sélectionnent un bloc de code à exécuter à partir d�une liste de choix possibles

! À utiliser comme alternative aux instructions imbriquées et complexes If�Then�Else

! Si plusieurs instructions Case sont vraies, seules les instructions appartenant à la première instruction Case vraie sont exécutées

Select Case RankCase 1

Prime = 0Case 2, 3

Prime = 0.05 * VentesCase 4 to 6

Prime = 0.10 * VentesCase Else

Prime = 0.15 * Ventes End Select

Select Case RankCase 1

Prime = 0Case 2, 3

Prime = 0.05 * VentesCase 4 to 6

Prime = 0.10 * VentesCase Else

Prime = 0.15 * Ventes End Select


L'instruction Select Case permet à votre application d'exécuter un bloc de code parmi plusieurs blocs en fonction de la valeur d'une expression test. Cette instruction Select Case fonctionne comme une structure If�Then�Else imbriquée et complexe, mais elle est plus facile à gérer que cette structure.

La syntaxe de l'instruction Select Case est la suivante :

Select Case expressiontest [Case listeexpression-n] [instructions-n1] . . . [Case Else] [instructionelse] End Select

L'exemple suivant montre comment utiliser l'instruction Select Case pour évaluer la valeur d'une prime basée sur six conditions différentes. Si aucune des conditions n'est vraie, la prime est définie sur 15 pour cent.

Dim Rank As Integer [Set Rank value] ... Select Case Rank Case 1 Prime = 0 Case 2, 3 Prime = 0.05 * Ventes Case 4 to 6 Prime = 0.10 * Ventes Case Else Prime = 0.15 * Ventes End Select

Introduction

Syntaxe

Exemple d'instruction Select Case


Principes de sélection d'une structure de décision

! Utiliser les instructions If�Then pour contrôlerl�exécution d�un bloc de code unique

! Utiliser les instructions If�Then�Else pour contrôlerl�exécution de deux sections de code s�excluantmutuellement

! Utiliser les instructions Select Case lorsque vous avezune liste de valeurs possibles à votre disposition


Vous devez soigneusement choisir la structure de décision à utiliser car Visual Basic .NET quitte une structure de décision dès qu'il rencontre la première instruction vraie. Ainsi, toute condition suivant la première instruction vraie n'est pas testée.

Consultez les directives suivantes pour déterminer quelle structure de décision utiliser :

! Utiliser des instructions If�Then pour contrôler l'exécution d'un bloc de code unique.

! Utiliser des instructions If�Then�Else pour contrôler l'exécution de deux sections de code s'excluant mutuellement. Si vous choisissez des instructions ElseIf, davantage de sections s'offrent à vous. Cependant, si vous avez utilisé plusieurs instructions ElseIf, vous pouvez préférer l'instruction Select Case.

! Utiliser des instructions Select Case lorsque vous avez une liste de valeurs possibles.

Introduction

Principes


Atelier 5.1 : Utilisation de structures de décision

! Exercice 1 : Vérification des entrées de l�utilisateur

! Exercice 2 : Confirmation de la fermeturede l�application



! élaborer des expressions conditionnelles ; ! utiliser des structures de décision dans une procédure.

Cet atelier met l'accent sur les concepts de ce module, par conséquent il est possible qu'il ne se conforme aux recommandations de sécurité émises par Microsoft.

Avant de poursuivre, vous devez avoir acquis :

! une expérience dans l'utilisation de variables et de constantes avec Visual Basic .NET ;

! une connaissance des procédures Visual Basic .NET ; ! une expérience dans l'utilisation des contrôles et des formulaires dans

Visual Basic .NET.

Dans les ateliers des modules 2, 4, 5, 6 et 12 du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET, vous créerez une application permettant d'estimer les échéances de remboursement d'un emprunt. Vous concevrez l'application dans son intégralité et par étapes ; chaque étape se basant sur le code créé dans l'atelier précédent. Au début de chaque atelier, vous pourrez continuer de travailler avec vos propres fichiers ou utiliser les fichiers prévus à cet effet.

Au cours de l'atelier 5.1, vous manipulerez des expressions conditionnelles et des structures de décision pour vérifier les entrées utilisateur et confirmer la fermeture d'une application.

Objectifs

Remarque


Scénario



Fichiers solution



Exercice 1 Vérification des entrées de l'utilisateur

Dans cet exercice, vous ajouterez le code permettant de vérifier si la saisie des informations sur l'emprunt dans toutes les zones de texte est correcte avant d'appeler les fonctions de calcul du prêt hypothécaire. Pour en savoir plus sur la validation des entrées de l'utilisateur, consultez le module 6, « Validation des entrées de l'utilisateur » du cours 2560A, Introduction à la programmation en Visual Basic® NET avec Microsoft® .NET.

! Ouverture du projet de l'application sur l'emprunt • Ouvrez le projet de l'application sur l'emprunt de l'atelier 4.1, « Création et

utilisation de procédures » dans le module 4, « Utilisation de procédures » du cours 2560A, Introduction à la programmation en Visual Basic® NET avec Microsoft® .NET. Si vous n'avez pas réalisé l'atelier 4.1, utilisez le projet LoanApplication.sln dans le dossier dossier_installation\Labfiles\ Lab051\Ex01\Starter.

! Modification du gestionnaire d'événements pour le bouton MonthlyPayment

• Dans le gestionnaire d'événements MonthlyPaymentButton_Click, utilisez une instruction If�Then�Else pour vous assurer que l'utilisateur a saisi le montant de l'emprunt et qu'il a sélectionné un taux d'intérêt avant d'appeler la fonction MonthlyPayment. Votre code doit ressembler au texte suivant : If (LoanTextBox.Text <> "" And _ RateComboBox.Text <> "") Then MessageBox.Show(FormatCurrency(MonthlyPayment _ (CDbl(LoanTextBox.Text), CDbl(RateComboBox.Text), _ loanTerm))) Else MessageBox.Show _ ("Veuillez saisir un montant de prêt et un taux d'intérêt.", _ "Données non valides", MessageBoxButtons.OK, _ MessageBoxIcon.Error) End If


! Modification du gestionnaire d'événements pour le bouton TotalPaid • Dans le gestionnaire d'événements TotalPaidButton_Click, utilisez une

instruction If�Then�Else pour vous assurer que l'utilisateur a saisi le montant de l'emprunt et qu'il a sélectionné un taux d'intérêt avant d'appeler la fonction TotalPaid. Votre code doit ressembler au texte suivant : If (LoanTextBox.Text <> "" And _ RateComboBox.Text <> "") Then MessageBox.Show(FormatCurrency(TotalPaid _ (CDbl(LoanTextBox.Text), CDbl(RateComboBox.Text), _ loanTerm))) Else MessageBox.Show _ ("Veuillez saisir un montant de prêt et un taux d'intérêt.", _ "Données non valides", MessageBoxButtons.OK, _ MessageBoxIcon.Error) End If

! Test de l'application 1. Exécutez l'application. 2. Cliquez sur les boutons sans entrer de données.

Un message doit s'afficher. 3. Tapez 20000 dans la zone de texte Montant du prêt, sélectionnez 10 dans

la zone Taux d'intérêt et cliquez sur Mensualité. Un message affiche le montant de 424,94 �.

Saisissez uniquement des caractères numériques dans ces zones de texte sinon l'application produira une exception. Vous apprendrez à résoudre ce problème dans le module 6, « Validation des entrées de l'utilisateur » du cours 2560A, Introduction à la programmation en Visual Basic® NET avec Microsoft® .NET.

Attention


Exercice 2 Confirmation de la fermeture de l'application

Dans cet exercice, vous inviterez l'utilisateur à confirmer son choix avant la fermeture de l'application.

! Modification du gestionnaire d'événements pour le bouton DoneButton_Click

• Dans le gestionnaire d'événements DoneButton_Click, utilisez un message pour demander une confirmation de fermeture de l'application à l'utilisateur. Si celui-ci clique sur le bouton OK dans le message, fermez le formulaire (ce qui revient à fermer l'application puisqu'il n'y a qu'un formulaire). Sinon, laissez l'application ouverte. Votre code doit ressembler au texte suivant : If (MessageBox.Show("Voulez-vous quitter l'application ?", _ "Fermer", MessageBoxButtons.YesNo, _ MessageBoxIcon.Question) = DialogResult.Yes) Then Me.Close( ) End If

! Test de l'application 1. Exécutez l'application, puis cliquez sur Terminé. 2. Lorsqu'un message vous demande si vous voulez quitter l'application,

cliquez sur Non. Vous devez revenir à l'application.

3. Cliquez de nouveau sur Terminé, mais cette fois-ci choisissez Oui dans le message. L'application doit se fermer.


Leçon : Utilisation de structures de boucles conditionnelles

! Utilisation d�instructions For�Next

! Utilisation d�instructions For Each�Next

! Utilisation d�instructions Do�Loop

! Utilisation de l�instruction Exit


Il est probable que vous devrez répéter fréquemment l'exécution d'un bloc de code jusqu'à ce qu'une condition particulière soit remplie dans le programme que vous développez. Pour répéter l'exécution d'un bloc de code dans Visual Basic .NET, servez-vous des structures de boucles conditionnelles. Cette leçon explique comment utiliser les boucles conditionnelles pour décider de l'exécution du code et du moment de son exécution. Elle s'attache également à la prise de décision concernant l'utilisation d'une instruction Exit pour quitter une boucle.


! Utilisation d'instructions For�Next ! Utilisation d'instructions For Each�Next ! Utilisation d'instructions Do�Loop ! Utilisation de l'instruction Exit ! Application pratique : Élaboration de structures en boucle


! utiliser des instructions For�Next pour exécuter du code un nombre de fois déterminé ;

! utiliser des instructions For each�Next afin d'exécuter du code pour tous les éléments d'une collection ;

! utiliser des instructions Do�Loop pour déterminer si un bloc de code doit être exécuté en fonction d'une condition ;

! décider d'utiliser ou non une instruction Exit pour quitter immédiatement une boucle.

Introduction




Utilisation d'instructions For�Next

! À utiliser lorsque vous savez le nombre de fois quevous voulez répéter l�exécution du code

For NamePos = 0 to 4

MessageBox.Show(Names(NamePos))

Next

' Dans l�ordre inverse

For NamePos = 4 to 0 Step -1


Next

For NamePos = 0 to 4


Next

' Dans l�ordre inverse

For NamePos = 4 to 0 Step -1


Next


Si vous savez combien de fois une boucle doit être exécutée, utilisez une boucle For�Next. Une instruction For�Next répète un groupe d'instructions pendant un nombre de fois spécifié.

Une boucle For�Next est une boucle qui s'exécute un nombre de fois indiqué par un compteur de boucles. La valeur du compteur dans une boucle For�Next peut augmenter ou diminuer en fonction du pas positif ou négatif.

La syntaxe d'une instruction For�Next se développe comme suit :

For compteur = début To fin [Step pas] [instructions] [Exit For] Next [compteur]

Introduction

Syntaxe


Dans l'exemple suivant, une instruction For�Next est utilisée pour exécuter une boucle dans le contenu d'un petit tableau. Un message est utilisé pour afficher chaque nom à l'écran. Les noms sont ensuite réaffichés dans l'ordre inverse.

Dim NamePos as Integer Dim Names(4) As String Names(0) = "Bob" Names(1) = "Tina" Names(2) = "Robert" Names(3) = "Georges" Names(4) = "Greg" For NamePos = 0 to 4 MessageBox.Show(Names(NamePos)) Next ' Dans l'ordre inverse For NamePos = 4 to 0 Step -1 MessageBox.Show(Names(NamePos)) Next

Vous pouvez utiliser autant d'instructions For�Next que vous voulez dans une structure For�Next. L'ajout d'une ou plusieurs instructions For�Next à l'intérieur d'une autre instruction For�Next s'appelle imbrication.

Imaginez le scénario suivant : vous voulez créer plusieurs points avec des coordonnées X et Y incrémentées pour un jeu vidéo et vous voulez utiliser ces points pour assigner des positions aux graphiques.

La création de ces points requiert l'utilisation d'instructions imbriquées For�Next. Le code de l'exemple suivant crée trois versions de myPoint et neuf versions de otherPoint avec des valeurs X et Y incrémentées.

Private Sub CreatePoints( ) Dim x, y As Integer Dim myPoint(7) As Point Dim otherPoint(7) As Point For x = 1 To 3 myPoint(x).X += 1 myPoint(x).Y += 1 MessageBox.Show(myPoint(x).ToString) For y = 1 To 3 otherPoint(y).X += y + 1 otherPoint(y).Y += y + 2 MessageBox.Show(otherPoint(y).ToString) Next Next End Sub

Les boîtes de message dans ce code sont proposées comme un moyen d'affichage des valeurs mis à votre disposition si vous choisissez d'essayer ce code. Elles seraient inutiles dans le scénario précédent du jeu vidéo.

Exemple

Imbrication d'instructions For�Next

Remarque


Utilisation d'instructions For Each�Next

! Une collection est un ensemble d�objets regroupés auquel on fait référence en tant qu�unité. Par exemple :

" les éléments d�une zone de liste font partie d�une collection Items

" chaque formulaire possède une collection Controls représentanttous les contrôles du formulaire

! Les instructions For Each � Next sont utilisées pour effectuer des boucles parmi les éléments d�une collection

Sub LightBlueBackground (. . .)

Dim ThisControl As System.Windows.Forms.Control

For Each ThisControl In ThisForm.Controls

ThisControl.BackColor = System.Drawing.Color.LightBlue

Next ThisControl

End Sub

Sub LightBlueBackground (. . .)

Dim ThisControl As System.Windows.Forms.Control

For Each ThisControl In ThisForm.Controls

ThisControl.BackColor = System.Drawing.Color.LightBlue

Next ThisControl

End Sub


Une instruction For Each�Next exécute un bloc d'instructions pour chaque élément d'une collection ou d'un tableau.

Une collection est un ensemble d'objets regroupés auquel on fait référence en tant qu'unité.

Les collections vous permettent d'ajouter, de supprimer et de compter facilement des éléments. Grâce à un numéro d'index ou à des valeurs clés, vous pouvez ajouter des éléments avant ou après d'autres éléments. Les collections sont similaires aux tableaux, mais elles offrent des fonctionnalités que les tableaux n'ont pas, entre autres la facilité d'ajout, de suppression et de manipulation des éléments, mais aussi davantage de fonctionnalités pour les objets.

Vous pouvez créer vos propres collections et leur ajouter vos éléments personnels ou des éléments déjà existants. Un élément peut être n'importe quel type de données, y compris des objets ou des structures, voire d'autres objets de collection.

Microsoft .NET Framework tient à votre disposition de nombreuses collections prédéfinies. Les quelques exemples suivants sont tirés de ces collections :

! Lorsque vous ajoutez des éléments à une ListBox, vous utilisez la collection Items. Chaque élément ajouté fait partie de la collection.

! Chaque formulaire possède une collection Controls représentant tous les contrôles du formulaire. Grâce à l'index de la collection, vous pouvez obtenir une référence à un contrôle et ainsi effectuer des boucles dans la collection à l'aide d'instructions For Each�Next.

! Chaque feuille de calcul Microsoft Excel fait partie de la collection Worksheet d'Excel. Ainsi, vous pouvez écrire du code pour effectuer des boucles dans les feuilles de calcul et rassembler des données dans une nouvelle feuille.

Introduction

Définition des collections


La syntaxe d'une instruction For Each�Next se développe comme suit :

For Each elementvariable In collection ' Bloc d'instruction à exécuter pour chaque valeur ' de elementvariable Next [elementvariable]

Dans l'exemple suivant, l'instruction For Each�Next est utilisée pour effectuer une boucle dans l'ensemble des contrôles du formulaire et définir en bleu clair la couleur de l'arrière-plan de chacun de ces contrôles :

Sub LightBlueBackground (ByVal ThisForm As _ System.Windows.Forms.Form) Dim ThisControl As System.Windows.Forms.Control For Each ThisControl In ThisForm.Controls ThisControl.BackColor = System.Drawing.Color.LightBlue Next ThisControl End Sub

Syntaxe

Exemple


Utilisation d'instructions Do�Loop

! Do�Loop Until" Exécute le code dans la boucle, puis évalue la condition. Se répète

jusqu�à ce que la condition soit déclarée True

! Do Until�Loop" Exécute le code dans la boucle uniquement si la condition est

déclarée False ; elle se répète jusqu�à ce que l�expression en test soit déclarée True

! Do�Loop While" Exécute le code dans la boucle, puis évalue la condition. Se répète

jusqu�à ce que la condition soit déclarée False

! Do While�Loop" Exécute le code dans la boucle uniquement si la condition est

déclarée True ; elle se répète jusqu�à ce que l�expression en test soit déclarée False


Les instructions Do�Loop donnent la possibilité à votre application d'exécuter un bloc de code tandis qu'une condition est vraie ou jusqu'à ce qu'elle soit vraie. Les instructions Do�Loop sont utilisables lorsque vous connaissez la condition déterminant le moment où l'exécution de votre code doit s'arrêter.

Lorsque vous ajoutez le mot clé Until à une instruction Do�Loop, vous donnez l'ordre au programme d'effectuer une action jusqu'à ce qu'une condition soit vraie. Dans les instructions Do�Loop, une expression peut être évaluée à la fin ou au début de la boucle. Les structures en boucle évaluant les expressions en fin de boucle garantissent l'exécution du code de la boucle au moins une fois, tandis que celles qui évaluent les expressions en début de boucle peuvent être complètement ignorées ; tout dépend de la valeur initiale de l'expression.

Si vous voulez vérifier la condition en test avant d'exécuter le code, sachant que celui-ci doit s'exécuter jusqu'à ce qu'une condition soit vraie, utilisez l'instruction Do Until�Loop. Celle-ci exécute le code de la boucle uniquement si la condition correspond à False et se répète jusqu'à ce que l'expression en test soit déclarée True.

Si vous voulez vérifier la condition en test après l'exécution du code, sachant que celui-ci doit s'exécuter jusqu'à ce qu'une condition soit vraie, utilisez l'instruction Do�Loop Until. Cette instruction s'exécute et se répète jusqu'à ce que l'expression soit déclarée True.

La syntaxe Do Until�Loop s'exprime comme suit :

Do [Until condition] [instructions] [Exit Do] Loop

Introduction

Types d'instructions Do�Loop avec le mot clé Until

Syntaxe


La syntaxe Do�Loop Until s'exprime comme suit :

Do [instructions] [Exit Do] [instructions] Loop [While condition]

Dans l'exemple suivant illustrant l'utilisation de Do�Loop Until, le code s'exécute en boucle jusqu'à ce que l'utilisateur clique sur Non dans un message :

Dim LoopCount As Integer Do LoopCount = LoopCount + 1 Loop Until MessageBox.Show("Boucle ?", "Do... Loop Until", _ MessageBoxButtons.YesNo) = DialogResult.No

Le prochain exemple illustrant l'utilisation de Do Until�Loop trouve, dans un répertoire, tous les fichiers correspondant à une spécification de fichier. L'exemple utilise la fonction Dir pour renvoyer le premier nom de fichier correspondant au chemin spécifié. La fonction Dir est de nouveau appelée pour renvoyer tous les noms de fichier supplémentaires qui correspondent au chemin d'accès. Lorsqu'il n'y a plus de noms de fichier concordants, la condition Do Until�Loop est déclarée True et la longueur de la chaîne renvoyée par Dir est égale à zéro :

Dim Message As String Dim Filespec As String Dim Match As String Message = "Entrer une spécification de fichier." ' Obtenir l'extension du fichier Filespec = InputBox(Message) ' Trouver la première correspondance Match = Dir(Filespec) Do Until Len(Match) = 0 ' Afficher les fichiers concordants MessageBox.Show(Match) ' Trouver la correspondance suivante Match = Dir( ) Loop MessageBox.Show ("Il n'y a plus de fichiers correspondants.")

Exemples


Il est possible d'utiliser le mot clé While à la place de Until lorsque la condition pour que la boucle continue est True au lieu de False. Ainsi, les deux blocs de code suivants sont fonctionnellement équivalents.

Dim EndOfLoop As Boolean EndOfLoop = False Do ' . . . Loop Until EndOfLoop Dim EndOfLoop As Boolean EndOfLoop = False Do ' . . . Loop While Not(EndOfLoop)

Utilisation de While à la place de Until


Utilisation de l'instruction Exit

Do Until y = -1If x < 0 Then Exit Do

x = Sqrt (x)If y > 0 Then Exit Do

y = y + 3If z = 0 Then Exit Do

z = x / yLoop

Do Until y = -1If x < 0 Then Exit Do

x = Sqrt (x)If y > 0 Then Exit Do

y = y + 3If z = 0 Then Exit Do

z = x / yLoop

! À utiliser pour quitter les boucles Do ou For plus tôtlorsqu�une condition est remplie


Vous pouvez quitter une boucle pendant son exécution si une condition particulière est remplie. Utilisez l'instruction Exit pour sortir d'une boucle Do ou For. L'instruction Exit permet de quitter immédiatement n'importe quelle structure de décision, boucle ou procédure. Elle transfère aussitôt l'exécution à l'instruction suivant celle du dernier contrôle.

La syntaxe permettant d'utiliser l'instruction Exit dans une instruction Do�Loop se présente comme suit :

Exit Do

La syntaxe permettant d'utiliser l'instruction Exit dans une instruction For�Next se présente comme suit :

Exit For

L'exemple suivant regroupe plusieurs occurrences de l'instruction Exit à l'intérieur d'une instruction Do�Loop :

Do Until y = -1 If x < 0 Then Exit Do x = Sqrt (x) If y > 0 Then Exit Do y = y + 3 If z = 0 Then Exit Do z = x / y Loop

Introduction

Syntaxe

Exemple


Application pratique : Élaboration de structures en boucle

! Dans chacun des quatre scénarios, décidez de la structure en boucle à utiliserpour résoudre le problème

! Dans l�environnement de développement, utilisez des instructions For�Next pour créer une table de multiplication


Dans cette application pratique, vous déciderez des structures en boucle à exploiter dans quatre scénarios de programmation différents. Vous utiliserez ensuite des instructions For�Next pour créer une table de multiplication.

Vous avez créé une application de type caisse enregistreuse qui stocke le prix de chaque article acheté dans un tableau. Lorsque l'utilisateur a terminé ses achats, le code doit parcourir le tableau et calculer le total de tous les articles achetés. La taille du tableau variera avec le nombre d'articles achetés. Quelle est la structure en boucle optimale pour résoudre ce problème ?

For Each�Next. Une instruction For Each�Next se déplace parmi tous les éléments du tableau à condition que chaque élément de ce tableau soit une variable For Each. _______________________________________________________________

_______________________________________________________________

_______________________________________________________________

Scénario 1


Votre application contient l'équation mathématique y = x³+3. L'application doit calculer le résultat de cette équation pour des valeurs de x situées dans la plage de -100 à 100 par pas de 10. Quelle est la structure en boucle optimale pour résoudre ce problème ?

For�Next. For x = -100 To 100 Step 10

Next

Ce problème peut être également résolu à l'aide d'une instruction Do Loop�Until et d'une variable incrémentée, mais une instruction For�Next est plus lisible. ________________________________________________________________

________________________________________________________________

________________________________________________________________

________________________________________________________________

Votre application prend le contenu d'un fichier journal sur le disque dur d'un ordinateur et affiche ses données dans une zone de texte d'un formulaire. Le programme lit de façon séquentielle les lignes de données contenues dans le fichier journal. Le nombre de lignes de données contenues dans le fichier est inconnu, mais vous avez à votre disposition une fonction appelée EOF qui renvoie True lorsque la fin du fichier est atteinte. Quelle est la structure en boucle optimale pour résoudre ce problème ?

Do Until�Loop. Étant donné que le nombre de lignes contenues dans le fichier est inconnu, une instruction Do Until�Loop est idéale, surtout qu'une expression peut déterminer ici si la fin du fichier est atteinte. FileOpen(1, "C:\file.log", OpenMode.Input)

Do Until EOF(1)

TextBox1.Text=TextBox1.Text & Chr(13) & Chr(10) & _

LineInput(1)

Loop

FileClose(1)

________________________________________________________________

________________________________________________________________

________________________________________________________________

________________________________________________________________

________________________________________________________________

________________________________________________________________

Scénario 2

Scénario 3


Votre application utilise un objet City pour déterminer les valeurs des remises effectuées sur les ventes de divers articles de détail selon la ville dans laquelle ces marchandises sont achetées. Vous voulez afficher les remises associées à chaque ville dans une zone de liste.

Quelle est la structure en boucle optimale pour résoudre ce problème ?

For Each�Next. For Each City in CityCollection

ListBox.Items.Add(City.Discount)

Next

_______________________________________________________________

_______________________________________________________________

_______________________________________________________________

_______________________________________________________________

! Utilisation d'une instruction For�Next Dans cette section de l'application pratique, vous ouvrirez un nouveau projet dans lequel vous utiliserez une instruction For�Next pour créer une table de multiplication dans un formulaire. 1. Ouvrez un nouveau projet dans Visual Basic .NET. Utilisez le modèle de

Microsoft Windows® Application. Nommez le projet MultiplicationTable et définissez l'emplacement dans dossier_installation\Practices\Mod05\ MultiplicationTable.

2. Ajoutez une étiquette au formulaire et redimensionnez-la pour obtenir une largeur de 255 sur une hauteur de 190. Centrez l'étiquette dans le formulaire.

3. Définissez la propriété Font de l'étiquette sur Courrier New. 4. Créez un gestionnaire d'événements pour l'événement Form1_Load et

ajoutez le code suivant : Dim outerLoop, innerLoop As Integer Dim result As String ' Externe pour...la prochaine boucle For outerLoop = 1 To 10 ' Interne pour...la prochaine boucle For innerLoop = 1 To 10 result = result & " " & (outerLoop * innerLoop) Next innerLoop result = result & vbCrLf Next outerLoop 'Afficher le résultat dans l'étiquette Label1.Text = result

Scénario 4

Utilisation d'une instruction For�Next


5. Répondez aux questions suivantes avant d'exécuter l'application. a. Quelles sont les trois lignes de code définissant la boucle interne ?

For innerLoop = 1 To 10

result = result & " " & (outerLoop * innerLoop)

Next innerLoop

__________________________________________________________

__________________________________________________________

__________________________________________________________

b. Quelles seront les valeurs de outerLoop et innerLoop la deuxième fois que la boucle interne s'exécutera ? La valeur de outerLoop sera 1 ; celle de innerLoop 2. __________________________________________________________

__________________________________________________________

c. D'après vous, à quoi ressemblera le résultat dans l'étiquette une fois le code exécuté ? L'illustration suivante montre le contenu de l'étiquette dans l'application en cours.

__________________________________________________________

__________________________________________________________

6. Exécutez l'application pour vérifier votre réponse à la question 5.c. Une table de multiplication s'affiche dans l'étiquette du formulaire.

Les fichiers solution correspondant à cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod05\MultiplicationTable\ Solution.

Fichiers solution



! Utilisation d�expressionsconditionnelles

! Utilisation de structures de décision

! Utilisation de structures de boucles conditionnelles

Debugand Deploy

Écriturede code

Accès auxdonnées


Studio .NET

Débogage et déploiement

Créationd�une

interface


1. Quel est le résultat de l'expression conditionnelle suivante ? "PetitChien" > "GrosChat" L'expression renvoie True puisque P est supérieur à G.

2. Écrire une instruction de décision pour l'affichage d'un message prévenant que l'unité centrale est en surchauffe si la température de l'UC atteint ou dépasse 125 degrés. If temp >= 125 Then

MessageBox.Show("L'unité centrale est en surchauffe.")

End If

3. Quelle est la structure idéale pour effectuer des boucles dans des questions dont le nombre est connu ? La structure en boucle For�Next.


4. Quelle valeur doit contenir x pour que la boucle suivante se termine ? Do While x = True MessageBox.Show("Bonjour") ' Code pour changer la valeur de x Loop

False.

5. La variable OceanName doit contenir au choix Atlantique, Pacifique, Indien ou Arctique. Votre code doit affecter respectivement un numéro allant de 1 à 4 à la variable OceanNumber. Si un autre nom que les quatre noms préalablement définis est identifié, le code doit renvoyer un message avertissant de l'erreur. Écrire le code pour réaliser cette fonctionnalité. Select Case OceanName

Case "Atlantique"

OceanNumber = 1

Case "Pacifique"

OceanNumber = 2

Case "Indien"

OceanNumber = 3

Case "Arctique"

OceanNumber = 4

Case Else

MessageBox.Show("Nom d'océan non valide !")

End Select

Table des matières

Vue d'ensemble 1

Présentation multimédia : Validation des entrées de l'utilisateur 2

Leçon : Limitation des entrées de l'utilisateur 4

Leçon : Validation des données de champs 17

Leçon : Validation des données de formulaires 30


Atelier 6.1 : Validation des entrées de l'utilisateur 40

Module 6 : Validation des entrées de l'utilisateur


Module 6 : Validation des entrées de l'utilisateur iii

Notes de l'instructeur Ce module explique la façon dont la validation des entrées de l'utilisateur doit s'effectuer dans le champ et dans le formulaire. Les stagiaires apprendront à gérer les entrées de données non valides en produisant des messages d'erreur pour guider les utilisateurs à travers un processus de recherche d'erreur et de correction. Les stagiaires utiliseront les propriétés et les méthodes de contrôle afin de limiter les entrées de données et les valider.


! limiter le type de données pouvant être entré dans un champ ; ! tester la validité des entrées de l'utilisateur au niveau du champ et afficher

des messages destinés à aider l'utilisateur dans sa correction des données non valides ;

! définir des propriétés de contrôle pour spécifier l'ordre d'entrée des données, leur type et leur affichage lorsque l'application s'exécute ;

! valider les entrées de l'utilisateur au niveau du formulaire et guider les utilisateurs dans le processus de recherche et de correction des erreurs.


! Fichier Microsoft PowerPoint® 2560A_06.ppt ! Fichier d'animation multimédia 2560A_Validating_User.htm


! lire tous les documents de cours relatifs à ce module ; ! étudier la démonstration multimédia ; ! réaliser les applications pratiques et l'atelier ; ! utiliser les démonstrations dirigées.


Documents de cours

Préparation

iv Module 6 : Validation des entrées de l'utilisateur


Présentation multimédia : Validation des entrées de l'utilisateur Ce module commence par une animation multimédia permettant de jeter les bases des concepts et des tâches clés de ce module. Cette animation présente un scénario qui traite de la validation des entrées et explique comment implémenter cette validation au niveau du champ et du formulaire. Pour lancer cette animation, cliquez sur l'icône au centre de la diapositive de cette rubrique.

Leçon : Limitation des entrées de l'utilisateur Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon. Au fur et à mesure que vous présentez chaque rubrique, ouvrez Microsoft Visual Studio® .NET et exposez chacune des tâches à effectuer par les stagiaires dans l'application pratique.

Lancez cette discussion en insistant sur l'importance de la validation des entrées. Chaque fois que cela est possible, les développeurs doivent utiliser une technique de validation des entrées qui évite l'entrée de données incorrectes par les utilisateurs. Étudiez avec votre classe chaque règle mentionnée dans les notes du stagiaire et, dès que l'occasion se présente, illustrez ce principe par un exemple pour démontrer ce qui peut survenir lorsque les applications ne sont pas pourvues de code de validation.

Une des façons les plus simples d'assurer une validation est de choisir un contrôle qui fournisse intrinsèquement la validation dont l'application a besoin. Par exemple, si une application requiert l'entrée d'un oui ou d'un non dans un champ de données, utilisez un contrôle limitant les entrées de l'utilisateur à l'activation ou la désactivation, comme pour un RadioButton (Bouton radio) ou une CheckBox (case à cocher). Une autre manière d'éviter l'entrée de données incorrectes consiste à fournir une liste d'entrées valides dans un contrôle ListBox (zone de liste) ou ComboBox (zone de liste déroulante).

Démarrez Visual Studio .NET et enseignez quelques propriétés de validation intrinsèque de certains contrôles couramment utilisés.

Cette rubrique montre comment utiliser les propriétés de validation intrinsèque du contrôle TextBox. Pour concrétiser les effets de chaque propriété, ajoutez un contrôle TextBox à un formulaire, définissez les propriétés de PasswordChar et de MaxLength, puis exécutez le formulaire et entrez des données. Les stagiaires prendront peu à peu conscience de la facilité d'utilisation de la validation intrinsèque comparée à la création de leur propre code de validation.

Directives pour la validation des entrées de l'utilisateur

Présentation de la validation intrinsèque

Utilisation des propriétés TextBox

Module 6 : Validation des entrées de l'utilisateur v

Le contrôle Masked Edit est disponible dans les versions précédentes de Microsoft® Visual Basic® et offre toujours des techniques de validation utiles. Discutez de la façon dont les développeurs peuvent utiliser les masques pour afficher des repères visuels concernant le type de données en cours de saisie ou affiché. Ce contrôle est particulièrement utile pour les données à collecter dans un format particulier, tel que les numéros de téléphone ou les numéros de carte de crédit.

Démontrez chaque étape de l'utilisation d'un contrôle Masked Edit, comme affiché sur la diapositive. Les stagiaires devront maîtriser chacune de ces étapes pour réaliser correctement l'application pratique.

Dans cette application pratique, les stagiaires ouvriront un projet existant et ajouteront deux contrôles Masked Edit à un formulaire. Ils modifieront les propriétés du masque pour permettre à un utilisateur d'entrer son numéro de téléphone dans un contrôle et un montant en devises dans l'autre. Ils écriront le code permettant d'accéder aux données entrées par un utilisateur dans les contrôles et afficheront ces données dans un mode formaté et non formaté grâce aux propriétés FormattedText et ClipText. Une durée de 20 minutes environ est prévue pour cette application pratique.

Leçon : Validation des données de champs Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon. Cette leçon explique comment valider des données de champ et afficher des messages pour aider l'utilisateur à corriger les entrées de données non valides.

Expliquez que les fonctions booléennes sont utiles pour tester la validité des données entrées et agir en conséquence. Rappelez que les fonctions booléennes utilisent une condition spécifique pour évaluer une expression et qu'elles renvoient uniquement une valeur True ou False. Visual Basic .NET propose de nombreuses fonctions booléennes. Deux fonctions couramment utilisées sont détaillées sur la diapositive : IsNumeric et IsDate.

Il s'agit d'une des techniques de validation les plus utiles présentée dans ce module. Le composant ErrorProvider permet aux développeurs de prévenir discrètement l'utilisateur d'un problème et de lui proposer une solution. ErrorProvider présente quelques avantages sur les messages : non seulement l'utilisateur n'a pas de fenêtre à fermer pour pouvoir continuer, mais il peut consulter le message à tout moment en immobilisant le pointeur de la souris sur l'icône d'erreur tant que le problème n'est pas résolu. Si le message est refermé, le message d'erreur n'est plus consultable.

Enseignez aux stagiaires la façon dont ils peuvent ajouter un composant ErrorProvider à un formulaire et comment ils peuvent définir ses propriétés. Il est important qu'ils sachent utiliser la méthode SetError pour gérer les entrées de données non valides de chaque contrôle dans un formulaire.

Cette rubrique explique comment utiliser les deux méthodes de contrôle, Focus et SelectAll, pour amener les utilisateurs jusqu'à un contrôle contenant des données non valides. Ces méthodes peuvent épargner beaucoup de frustrations à l'utilisateur car aussitôt qu'une erreur de saisie est repérée par le code de validation, les méthodes se focalisent sur le contrôle dans lequel l'erreur est survenue et sélectionnent le texte à corriger. L'utilisation de ces méthodes est particulièrement utile lorsqu'elles sont combinées à un message aidant l'utilisateur à comprendre rapidement le problème.

Utilisation du contrôle Masked Edit

Application pratique : Utilisation du contrôle Masked Edit

Utilisation de fonctions booléennes

Utilisation du composant ErrorProvider

Réglage du focus sur les contrôles et le texte

vi Module 6 : Validation des entrées de l'utilisateur

Expliquez aux stagiaires qu'ils peuvent modifier les données entrées par un utilisateur pour s'assurer qu'elles s'affichent selon les exigences d'un format spécifique ou pour préparer leur intégration à une base de données. Par exemple, les utilisateurs peuvent remplacer une chaîne en minuscules par des caractères majuscules et vice-versa. Ceci peut se révéler utile pour la gestion des données qui ne sont pas entrées dans une zone de texte car elles sont transformables en majuscules ou en minuscules au moment de la création.

Visual Basic .NET met différentes fonctions à la disposition des stagiaires pour modifier par la programmation les entrées de l'utilisateur après leur saisie. Cette rubrique détaille l'utilisation des fonctions UCase et LCase.

Cette rubrique décrit comment utiliser les événements Validating et Validated fournis par tous les contrôles Microsoft Windows® Forms. Conseillez aux stagiaires de se référer à l'illustration dans le cours tandis que vous expliquez l'exemple de code sur la diapositive.

Dans cette application pratique, les stagiaires exploiteront l'événement Validating pour contrôler les données entrées par l'utilisateur, ils utiliseront le composant ErrorProvider pour avertir celui-ci d'une erreur et déclencheront l'événement Validated pour réinitialiser le fournisseur d'erreurs. Une durée de 20 minutes environ est prévue pour cette application pratique.

Leçon : Validation des données de formulaires Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon. Les stagiaires mettront en pratique les procédures et les concepts enseignés dans cette leçon en réalisant cet atelier.

Expliquez que très souvent les stagiaires devront effectuer la validation des entrées de l'utilisateur vers la fin du processus de saisie des données d'un formulaire. Cette manière de faire limite le nombre de messages d'erreur qu'un utilisateur doit résoudre et réduit les interruptions au minimum.

Certains aspects importants concernant la validation au niveau du formulaire doivent être examinés en cours. En premier lieu, les stagiaires doivent apprendre à fournir des repères visuels pour prévenir l'utilisateur que tous les champs obligatoires sont remplis. Par exemple, le bouton OK ou Envoyer du formulaire peut être désactivé tant que toutes les données requises ne sont pas entrées. Expliquez ensuite aux stagiaires qu'ils peuvent valider tous les champs d'un formulaire en même temps en écrivant tout le code de validation dans le bouton OK ou dans un autre bouton possédant la même fonctionnalité. Comme cela a été mentionné dans les leçons précédentes, les utilisateurs doivent pouvoir s'acquitter du processus de validation rapidement et facilement ; le code doit donc guider l'utilisateur vers le contrôle contenant les données non valides et sélectionner le texte à corriger.

Cette rubrique s'attache à l'attribution de la fonctionnalité des touches ENTRÉE et ÉCHAP à des boutons d'un formulaire Windows. Montrez aux stagiaires comment définir les propriétés AcceptButton et CancelButton pour associer des boutons spécifiques d'un formulaire à cette fonctionnalité. Précisez qu'en règle générale la propriété AcceptButton est affectée à un bouton OK ou Envoyer et la propriété CancelButton à un bouton Annuler ou Quitter.

Modification des entrées de l'utilisateur

Utilisation des événements de validation

Application pratique : Validation des données de champs

Validation de plusieurs champs d'un formulaire

Désignation des boutons d'acceptation et d'annulation

Module 6 : Validation des entrées de l'utilisateur vii

Le but intrinsèque de toute technique de sécurité utilisant l'authentification est de contrôler l'accès aux ressources protégées. Cette rubrique présente brièvement la question de la sécurité et propose quelques suggestions concernant les sources d'informations à consulter sur le sujet. Elle explique également comment obtenir et afficher l'identité de l'utilisateur Windows qui a ouvert une session. Faites remarquer aux stagiaires que la mise en �uvre de la sécurité dépasse la portée de ce cours et qu'ils trouveront d'autres cours et d'autres ouvrages sur le sujet comme Writing Secure Code et la documentation Visual Studio .NET.

Contrôle des acquis Les questions sont basées principalement sur la théorie et sur les procédures détaillées dans le module. Vous pouvez préférer la forme d'une discussion pour aborder ces questions afin que chacun profite des réponses.

1. Cette question teste l'aptitude des stagiaires à utiliser les propriétés de validation intrinsèque du contrôle TextBox. Vous pouvez également profiter de l'occasion pour réviser d'autres propriétés, comme MaxLength ou ReadOnly.

2. Commentez le fait qu'une des plus importantes caractéristiques du contrôle Masked Edit est d'éviter l'entrée de données non valides par les utilisateurs.

3. Insistez sur la grande utilité des capacités de validation intrinsèque fournies par les contrôles lors de la mise en �uvre d'une validation dans une application. Si vous avez le temps, profitez de l'occasion pour décrire les propriétés de validation intrinsèque disponibles dans d'autres contrôles.

4. Il s'agit d'une question simple pour tester la compréhension des stagiaires sur le fonctionnement de la propriété PasswordChar du contrôle TextBox. S'ils ne comprennent pas la façon dont cette propriété fonctionne, faites une démonstration dans l'environnement de développement.

5. Assurez-vous que les stagiaires sont capables d'écrire le code permettant de configurer un composant ErrorProvider. Pour cela, ils devront configurer plusieurs fois ces composants dans l'atelier.

6. Cette question vérifie la compréhension des étudiants concernant la validation en une seule fois de tous les champs d'un formulaire.

7. Si les stagiaires semblent hésiter, revoyez ensemble les différentes manières de mettre en �uvre la rétroaction de validation au niveau du formulaire. Dans l'atelier, ils placeront le code de validation pour un ensemble de contrôles apparentés dans l'événement Click traitant les valeurs.

Atelier 6.1 : Validation des entrées de l'utilisateur Avant de démarrer cet atelier, les stagiaires doivent s'assurer qu'ils ont réalisé toutes les applications pratiques et répondu à toutes les questions de contrôle des acquis. Les stagiaires devront être capable de mettre en pratique la plupart des connaissances qu'ils ont acquises dans les leçons et les applications pratiques pour réaliser cet atelier de façon satisfaisante.

Questions sur la sécurité

Module 6 : Validation des entrées de l'utilisateur 1

Vue d'ensemble

! Limitation des entrées de l'utilisateur

! Validation des données de champs

! Validation des données de formulaires

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


Au cours de ce module, vous apprendrez à valider les entrées d'un utilisateur au niveau d'un champ et d'un formulaire pour les applications que vous créez dans Microsoft Visual Basic® .NET. Vous découvrirez la façon de gérer les entrées de données non valides en produisant des messages d'aide pour guider les utilisateurs dans un processus de recherche d'erreur et de correction. Vous utiliserez les propriétés et les méthodes de contrôle pour limiter et valider les entrées de données.


! limiter le type de données pouvant être entré dans un champ ; ! tester la validité des entrées de l'utilisateur au niveau du champ et afficher

des messages destinés à aider l'utilisateur dans sa correction des données non valides ;

! définir des propriétés de contrôle pour spécifier l'ordre d'entrée des données, leur type et leur affichage lorsque l'application s'exécute ;

! valider les entrées de l'utilisateur au niveau du formulaire et guider les utilisateurs dans le processus de recherche et de correction des erreurs.

Introduction

Objectifs

2 Module 6 : Validation des entrées de l'utilisateur

Présentation multimédia : Validation des entrées de l'utilisateur


Cette animation présente un scénario traitant de la validation des entrées et de sa mise en �uvre au niveau du champ et du formulaire.

Dans la plupart des applications que vous créez, les utilisateurs entrent des informations qui doivent être traitées ou manipulées d'une manière ou d'une autre. En tant que développeur, vous pouvez écrire le code qui valide les entrées de l'utilisateur afin de garantir l'exécution correcte de votre application.

Supposons que vous disposez d'un formulaire de saisie de commande que les clients utilisent pour commander des articles sur un catalogue en ligne. Certains champs du Formulaire de saisie de commande doivent obligatoirement être renseignés, tandis que d'autres sont facultatifs. Quant au champ Quantité, il peut contenir uniquement des nombres. Dans ce formulaire, la validation des entrées doit s'effectuer à deux niveaux : au niveau des champs et au niveau du formulaire.

Pour opérer la validation au niveau des champs pour le champ Quantité, vous devez écrire le code derrière le contrôle TextBox afin de valider l'entrée de l'utilisateur et d'afficher le message approprié pour faciliter la saisie des données valides. Si l'utilisateur entre des données non valides dans le champ Quantité, un message apparaît afin de lui permettre de corriger l'erreur. Vous pouvez appeler le code de validation lorsque l'utilisateur tente de sortir du champ, comme l'indique cet exemple.

Pour opérer une validation au niveau des champs, vous devez écrire le code derrière le bouton Passer en revue la commande afin de vérifier que tous les champs obligatoires ont été renseignés et que le message approprié s'affiche si les données sont incomplètes.

Introduction

Script d'animation


Le code de validation derrière ce formulaire peut :

! vérifier que les champs Numéro d'article et Quantité sont renseignés ; ! vérifier que le champ Quantité est un champ numérique ; ! vérifier qu'une couleur a été sélectionnée dans la zone de liste déroulante

Couleur ; ! permettre à l'utilisateur d'annuler la commande.

Si l'utilisateur clique sur Passer en revue la commande sans avoir renseigné un champ obligatoire, un message apparaît et signale à l'utilisateur qu'il doit saisir les données requises. Après avoir entré des données valides dans tous les champs obligatoires puis cliqué sur Passer en revue la commande, l'utilisateur peut passer à l'étape suivante de la procédure de commande.

Lorsque vous créez l'interface utilisateur de vos applications, vous pouvez écrire le code qui permet de valider les entrées de l'utilisateur et d'afficher des messages destinés à faciliter la correction des données non valides.


Leçon : Limitation des entrées de l'utilisateur

! Directives pour la validation des entrées de l'utilisateur

! Présentation de la validation intrinsèque

! Utilisation des propriétés TextBox

! Utilisation du contrôle Masked Edit


Cette leçon décrit la façon dont vous devez limiter les entrées de l'utilisateur, définir des paramètres de formatage pour l'affichage des sorties et afficher des messages d'erreur qui expliquent comment corriger les entrées de données non valides.


! Directives pour la validation des entrées de l'utilisateur ! Présentation de la validation intrinsèque ! Utilisation des propriétés TextBox ! Utilisation du contrôle Masked Edit ! Application pratique : Utilisation du contrôle Masked Edit


! utiliser la validation intrinsèque pour les contrôles standard ; ! utiliser les propriétés de validation du contrôle TextBox ; ! limiter les entrées de l'utilisateur et formater les données à l'aide de masques

éditables dans un contrôle Masked Edit ; ! filtrer les caractères de masque dans un contrôle Masked Edit pour préparer

les données à leur intégration dans une base de données ; ! contrôler l'ordre dans lequel l'utilisateur entre des données dans les champs

d'un formulaire.

Introduction




Directives pour la validation des entrées de l'utilisateur

! Empêcher les utilisateurs d'entrer des données non valides lorsque cela est possible

! Guider les utilisateurs tout au long du processus de saisie des données valides

! Permettre aux utilisateurs d'entrer leurs donnéesquand et comme ils le souhaitent

! Penser aux implications liées à la validation lors de la conception de l'application

! Placer le code de validation à l'emplacement approprié selon le design de votre application

DirectivesDirectives


Dans la majeure partie des applications que vous créez, les utilisateurs entrent des informations que l'application doit ensuite traiter. Vous pouvez par exemple créer une application qui calcule le coût des marchandises vendues en se basant sur des valeurs de chiffre d'affaires et de frais entrées par un utilisateur. Il est donc important que les utilisateurs rentrent des données valides pour que l'application s'exécute correctement.

Lorsque vous écrivez vos applications, tenez compte des directives suivantes pour valider les entrées de l'utilisateur :

! Empêcher les utilisateurs d'entrer des données non valides lorsque cela est possible. Un des moyens les plus simples pour assurer la validation des entrées est de limiter les entrées de l'utilisateur à des données valides uniquement. Ainsi, la validation peut être accomplie à l'aide d'un contrôle ne permettant pas aux utilisateurs d'entrer autre chose que les données requises. Le contrôle DateTimePicker, par exemple, permet d'entrer uniquement des dates.

! Guider les utilisateurs tout au long du processus de saisie des données valides. Pour éviter de gêner les utilisateurs par des messages d'erreur trop nombreux, il est recommandé de concevoir votre code de validation pour qu'il s'exécute vers la fin du processus de remplissage du formulaire. Écrivez ce code de façon à ce que, si une erreur survient, l'utilisateur soit dirigé vers le champ contenant l'erreur et qu'un message s'affiche pour l'aider à la corriger.

! Permettre aux utilisateurs d'entrer leurs données quand et comme ils le souhaitent. Une application bien écrite guide les utilisateurs dans une saisie de données correcte chaque fois que cela est possible. Toutefois, elle leur permet de naviguer librement entre les champs du formulaire, sauf si les données d'un champ sont absolument nécessaires à un autre champ.

Introduction

Principes


! Penser aux implications liées à la validation lors de la conception de l'application. Chaque fois que vous implémentez un type de validation, vous devez réfléchir à la technique de validation à utiliser. Quelques-unes des tâches de validation les plus courantes consistent à vérifier que :

• les données entrées par un utilisateur sont numériques ;

• un nombre est compris dans une certaine plage de valeurs ;

• une date est valide ou est comprise dans une plage de dates ;

• tous les champs obligatoires sont remplis ;

• les numéros de carte de crédit ou les mots de passe correspondent aux entrées de la base de données ;

• un format ou une combinaison de conditions est présent, par exemple le format de la référence de pièce suivant : HW-999-5678.

! Placer le code de validation à l'emplacement approprié selon le design de votre application. Généralement, il doit être placé vers la fin du processus de remplissage du formulaire, mais il peut arriver parfois qu'il soit appliqué champ par champ. C'est le cas de la saisie obligatoire de données dans un champ du formulaire de commande qui doit être validé au moment de la saisie et donc avant la validation d'autres champs.

Il est également possible de valider des données au niveau de la frappe de touche. Pour plus d'informations sur la validation par la frappe de touches, recherchez les événements KeyPress, KeyDown et KeyUp dans la documentation Microsoft Visual Studio® .NET.

Remarque


Présentation de la validation intrinsèque

! Définition : Propriétés et méthodes intégrées au contrôle que vouspouvez utiliser pour restreindre et valider les entrées de l'utilisateur

! Contrôles courants qui offrent une validation intrinsèque :

ContrôleContrôleContrôle

RadioButtonRadioButtonTechnique de validationTechnique de validationTechnique de validation

Restreint les entrées à On ou OffRestreint les entrées à On ou Off

CheckBoxCheckBox Restreint les entrées à Checked ou UncheckedRestreint les entrées à Checked ou Unchecked

CheckedListBoxCheckedListBox Fournit une liste d'entrées validesFournit une liste d'entrées valides

ListBoxListBox Fournit une liste d'entrées valides (graphiques et texte)Fournit une liste d'entrées valides (graphiques et texte)

DateTimePickerDateTimePicker Restreint les entrées à des dates ou à des heuresRestreint les entrées à des dates ou à des heures

MonthCalendarMonthCalendar Restreint les entrées à une plage de datesRestreint les entrées à une plage de dates

TextBoxTextBox Définit des propriétés pour restreindre ou modifier les entréesDéfinit des propriétés pour restreindre ou modifier les entrées


Il existe des contrôles Visual Basic .NET qui limitent automatiquement les saisies utilisateurs pour les cas de restrictions les plus classiques. Vous économiserez du temps et des efforts en vous familiarisant avec les propriétés et les méthodes de ces contrôles.

La validation intrinsèque désigne un jeu de propriétés et de méthodes intégré au contrôle mis à votre disposition pour limiter et valider les entrées de l'utilisateur. La plupart des contrôles proposent une forme de validation intrinsèque. Par exemple, le contrôle DateTimePicker permet à l'utilisateur de sélectionner uniquement des dates et des heures.

Quelques contrôles courants offrant une validation intrinsèque sont décrits dans le tableau suivant.

Utiliser ce contrôle�

Pour ce type de données�

Technique de validation intrinsèque

DateTimePicker Dates et heures Limite les entrées à des dates ou à des heures

MonthCalendar Plage de dates Limite les entrées à une plage de dates

CheckedListBox

ComboBox

DomainUpDown

NumericUpDown

Éléments dans une liste Propose une liste d'entrées valides

ListBox

ListView

Élements dans une liste avec des graphiques et du texte

Propose une liste d'entrées valides

Introduction

Définition

Contrôles possédant des propriétés de validation intrinsèque


(suite) Utiliser ce contrôle�

Pour ce type de données�

Technique de validation intrinsèque

CheckedListBox

CheckBox

RadioButton

TrackBar

Plage de valeurs Limite les valeurs à une liste, une plage ou une échelle prédéfinie

TextBox

RichTextBox

LinkLabel

Conditions spéciales liées à du texte

Limite et modifie les entrées de données dans les zones de texte et les étiquettes

OpenFileDialog

SaveFileDialog

PrintDialog

Boîtes de dialogue Limite les entrées à des noms de chemin d'accès et des noms de fichier valides

Utilisez le contrôle DateTimePicker pour autoriser les utilisateurs à sélectionner une date. Les propriétés MinDate et MaxDate vous permettent de définir une plage de dates acceptable. L'exemple suivant montre comment accéder à la date et au jour de la semaine que l'utilisateur a sélectionnés à l'aide du contrôle.

Private Sub Button1_Click(...) MessageBox.Show("La date sélectionnée est " & _ DateTimePicker1.Value) MessageBox.Show("La jour de la semaine est " & _ DateTimePicker1.Value.DayOfWeek.ToString) End Sub

Utilisez le contrôle TrackBar pour autoriser les utilisateurs à définir des valeurs sur une échelle en déplaçant un pointeur le long de celle-ci. L'utilisation de ce contrôle évite aux utilisateurs d'avoir à choisir une valeur numérique précise. L'exemple suivant affiche la valeur d'un contrôle TrackBar dans une instruction MessageBox. Les contrôles Button et TrackBar sont placés dans le formulaire.

Private Sub Button1_Click(...) MessageBox.Show(TrackBar1.Value) End Sub

Exemple de DateTimePicker

Exemple de TrackBar


Utilisez les contrôles OpenFileDialog, SaveFileDialog et PrintDialog pour limiter les entrées de l'utilisateur à des noms de chemin d'accès et des noms de fichier valides.

L'exemple suivant crée un contrôle OpenFileDialog. Il définit plusieurs propriétés et affiche la boîte de dialogue à l'aide de la méthode ShowDialog. Lorsque le code s'exécute, il affiche tout d'abord les fichiers de l'utilisateur du répertoire C:\Société\Données de projet ; toutefois l'utilisateur peut parcourir normalement l'arborescence dans la boîte de dialogue. Supposez ici que le répertoire affiché existe, que le formulaire présente un contrôle Button et que l'espace de noms System.IO a été ajouté au formulaire. (L'espace de noms System.IO permet la lecture et l'écriture de fichiers ou d'un objet de flux.)

Protected Sub Button1_Click(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles Button1.Click Dim myStream As Stream Dim openFileDialog1 As New OpenFileDialog( ) openFileDialog1.InitialDirectory = _ "c:\Company\Project Data" openFileDialog1.Filter = "txt files (*.txt)|*.txt" & _ "|Tous les fichiers (*.*)|*.*" openFileDialog1.FilterIndex = 2 openFileDialog1.RestoreDirectory = True If openFileDialog1.ShowDialog( ) = DialogResult.OK Then myStream = openFileDialog1.OpenFile( ) If Not(myStream Is Nothing) Then ' Insérer le code pour lire le flux ici myStream.Close( ) End If End If End Sub

Exemple d'utilisation de boîtes de dialogue


Utilisation des propriétés TextBox

! Vous pouvez utiliser les propriétés ci-dessous pour restreindre ou modifier les entrées utilisateur des contrôles TextBox :

ContrôleContrôleContrôle Technique de validationTechnique de validationTechnique de validation

PasswordCharPasswordChar Cache ou masque les caractères entrés dans une zone de texte

Cache ou masque les caractères entrés dans une zone de texte

MaxLengthMaxLength Définit un nombre maximal de caractères à entrer dans unezone de texte

Définit un nombre maximal de caractères à entrer dans unezone de texte

ReadOnlyReadOnly Fournit une réponse prédéterminée valideFournit une réponse prédéterminée valide

CharacterCasingCharacterCasing Définit tous les caractères d'une zone de texte en majuscules ou en minuscules

Définit tous les caractères d'une zone de texte en majuscules ou en minuscules


Vous pouvez utiliser les propriétés de validation intrinsèque du contrôle TextBox pour limiter et valider des entrées de l'utilisateur dans des zones de texte. Vous pouvez, par exemple, masquer ou cacher les caractères entrés dans une zone de texte ou spécifier un nombre maximal de caractères.

Dans un contrôle TextBox, vous pouvez définir les propriétés de validation suivantes pour limiter ou valider les entrées de l'utilisateur au moment de la création :

! PasswordChar La propriété PasswordChar vous permet de cacher (ou masquer) des caractères entrés dans une zone de texte. Par exemple, en définissant la propriété PasswordChar sur astérisque (*), l'utilisateur ne verra que des astérisques dans la zone de texte. Cette technique est souvent utilisée pour cacher des mots de passe dans les boîtes de dialogue de connexion. Bien que n'importe quel caractère puisse être choisi, la plupart des applications Microsoft Windows® utilisent l'astérisque (*). La propriété PasswordChar n'a aucune incidence sur la propriété Text ; cette dernière contient exactement ce que le développeur tape dans la fenêtre Propriétés ou définit dans le code.

! MaxLength La propriété MaxLength peut être utilisée pour définir un nombre maximal de caractères à entrer dans une zone de texte. Le système émet un signal sonore lorsque l'utilisateur essaie de taper plus de caractères que le nombre spécifié dans la propriété MaxLength.

Introduction

Propriétés de validation du contrôle TextBox


! ReadOnly Vous pouvez limiter toutes les entrées de données dans un contrôle TextBox en définissant la propriété ReadOnly sur True. Lorsque cette propriété est définie sur True, les utilisateurs peuvent afficher le texte dans la zone mais ils ne peuvent pas le modifier.

! CharacterCasing Utilisez la propriété CharacterCasing pour modifier la casse des caractères en fonction des besoins de votre application. Par exemple, si vous voulez mettre en place une stratégie sur les mots de passe, vous pouvez transformer en minuscules ou en majuscules la casse de tous les caractères entrés dans un contrôle TextBox utilisé pour l'entrée des mots de passe.

Après avoir ajouté un contrôle TextBox à un formulaire, vous pouvez définir ses propriétés de validation au moment de la création.

! Définition des propriétés du contrôle TextBox au moment de la création • Dans la fenêtre Propriétés du contrôle TextBox, repérez les propriétés de

validation voulues et définissez leurs valeurs.

Dans Visual Basic .NET, vous pouvez définir l'ordre de tabulation des contrôles visuellement.

! Définition de l'ordre de tabulation d'un contrôle 1. Dans le menu Affichage, cliquez sur Ordre de tabulation.

Vous pouvez voir l'ordre de tabulation du formulaire. Un nombre représentant la propriété TabIndex apparaît dans le coin supérieur gauche de chaque contrôle.

2. Cliquez sur les contrôles de façon séquentielle pour établir l'ordre de tabulation correct. Vous pouvez définir la position d'un contrôle sur n'importe quelle valeur supérieure ou égale à zéro dans l'ordre de tabulation.

3. Lorsque l'ordre est défini, cliquez sur Ordre de tabulation dans le menu Affichage pour quitter ce mode.

Les contrôles ne pouvant pas recevoir de focus, autres que des contrôles désactivés ou invisibles, ne possèdent pas de propriété TabIndex et ne sont pas inclus dans l'ordre de tabulation. Lorsque l'utilisateur appuie sur la touche TAB, ces contrôles sont ignorés.

Définition des propriétés de validation intrinsèque

Définition de l'ordre de tabulation

Remarque


Utilisation du contrôle Masked Edit

ProcédureProcédureProcédure

Ajout du contrôle Masked Edit à la boîte à outilsAjout du contrôle Masked Edit à la boîte à outils

Ajout d'un contrôle Masked Edit à un formulaireAjout d'un contrôle Masked Edit à un formulaire

Définition des propriétés du contrôleDéfinition des propriétés du contrôle

Accès aux données entrées par l'utilisateur et miseen formeAccès aux données entrées par l'utilisateur et miseen forme


Vous pouvez utiliser le contrôle Masked Edit pour vous assurer que les utilisateurs entrent des données valides et pour formater les sorties de données en fonction des exigences de votre application. Ce contrôle fournit des repères visuels sur le type de données en cours de saisie ou d'affichage. Dans le cas d'un masque contenant un symbole #, l'utilisateur peut entrer uniquement un nombre à la place de ce caractère.

Pour utiliser le contrôle Masked Edit, vous devez effectuer les opérations suivantes :

1. Ajouter le contrôle Masked Edit à la boîte à outils. 2. Placer un contrôle Masked Edit dans un formulaire. 3. Définir les propriétés du contrôle Masked Edit. 4. Accéder aux données entrées par l'utilisateur et les formater.

! Ajout du contrôle Masked Edit à la boîte à outils 1. Ouvrez Visual Studio .NET. 2. Dans le menu Outils, cliquez sur Personnaliser la boîte à outils.

La boîte de dialogue Personnaliser la boîte à outils s'affiche. 3. Dans l'onglet Composants COM de cette boîte de dialogue, activez la case

à cocher Microsoft Masked Edit Control, version 6.0 puis cliquez sur OK. Le contrôle Masked Edit apparaît au bas de l'onglet affiché à l'écran, dans la boîte à outils.

Le contrôle Masked Edit se comporte généralement comme un contrôle de zone de texte classique bénéficiant de propriétés améliorées pour masquer les entrées et formater les sorties. Vous pouvez ajouter le contrôle Masked Edit à un formulaire comme vous ajoutez n'importe quel autre contrôle de boîte à outils.

Introduction

Ajout du contrôle Masked Edit à la boîte à outils

Ajout d'un contrôle Masked Edit à un formulaire


Les propriétés définissables pour implémenter la fonctionnalité du contrôle Masked Edit englobent notamment :

! La propriété Mask Vous pouvez définir les masques de saisie au moment de la création ou de l'exécution. Le contrôle opère une distinction entre les caractères numériques et alphabétiques lors de la validation, mais il ne peut pas vérifier la validité du contenu, par exemple si le mois ou l'heure de la journée est correct. Certains caractères usuels à votre disposition dans les masques de saisie figurent dans le tableau suivant.

Caractère Description

# Espace réservé aux chiffres (saisie obligatoire).

9 Espace réservé aux chiffres (saisie facultative).

? Espace réservé aux caractères alphabétiques : a-z ou A-Z (saisie facultative).

A Espace réservé aux caractères alphanumériques (saisie obligatoire).

a Espace réservé aux caractères alphanumériques (saisie facultative).

\ Utilisé dans un masque de saisie pour indiquer qu'un littéral suit. Par exemple, pour afficher un espace dans un masque vous taperez un espace après le caractère \.

Le tableau suivant regroupe des exemples de masques de saisie utilisables au moment de la création. Masque Description

#####-9999 Code postal à neuf chiffres. Exemple : 98765-1234, avec les quatre derniers chiffres facultatifs.

(###)AAA-AAAA Numéro de téléphone avec l'indicatif de zone. Exemple : (123)555-0100, avec les sept derniers caractères alphabétiques ou numériques obligatoires.

Si vous écrivez une application d'envergure internationale, faites attention à ne pas utiliser des formats de masques spécifiques à un pays ou à une région en particulier, comme l'exemple du code postal américain dans le tableau précédent.

! Propriété TabIndex Utilisez cette propriété pour définir l'ordre dans lequel les utilisateurs doivent entrer des données dans plusieurs contrôles Masked Edit. Un index de tabulation peut être composé de n'importe quel entier valide supérieur ou égal à zéro. Les nombres inférieurs se situent plus haut dans l'index de tabulation.

! Propriété Format La propriété Format définit le format à utiliser pour l'affichage et l'impression du contenu d'un contrôle, comme les nombres, les dates, les heures et le texte. Faites votre choix parmi plusieurs formats standard proposés dans la fenêtre Propriétés du contrôle Masked Edit ou créez votre propre format personnalisé.

Définition des propriétés

Remarque


! Propriété FormattedText La propriété FormattedText renvoie les données entrées par l'utilisateur avec les caractères littéraux spécifiés pour le masque. Cette propriété n'est pas disponible au moment de la création et elle est en lecture seule pendant l'exécution.

! Propriété ClipText La propriété ClipText renvoie le texte dans le contrôle Masked Edit en excluant les caractères littéraux dans le masque de saisie. Cette propriété est particulièrement importante lors de la mise en �uvre d'un contrôle Masked Edit avec une base de données. Cette propriété n'est pas disponible au moment de la création et elle est en lecture seule pendant l'exécution.

Le code suivant indique comment accéder aux données entrées par l'utilisateur dans un contrôle Masked Edit et comment les afficher dans un mode formaté et non formaté. Un contrôle Masked Edit nommé AxMaskEdBox1 a été placé dans le formulaire.

MessageBox.Show(AxMaskEdBox1.FormattedText) MessageBox.Show(AxMaskEdBox1.ClipText)

« Ax » est utilisé dans les conventions d'affectation de noms pour signaler les contrôles ActiveX®.

Exemple

Remarque


Application pratique : Utilisation du contrôle Masked Edit

Ajoutez le contrôle Masked Edit à un formulaire

Modifiez la propriété Mask

Modifiez la propriété Format

Accédez aux données utilisateur et affichez-les

Ajoutez le contrôle Masked Edit à la boîte à outils


Dans cette application pratique, vous ouvrirez un projet existant et ajouterez deux contrôles Masked Edit à un formulaire. Vous modifierez les propriétés du masque pour permettre à un utilisateur d'entrer un numéro de téléphone dans un contrôle et un montant en devises dans l'autre. Vous écrirez ensuite le code permettant l'accès aux données entrées par l'utilisateur dans le contrôle Masked Edit et leur affichage dans un mode formaté et non formaté.

! Ouverture du code de démarrage de l'application pratique 1. Ouvrez le fichier MaskedEdit.sln situé dans le dossier dossier_installation\

Practices\Mod06\MaskedEdit\Starter. 2. Remarquez la présence de deux boutons dans Form1.

! Ajout du contrôle Masked Edit à la boîte à outils 1. Vérifiez que l'onglet Windows Forms est sélectionné dans la boîte à outils. 2. Dans le menu Outils, cliquez sur Personnaliser la boîte à outils. 3. Dans l'onglet Composants COM, activez la case à cocher Microsoft

Masked Edit Control, version 6.0 puis cliquez sur OK. Le contrôle Masked Edit est ajouté à l'onglet Windows Forms de la boîte à outils, comme illustré ci-dessous :

! Ajout de deux contrôles Masked Edit à Form1 • Placez deux contrôles MaskEdBox dans le formulaire, un à gauche de

chaque bouton existant. Élargissez ces contrôles pour qu'ils puissent contenir un numéro de téléphone (format États-Unis).

Introduction

Instructions


! Définition des propriétés du contrôle Masked Edit • Dans la fenêtre Propriétés, définissez les propriétés de ces contrôles, comme

stipulé dans le tableau ci-dessous.


AxMaskEdBox1 Name PhoneAxMaskedEdit

TabIndex 0

Mask (###)AAA-AAAA

AxMaskEdBox2 Name AmountAxMaskedEdit

TabIndex 1

Mask #,##0.00 €

Format #,##0.00 €;(#,##0.00 €)

Le format défini dans cette procédure, #,##0.00 �, est approprié lorsque les règles commerciales requièrent des entrées de données arrondies à deux chiffres après la virgule. Pour les saisies exemptes de ce genre de condition, le format sera ##,###.## �.

! Affichage des données entrées dans les contrôles Masked Edit 1. Dans le gestionnaire d'événements Button1_Click, ajoutez le code suivant

pour afficher le numéro de téléphone entré par l'utilisateur sous la forme d'un texte formaté et non formaté : MessageBox.Show(PhoneAxMaskedEdit.FormattedText) MessageBox.Show(PhoneAxMaskedEdit.ClipText)

2. Dans le gestionnaire d'événements Button2_Click, ajoutez le code suivant

pour afficher le montant en devises entré par l'utilisateur sous la forme d'un texte formaté et non formaté : MessageBox.Show(AmountAxMaskedEdit.FormattedText) MessageBox.Show(AmountAxMaskedEdit.ClipText)

! Vérification de votre travail 1. Exécutez l'application. 2. Tapez des données dans la zone Numéro de téléphone. Pour contrôler le

fonctionnement du contrôle Masked Edit, essayez de taper des caractères alphabétiques dans les trois premiers espaces réservés du masque.

3. Tapez des données non valides dans la zone Montant, puis tapez des données numériques dans ce même champ.

4. Cliquez sur Button1 et remarquez la différence entre les données affichées avec la propriété Formatted Text et celles affichées avec la propriété ClipText.

5. Cliquez sur Button2 et examinez les données qui s'affichent. 6. Quittez Visual Studio .NET.

Les fichiers solution correspondant à cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod06\MaskedEdit\Solution.

Remarque

Fichiers solution


Leçon : Validation des données de champs

! Utilisation de fonctions booléennes

! Utilisation du composant ErrorProvider

! Réglage du focus sur les contrôles et le texte

! Modification des entrées de l'utilisateur

! Utilisation des événements de validation


Dans bien des cas, vous voudrez valider des données au fur et à mesure qu'elles sont entrées par l'utilisateur dans les champs d'un formulaire. Dans cette leçon, vous apprendrez à valider des données dans des champs et à déclencher des messages d'aide à destination de l'utilisateur pour qu'il corrige certaines données non valides.


! Utilisation de fonctions booléennes ! Utilisation du composant ErrorProvider ! Réglage du focus sur les contrôles et le texte ! Modification des entrées de l'utilisateur ! Utilisation des événements de validation ! Application pratique : Validation des données de champs


! utiliser des fonctions booléennes telles que IsNumeric pour valider les entrées de l'utilisateur ;

! utiliser le composant ErrorProvider pour appliquer une rétroaction de validation à chaque contrôle du formulaire ;

! définir un focus sur un contrôle ou un texte spécifiques pour que l'utilisateur puisse corriger les données erronées ;

! modifier les entrées de l'utilisateur afin de les préparer à l'affichage ou à leur intégration dans une base de données ;

! utiliser les événements Validating et Validated pour définir une validation au niveau du champ.

Introduction




Utilisation de fonctions booléennes

ExempleExemple

Fonctions booléennes courantesFonctions booléennes courantes

If IsNumeric(TextBox1.Text) Then

MessageBox.Show("La zone de texte contient un nombre.")

End If

If IsNumeric(TextBox1.Text) Then

MessageBox.Show("La zone de texte contient un nombre.")

End If

FonctionFonctionFonction DescriptionDescriptionDescription

IsNumericIsNumeric Renvoie une valeur booléenne qui indique si uneexpression est reconnue en tant que nombre

Renvoie une valeur booléenne qui indique si uneexpression est reconnue en tant que nombre

IsDateIsDate Renvoie une valeur booléenne qui indique si uneexpression évalue une date valide

Renvoie une valeur booléenne qui indique si uneexpression évalue une date valide


Vous pouvez parfois avoir besoin de tester une variable pour déterminer le type de données qu'elle contient et agir en conséquence. Ainsi, vous pouvez utiliser une fonction booléenne pour tester les données entrées par un utilisateur dans un champ date et déterminer s'il s'agit d'une date ou d'une chaîne à convertir en date.

Une fonction booléenne évalue une expression selon une condition posée et renvoie une valeur True ou False.

Visual Basic .NET propose de nombreuses fonctions booléennes. Deux des fonctions les plus connues sont présentées dans l'illustration précédente, mais vous pouvez en utiliser d'autres comme IsError et IsNothing.

Utilisez la fonction IsNumeric pour vérifier si la saisie de l'utilisateur est une valeur numérique. La fonction IsNumeric renvoie une valeur True si l'argument est numérique. Sinon, elle renvoie False.

Le code suivant renseigne sur la façon d'utiliser une fonction IsNumeric pour vérifier si la valeur est numérique et pour afficher un message informant du résultat de cette opération. Il existe un contrôle TextBox nommé ValueTextBox dans le formulaire de l'exemple.

Private Sub EvaluateInput( ) Dim InputValue As String InputValue = ValueTextBox.Text If IsNumeric(InputValue) Then MessageBox.Show(InputValue & " est un nombre.") Else MessageBox.Show(InputValue & " n'est pas un nombre.") End If End Sub

Introduction

Définition

Fonctions booléennes courantes

Exemple


Utilisation du composant ErrorProvider

! Ajout d'un composant ErrorProvider à un formulaire" Disponible sous l'onglet Windows Forms de la boîte à outils

! Appel de la méthode SetError" Le premier paramètre spécifie l'emplacement de l'icône et le second, le

message d'erreur à afficher :

" Si l'utilisateur entre des données non valides, une icône d'erreur apparaît sur le formulaire :

ErrorProvider1.SetError (Textbox1, "Veuillez entrer une date valide.")

ErrorProvider1.SetError (Textbox1, "Veuillez entrer une date valide.")


Le composant ErrorProvider vous permet d'avertir discrètement l'utilisateur d'un problème tout en lui donnant une solution pour le résoudre. Ce système comporte des avantages comparé aux messages : l'utilisateur n'a pas besoin de fermer une fenêtre pour poursuivre sa tâche et, tandis que la fenêtre a disparu, le message d'erreur est toujours visible.

Le composant ErrorProvider est disponible dans l'onglet Windows Forms de la boîte à outils. Vous pouvez l'ajouter à un formulaire de la même manière que vous ajoutez d'autres contrôles de la boîte à outils. Une fois qu'il est ajouté, vous pouvez l'utiliser tout seul pour gérer les messages de validation de tous les contrôles du formulaire. L'utilisateur immobilise simplement le pointeur de la souris sur l'icône pour consulter votre message d'erreur.

La méthode clé du composant ErrorProvider est la méthode SetError qui détermine la chaîne du message d'erreur et l'emplacement où l'icône d'erreur doit apparaître.

Les propriétés clés du composant ErrorProvider sont ContainerControl et Icon. Utilisez la propriété ContainerControl pour spécifier le conteneur approprié (généralement le formulaire Windows) afin que le composant ErrorProvider puisse afficher une icône d'erreur dans le formulaire. Lorsque le composant est ajouté dans le Concepteur Windows Forms, la propriété ContainerControl est automatiquement définie sur le formulaire contenant. Si vous ajoutez le composant au code, vous devez vous-même le définir. Le cas échéant, utilisez la propriété Icon pour remplacer l'icône par défaut par une icône d'erreur personnalisée.

Introduction

Ajout d'un composant ErrorProvider à un formulaire

Méthode SetError

Propriétés clés


Le composant ErrorProvider permet d'afficher une icône d'erreur lorsque l'utilisateur entre des données non valides.

! Affichage d'une icône d'erreur lorsque l'utilisateur entre des données non valides

1. Ajoutez un composant ErrorProvider au formulaire contenant les contrôles à valider.

2. Ajoutez du code au gestionnaire d'événements Click du contrôle dans lequel vous voulez permettre une rétroaction de validation, ici le bouton ConfirmDate. Le code suivant illustre l'appel de la méthode SetError pour un contrôle TextBox nommé HireDate. Le premier argument de la méthode SetError spécifie le contrôle auquel associer l'icône d'erreur si l'utilisateur entre des données non valides. Le second argument précise le texte d'erreur à afficher. Private Sub ConfirmDate_Click(...) If Not IsDate(HireDate.Text) Then ErrorProvider1.SetError(HireDate, _ "Veuillez entrer une date valide.") Else ' Effacer l'erreur ErrorProvider1.SetError(HireDate, "") End If End Sub

Vous devez effacer le message d'erreur du composant ErrorProvider entre chaque tentative de correction de l'utilisateur et avant que ce composant puisse être utilisé par un autre contrôle.

Utilisation de ErrorProvider

Remarque


Réglage du focus sur les contrôles et le texte

! Pour quelles raisons définir le focus ?

" Lorsqu'un contrôle possède le focus, l'utilisateur peut y entrer des données à l'aide de la souris ou du clavier

" Lorsqu'un utilisateur entre des données non valides, vous pouvezconserver le focus sur le contrôle approprié jusqu'à ce que l'erreursoit corrigée

! Exemples

" Pour définir le focus sur un contrôle TextBox, utilisez la méthodeFocus :

" Pour sélectionner tout le texte d'un contrôle, utilisez SelectAll :TextBox1.Focus( )TextBox1.Focus( )

TextBox1.SelectAll( )TextBox1.SelectAll( )


Lorsqu'un contrôle est doté d'un focus, l'utilisateur peut entrer des données pour ce contrôle à l'aide de la souris ou du clavier. Par exemple, dans un formulaire Visual Basic .NET contenant plusieurs zones de texte, seule la zone de texte dotée du focus peut recevoir une saisie au clavier. Si un utilisateur entre des données non valides, vous pouvez maintenir le focus par programmation sur le contrôle approprié tant que les données valides ne sont pas entrées.

Utilisez la méthode Focus pour régler le focus sur un contrôle en le programmant et servez-vous de la méthode SelectAll pour sélectionner tout le texte contenu dans le contrôle.

Certains contrôles, tels que Panel, GroupBox, PictureBox, ProgressBar, Splitter, Label et LinkLabel ne peuvent pas recevoir de focus. Il en va de même pour les contrôles invisibles au moment de l'exécution, comme le contrôle Timer.

Le code suivant exemplifie la façon d'utiliser les méthodes Focus et SelectAll pour maintenir le focus sur un contrôle TextBox jusqu'à la saisie correcte de données par l'utilisateur. Il montre également l'utilisation conjointe de ces méthodes avec le composant ErrorProvider pour fournir un message d'aide capable de guider l'utilisateur dans sa correction des données non valides.

Private Sub ConfirmDate_Click(...) If Not IsDate(TextBox1.Text) Then ErrorProvider1.SetError(TextBox1, _ "Veuillez entrer une date valide.") TextBox1.Focus( ) TextBox1.SelectAll( ) Else ' Effacer l'erreur ErrorProvider1.SetError(TextBox1, "") End If End Sub

Introduction

Méthodes

Remarque

Exemple


Il se peut que vous ayez besoin de valider des données lorsque l'utilisateur ne clique pas sur un bouton ou sur tout autre contrôle déclencheur. Utilisez les événements Enter ou Leave pour ce type de validation. Vous pouvez également les utiliser lorsqu'un contrôle particulier nécessite des données précises avant qu'un autre contrôle puisse être validé. Les événements Enter et Leave surviennent lorsqu'un objet reçoit un focus ou le perd. La majeure partie des contrôles prennent ces événements en charge. Les événements équivalents dans la classe Form sont Activated et Deactivate. Pour éviter la création d'une boucle sans fin, n'utilisez pas la méthode Focus dans un ou plusieurs événements Leave.

L'exemple suivant illustre la façon d'utiliser l'événement Enter pour assurer l'affichage de conseils lorsque l'utilisateur se déplace vers un champ nécessitant une saisie de données. Le formulaire de l'exemple contient les deux contrôles Label et TextBox.

Private Sub FirstNameTextBox_Enter(...) GuidanceLabel.Text = "Veuillez taper votre prénom." End Sub

L'exemple suivant montre comment utiliser l'événement Leave pour valider le champ unique que l'utilisateur quitte. Le formulaire de l'exemple contient un contrôle TextBox.

Private Sub FirstNameTextBox_Leave(...) If IsNumeric(FirstNameTextBox.Text) Then ' Le code à suivre se place ici Else MessageBox.Show("Veuillez utiliser des caractères numériques.") End If End Sub

Événements Enter et Leave

Exemples


Modification des entrées de l'utilisateur

! Vous pouvez modifier des entrées de l'utilisateur àl'aide des fonctions suivantes :

! ExempleDim LowerCase, UpperCase As String LowerCase = " Bonjour le monde 1234" ' Chaîne à convertirUpperCase = UCase(LowerCase) ' Retourne "BONJOUR LE MONDE

1234"

Dim LowerCase, UpperCase As String LowerCase = " Bonjour le monde 1234" ' Chaîne à convertirUpperCase = UCase(LowerCase) ' Retourne "BONJOUR LE MONDE

1234"

FonctionFonctionFonction DescriptionDescriptionDescription

UCaseUCase Convertit une chaîne spécifiée en majusculesConvertit une chaîne spécifiée en majuscules

LCaseLCase Convertit une chaîne spécifiée en minusculesConvertit une chaîne spécifiée en minuscules

TrimTrim Élimine les espaces à gauche et à droite dans unechaîne spécifiée

Élimine les espaces à gauche et à droite dans unechaîne spécifiée


Vous pouvez modifier les données entrées par un utilisateur pour garantir leur affichage selon les exigences de votre format ou pour préparer leur intégration à une base de données. Par exemple, vous pouvez remplacer une chaîne en minuscules par des caractères majuscules et vice-versa. Ceci peut se révéler pratique pour les données qui ne sont pas entrées à l'aide d'un contrôle TextBox car vous pouvez transformer des caractères en majuscules ou en minuscules au moment de la création.

Visual Basic .NET met à votre disposition différentes fonctions permettant de modifier par la programmation les entrées de l'utilisateur après leur saisie ; celles-ci comprennent les fonctions UCase et LCase.

La fonction UCase renvoie une chaîne ou un caractère contenant la chaîne spécifiée convertie en majuscules. Seules les minuscules sont transformées en majuscules, les lettres majuscules et les caractères autres que des lettres demeurent inchangés.

La fonction LCase renvoie une chaîne ou un caractère contenant la chaîne spécifiée convertie en minuscules. Seules les majuscules sont transformées en minuscules, les lettres minuscules et les caractères autres que des lettres demeurent inchangés.

Introduction

Fonctions


Utilisation des événements de validation

! Utilisez la propriété CausesValidation pour déclencher l'événementValidating

! Événement Validating

Private Sub WarehouseTextbox_Validating(. . .) If WarehouseTextbox.Text = "" Then

infoErrorProvider.SetError(WarehouseTextbox, _"Veuillez entrer un emplacement pour

l'entrepôt.")e.Cancel = True

End IfEnd Sub

Private Sub WarehouseTextbox_Validating(. . .) If WarehouseTextbox.Text = "" Then

infoErrorProvider.SetError(WarehouseTextbox, _"Veuillez entrer un emplacement pour

l'entrepôt.")e.Cancel = True

End IfEnd Sub

Private Sub WarehouseTextbox_Validated(. . .)infoErrorProvider.SetError(WarehouseTextbox, "")

End Sub

Private Sub WarehouseTextbox_Validated(. . .)infoErrorProvider.SetError(WarehouseTextbox, "")

End Sub

! Événement Validated


Vous serez parfois amené à vérifier la saisie de données précises d'un utilisateur dans un champ avant de lui permettre l'accès à un autre champ. Tous les contrôles Windows Forms offrent deux événements de validation : l'événement Validating et l'événement Validated. Utilisez ces événements pour vous assurer que des champs spécifiques dans votre application contiennent des données précises avant que l'utilisateur ne passe à un autre champ.

Profitez de la propriété CausesValidation pour déclencher l'événement Validating d'un contrôle. La propriété CausesValidation est une propriété booléenne disponible dans les contrôles Windows Forms fournis par défaut dans la boîte à outils. Lorsqu'elle est définie sur True, cette propriété déclenche l'événement Validating du contrôle qui était actif juste avant le contrôle en cours. La propriété déclenche cet événement lorsque l'utilisateur tente de mettre le focus sur un autre contrôle. Lorsqu'elle est définie sur False, cette propriété annule la validation de n'importe quel contrôle nécessitant une validation. Sa valeur par défaut est True.

L'événement Validating est déclenché avant qu'un contrôle perde son focus, après l'événement Leave et avant l'événement Validated. Le gestionnaire d'événements Validating peut contenir n'importe quel code de validation pouvant vous servir pour le contrôle spécifique.

Introduction

Propriété CausesValidation

Événement Validating


Examinez le formulaire ci-dessous :

Supposez que les règles commerciales de l'application stipulent qu'un champ doive contenir des données avant que l'utilisateur n'accède au champ suivant. Si la propriété CausesValidation de la zone de texte Numéro d'article est définie sur True et que l'événement Validating de la zone de texte Emplacement de l'entrepôt contient du code, ce code s'exécutera dès que l'utilisateur essaiera de déplacer le focus de la zone de texte Emplacement de l'entrepôt à la zone de texte Numéro d'article.

Le code suivant utilise l'événement Validating du contrôle WarehouseTextbox pour vérifier que l'utilisateur a bien entré des données dans la zone de texte Emplacement de l'entrepôt. Si ce n'est pas le cas, le composant ErrorProvider envoie un message d'erreur à l'utilisateur.

Private Sub WarehouseTextbox_Validating(ByVal sender As _ System.Object, ByVal e As _ System.ComponentModel.CancelEventArgs) _ Handles WarehouseTextbox.Validating If WarehouseTextbox.Text = "" Then infoErrorProvider.SetError(WarehouseTextbox, _ "Veuillez entrer un emplacement pour l'entrepôt.") e.Cancel = True End If End Sub

Exemple d'utilisation de l'événement Validating


L'exemple suivant utilise la propriété Value du contrôle DateTimePicker pour vérifier que les dates entrées dans la zone Date de soumission font partie de l'année 2002.

Private Sub submitDateTimePicker_Validating(ByVal sender As _ Object, ByVal e As System.ComponentModel.CancelEventArgs) _ Handles submitDateTimePicker.Validating If submitDateTimePicker.Value <= #1/1/2002# Or _ submitDateTimePicker.Value >= #1/1/2003# Then infoErrorProvider.SetError(WarehouseTextbox, _ "Veuillez entrer une date comprise entre 1/1/2002 et 1/1/2003.") e.Cancel = True End If End Sub

Le code définissant e.Cancel sur True bloque le focus dans la zone de texte tant qu'elle est vide. Pour plus d'informations sur les arguments d'annulation d'événements, voir « CancelEventArgs.Cancel, propriété » dans la documentation Visual Studio .NET.

L'événement Validated est déclenché lorsque les conditions de l'événement Validating sont remplies, mais avant que l'événement LostFocus ne survienne. Dans l'exemple précédent, l'événement Validated est déclenché après la saisie par l'utilisateur de données valides dans la zone de texte NameTextbox et après son déplacement jusqu'au contrôle suivant.

Dans le gestionnaire d'événements Validated, vous pouvez placer du code pour gérer des contrôles dont le contenu dépend du contrôle précédemment validé. Ainsi, vous pouvez réinitialiser un composant Error Provider dans l'événement Validated si vous avez utilisé ce composant pour communiquer des informations sur une erreur lors de la dernière tentative de validation.

L'exemple suivant illustre la façon dont l'événement Validated permet de réinitialiser le composant Error Provider. Le code de l'événement Validated est en gras, celui de l'événement Validating est fourni pour plus de clarté.

Private Sub WarehouseTextbox_Validating(ByVal sender As _ Object, ByVal e As System.ComponentModel.CancelEventArgs) _ Handles WarehouseTextbox.Validating If WarehouseTextbox.Text = "" Then infoErrorProvider.SetError(WarehouseTextbox, _ "Veuillez entrer un nom d'entrepôt.") e.Cancel = True End If End Sub Private Sub WarehouseTextbox_Validated(ByVal sender _ As System.Object, ByVal e As System.EventArgs) _ Handles WarehouseTextbox.Validated infoErrorProvider.SetError(WarehouseTextbox, "") End Sub

Remarque

Événement Validated

Exemple d'utilisation de l'événement Validated


Application pratique : Validation des données de champs

Utilisez le composant ErrorProvider pour avertir l'utilisateur d'une erreur

Écrivez du code pour l'événement Validated afin de réinitialiser le composant ErrorProvider

Écrivez du code pour l'événement Validating afin de tester les données

Testez l'application


Dans cette application pratique, vous ouvrirez un projet existant et ajouterez le code permettant de valider les valeurs entrées dans les champs d'un formulaire.

! Ouverture du projet ValidationEvents 1. Ouvrez Visual Studio .NET. 2. Ouvrez le fichier ValidationEvents.sln situé dans le dossier

dossier_installation\Practices\Mod06\ValidationEvents\Starter 3. Familiarisez-vous avec les contrôles et le code de cette application.

! Test des données dans SkierNameTextbox 1. Créez un gestionnaire d'événements Validating pour le contrôle

SkierNameTextbox.. 2. Dans le gestionnaire d'événements SkierNameTextbox_Validating,

écrivez le code pour vérifier la présence de données dans SkierNameTextbox. Votre code doit ressembler au texte suivant : If SkierNameTextbox.Text = "" Then e.Cancel = True SkiFormErrorProvider.SetError(SkierNameTextbox, _ "Veuillez entrer votre nom.") End If

Introduction

Instructions


! Réinitialisation du composant ErrorProvider dans l'événement Validated de SkierNameTextbox

1. Créez un gestionnaire d'événements Validated pour le contrôle SkierNameTextbox..

2. Dans le gestionnaire d'événements SkierNameTextbox_Validated, écrivez le code pour réinitialiser le composant ErrorProvider de SkierNameTextbox. Votre code doit ressembler au texte suivant : Private Sub SkierNameTextbox_Validated(...) Handles _ SkierNameTextbox.Validated SkiFormErrorProvider.SetError(SkierNameTextbox, "") End Sub

! Test des données dans le contrôle SkiStyleListBox 1. Créez un gestionnaire d'événements Validating pour le contrôle

SkiStyleListBox. 2. Dans le gestionnaire d'événements SkiStyleListBox_Validating, écrivez le

code pour vérifier la présence de données dans SkierNameTextbox. Votre code doit ressembler au texte suivant : Private Sub SkiStyleListBox_Validating(...) Handles _ SkiStyleListBox.Validating If SkiStyleListBox.SelectedItems.Count = 0 Then e.Cancel = True SkiFormErrorProvider.SetError(SkiStyleListBox, _ "Veuillez entrer un style de ski.") End If End Sub

! Réinitialisation du composant ErrorProvider dans l'événement Validated de SkiStyleListBox

1. Créez un gestionnaire d'événements Validated pour le contrôle SkiStyleListBox.

2. Dans le gestionnaire d'événements SkiStyleListBox_Validated, écrivez le code pour réinitialiser le composant ErrorProvider de SkierNameTextbox. Votre code doit ressembler au texte suivant : Private Sub SkiStyleListBox_Validated(...) Handles _ SkiStyleListBox.Validated SkiFormErrorProvider.SetError(SkiStyleListBox, "") End Sub


! Vérification de votre travail 1. Exécutez l'application. 2. Essayez d'utiliser la touche de tabulation dans la zone de texte Nom du

skieur. Une icône d'erreur doit clignoter en regard de la zone de texte Nom du skieur. Immobilisez le pointeur de la souris sur l'icône pour afficher le message « Veuillez entrer votre nom. »

3. Tapez votre nom dans la zone de texte Nom du skieur et appuyez sur la touche TAB. L'icône d'erreur doit disparaître.

4. Essayez d'utiliser la touche de tabulation dans la liste Style de ski. Une icône d'erreur doit clignoter en regard de la liste Style de ski. Immobilisez le pointeur de la souris sur l'icône pour afficher le message « Veuillez entrer un style de ski. »

5. Cliquez sur un élément dans la liste Style de ski et appuyez sur la touche TAB. L'icône d'erreur doit disparaître.

6. Cliquez sur OK. Un message confirmant vos choix doit s'afficher.


Les fichiers solution correspondant à cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod06\ValidationEvents\Solution.

Fichiers solution


Leçon : Validation des données de formulaires

! Validation de plusieurs champs d'un formulaire

! Désignation des boutons d'acceptation et d'annulation

! Questions sur la sécurité


Vous pouvez valider tous les champs d'un formulaire en une seule fois dans Visual Basic .NET. La plupart du temps, vous effectuerez la validation des entrées de l'utilisateur vers la fin du processus de remplissage d'un formulaire. En procédant ainsi, vous limitez le nombre de messages d'erreur et d'interruptions auxquels l'utilisateur doit répondre.


! Validation de plusieurs champs d'un formulaire ! Désignation des boutons d'acceptation et d'annulation ! Questions sur la sécurité


! valider plusieurs champs d'un formulaire en une seule fois ; ! attribuer les propriétés CancelButton et AcceptButton aux boutons de

votre choix dans le formulaire ; ! accéder à l'identité de l'utilisateur Windows en cours de session et l'afficher.

Introduction




Validation de plusieurs champs d'un formulaire

! Repères visuels destinés à l'utilisateur" Exemple

Désactivation du bouton OK jusqu'à ce que l'utilisateur aitentré des données dans tous les champs requis

! Validation de tous les champs du formulaire en même temps" Exemple

Placement de tout le code de validation dans le gestionnaired�événements Click du bouton OK


Certains aspects importants de la validation au niveau du formulaire doivent être envisagés. Vous pouvez prévenir visuellement l'utilisateur que tous les champs obligatoires ont été remplis. Vous pouvez écrire votre code de validation pour que tous les champs du formulaire soient validés en même temps. Si une erreur est découverte, vous pouvez régler le focus sur le contrôle et sur le texte à corriger.

Lorsque vous mettez en �uvre une validation au niveau d'un formulaire, il est important de fournir des indicateurs visuels aux utilisateurs pour qu'ils puissent de comprendre ce que vous attendez d'eux. Prenons l'exemple d'un formulaire dont plusieurs champs (prénom, nom, adresse, ville, département et code postal) doivent être remplis convenablement avant de pouvoir poursuivre.

Une solution pratique consiste à désactiver une commande comme un bouton OK ou Envoyer pour prévenir l'utilisateur qu'il reste des champs à remplir. Lorsque toutes les informations requises sont fournies, il suffit de régler la propriété Enabled du bouton de commande sur True. L'utilisateur saura par ce moyen qu'il a effectué convenablement cette tâche.

Une façon d'activer un bouton de commande lorsque tous les champs sont remplis consiste à lancer une boucle dans la collection Controls pour valider chaque contrôle. Cette collection prédéfinie est fournie par Visual Basic .NET et contient tous les contrôles d'un formulaire.

Introduction

Repères visuels destinés à l'utilisateur

Exemple


Le code suivant renseigne sur la façon d'utiliser le bouton OK pour prévenir visuellement l'utilisateur que certains champs obligatoires sont toujours vides (bouton OK désactivé) ou que toutes les données ont été entrées dans les champs obligatoires d'un formulaire (bouton OK activé). Le formulaire de l'exemple présente des boutons nommés ConfirmData et OK ainsi que des zones de texte.

Private Sub ConfirmData_Click(...) Handles ConfirmData.Click Dim controlVariable As Control For Each controlVariable In Me.Controls ' Vérifier pour voir si le contrôle en cours est une ' zone de texte If TypeOf controlVariable Is TextBox Then ' La zone de texte contient-elle des données ? If Trim(controlVariable.Text) = "" Then ' Si elle est vide, désactiver le bouton OK et ' quitter OKButton.Enabled = False Exit Sub Else OKButton.Enabled = True End If End If Next ' Activer le bouton de commande OK OKButton.Enabled = True End Sub

Dans certains cas, la validation des entrées de l'utilisateur d'un formulaire peut être intéressante dans un gestionnaire d'événements unique. Prenez le cas d'un formulaire contenant des informations clients comme un nom, une adresse, un nom et une référence de service. Vous pouvez prévoir des zones de texte pour la saisie des informations de ces champs et un bouton OK à cliquer lorsque l'utilisateur est prêt à passer au formulaire suivant ou à la prochaine étape de votre application. Utilisez le gestionnaire d'événements Click du bouton de commande pour valider les données de chaque zone de texte du formulaire et, en réglant le focus sur le champ contenant des données non valides, diriger l'utilisateur vers celui-ci.

Validation de plusieurs champs d'un formulaire en même temps


Le code suivant exemplifie la façon de valider tous les champs d'un formulaire en une seule fois. Le formulaire ci-dessous a déjà été créé et un composant ErrorProvider a été ajouté au formulaire. Si des erreurs dans la saisie de données sont repérées, les utilisateurs sont dirigés vers les champs concernés pour les corriger.

Private Sub OkButton_Click(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles OKButton.Click ' Effacer les messages d'erreur entre chaque tentative effectuée par ' l'utilisateur ' de corriger une erreur ErrorProvider1.SetError(FirstNameTextBox, "") ErrorProvider1.SetError(LastNameTextBox, "") ErrorProvider1.SetError(DeptNameTextBox, "") ErrorProvider1.SetError(DeptNumberTextBox, "") ' Configurer le composant ErrorProvider pour chaque contrôle et afficher ' des conseils pour aider les utilisateurs à corriger les erreurs If FirstNameTextBox.Text = "" Then ErrorProvider1.SetError(FirstNameTextBox, _ "Vous devez entrer un prénom.") FirstNameTextBox.Focus( ) Exit Sub ElseIf LastNameTextBox.Text = "" Then ErrorProvider1.SetError(LastNameTextBox, _ "Vous devez entrer un nom.") LastNameTextBox.Focus( ) Exit Sub ElseIf Microsoft.VisualBasic.Left(DeptNameTextBox.Text, 4) <> "SVCE" Then ErrorProvider1.SetError(DeptNameTextBox, _ "Le nom du service doit commencer par SVCE.") DeptNameTextBox.Focus( ) DeptNameTextBox.SelectAll( ) Exit Sub ElseIf Not IsNumeric(DeptNumberTextBox.Text) Then ErrorProvider1.SetError(DeptNumberTextBox, _ "Utilisez des chiffres pour spécifier la référence du service.") DeptNumberTextBox.Focus( ) DeptNumberTextBox.SelectAll( ) DeptNumberTextBox.ForeColor = Color.Red Exit Sub (suite du code à la page suivante)

Exemple


ElseIf CInt(DeptNumberTextBox.Text) < 50 Or _ CInt(DeptNumberTextBox.Text) > 80 Then ErrorProvider1.SetError(DeptNumberTextBox, _ "La référence du service doit être comprise entre 50 et 80.") DeptNumberTextBox.Focus( ) DeptNumberTextBox.SelectAll( ) DeptNumberTextBox.ForeColor = Color.Crimson Exit Sub Else ' Les entrées de l'utilisateur sont conformes et l'application poursuit son ' exécution MessageBox.Show("Veuillez continuer.") End If End Sub


Désignation des boutons d'acceptation et d'annulation

! Définissez la propriété AcceptButton du formulaire

! Définissez la propriété CancelButton du formulaire

! Exemples

" Désignation du boutonOKButton en tant quebouton d'acceptation

" Désignation du boutonEscapeButton en tantque bouton d'annulation


Dans les applications Windows, la touche ÉCHAP permet à l'utilisateur de quitter rapidement une opération sans s'impliquer dans une action quelconque. La touche ENTRÉE lui permet d'accepter les données qu'il a entrées. Vous pouvez assigner la fonctionnalité des touches ÉCHAP et ENTRÉE à n'importe quel bouton d'un formulaire Windows pour faciliter l'utilisation de ce dernier.

Dans les formulaires Windows, vous pouvez désigner le contrôle Button de votre choix comme bouton d'acceptation ; celui-ci est également appelé bouton par défaut. Chaque fois que l'utilisateur appuie sur la touche ENTRÉE, le bouton par défaut est cliqué sans que l'autre contrôle du formulaire possédant le focus ne soit pris en compte. Néanmoins, si celui-ci est un autre bouton, c'est lui qui sera cliqué.

Très souvent, les développeurs définissent la propriété AcceptButton du formulaire sur le bouton OK et ils placent le code de validation dans le gestionnaire d'événements Click du bouton OK. Si vous suivez cette convention dans vos applications, le code du bouton OK s'exécutera lorsque l'utilisateur appuiera sur la touche ENTRÉE.

! Pour désigner un bouton Windows Forms comme bouton d'acceptation 1. Sélectionnez le formulaire dans lequel se trouve le bouton. 2. Dans la fenêtre Propriétés, définissez la propriété AcceptButton du

formulaire sur le nom du contrôle Button.

Introduction

Désignation d'un bouton d'acceptation


Vous pouvez désigner n'importe quel contrôle Button comme bouton d'annulation dans un formulaire Windows. Le code d'événement Click pour le bouton désigné s'exécutera chaque fois que l'utilisateur appuiera sur la touche ÉCHAP, qu'il existe ou non un autre contrôle possédant un focus dans le formulaire.

Si par exemple vous écrivez un code d'annulation dans le bouton Escape, vous pouvez attribuer la propriété CancelButton du formulaire à ce bouton. En appuyant sur la touche ÉCHAP, l'utilisateur déclenchera l'exécution du code de votre bouton Escape.

! Pour désigner un bouton Windows Forms comme bouton d'annulation 1. Sélectionnez le formulaire dans lequel se trouve le bouton. 2. Dans la fenêtre Propriétés, définissez la propriété CancelButton du

formulaire sur le nom du contrôle Button.

Désignation d'un bouton d'annulation


Questions sur la sécurité

! Authentification des utilisateurs

! Vérification de l'utilisateur Windows actuel

" Utilisez la propriété UserName de l'objetSystemInformation

" Exemple

! Sécurisation de votre codeMessageBox.Show(" Vous êtes " & SystemInformation.UserName)MessageBox.Show(" Vous êtes " & SystemInformation.UserName)


Le but inhérent à toute technique de sécurité est le contrôle d'accès aux ressources protégées. Plusieurs points doivent être étudiés lors la conception et de la mise en �uvre de la sécurité de votre application.

Votre application Windows Forms saura tirer parti de la sécurité intégrée de Windows XP. Les utilisateurs et les ordinateurs clients sont configurés dans des domaines valides et les permissions basées sur les rôles gèrent les accès aux applications individuelles.

Pour accéder à l'identité de l'utilisateur Windows en cours de session et l'afficher, utilisez SystemInformation, comme exploité dans le code suivant :

Private Sub Button1_Click(...) MessageBox.Show("Vous êtes " & SystemInformation.UserName) End Sub

Pour en savoir plus sur SystemInformation, consultez la documentation Visual Studio .NET.

Dans Microsoft .NET Framework, le modèle de sécurité repose sur le code, autrement dit des niveaux de sécurité peuvent être définis pour le code sans qu'aucune importance ne soit accordée à l'utilisateur exécutant ce code. Ces niveaux de sécurité peuvent définir la sécurité du navigateur (comme la sécurité basée sur les zones dans Microsoft Internet Explorer) ou la sécurité du système d'exploitation (voir la sécurité basée sur la permission et la stratégie de .NET Framework et Windows).

Bien que la mise en �uvre d'un système de sécurité dans vos appli-cations soit extrêmement importante, elle dépasse le cadre de ce cours. Pour plus d'informations sur ce sujet, lisez l'ouvrage de Michael Howard et David Le Blanc Writing Secure Code (en anglais) ou reportez-vous à « Informations sur la sécurisation des applications » dans la documentation Visual Studio .NET.

Introduction

Authentification des utilisateurs

Vérification de l'utilisateur Windows connecté

Remarque

Sécurisation de votre code

Remarque



! Limitation des entrées de l'utilisateur

! Validation des données de champs

! Validation des données de formulaires

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


1. Comment mettre un TextBox en lecture seule ? Dans la fenêtre Propriétés, définir la propriété ReadOnly sur True.

2. Que se passe-t-il lorsqu'un utilisateur entre un caractère non valide dans un contrôle Masked Edit ? L'ordinateur émet un signal sonore si le son est activé. Le caractère non valide n'est pas accepté et l'application continue.

3. Comment utiliser la validation intrinsèque pour limiter l'entrée des données aux dates et aux heures ? Utiliser le contrôle DateTimePicker.

4. Que se passe-t-il lorsqu'un utilisateur entre des données dans un TextBox dont la propriété PasswordChar est définie sur * (astérisque) ? Quels que soient les caractères entrés par l'utilisateur, ceux-ci s'affichent sous la forme d'astérisques. Cette technique est souvent utilisée pour cacher des mots de passe dans les boîtes de dialogue de connexion.


5. Écrire le code pour appeler la méthode SetError du composant ErrorProvider1 du TextBox1 et afficher le message « Veuillez taper votre prénom. » ErrorProvider1.SetError(TextBox1, "Veuillez taper votre " & _

"prénom.")

6. Quelle technique utiliser pour prévenir visuellement l'utilisateur que tous les champs obligatoires d'un formulaire sont remplis ? Ajouter un bouton OK au formulaire et l'activer uniquement après la saisie des données dans tous les champs obligatoires.

7. Où placer le code de validation si une rétroaction de validation est voulue après la saisie de données dans tous les champs obligatoires ? Dans le gestionnaire d'événements du bouton OK ou de n'importe quel autre bouton d'acceptation désigné.


Atelier 6.1 : Validation des entrées de l'utilisateur

! Exercice 1 : Validation des entrées de l'utilisateur



! utiliser des fonctions booléennes pour valider le contenu d'un contrôle Windows Forms ;

! utiliser les événements Validating et Validated pour aider les utilisateurs à entrer correctement leurs données ;

! utiliser le composant ErrorProvider pour afficher des messages d'erreur et donner des conseils permettant de corriger les saisies de données non valides.

Cet atelier met l'accent sur les concepts dans ce module, par conséquent il est possible qu'il ne se conforme pas aux recommandations de sécurité émises par Microsoft.

Avant de poursuivre, vous devez disposer de connaissances sur :

! les fonctions booléennes ; ! les événements Validating et Validated ; ! le composant ErrorProvider.

Objectifs

Remarque



Dans les ateliers des modules 2, 4, 5, 6 et 12 du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET, vous créerez une application de simulation de prêt. Vous concevrez l'application dans son intégralité et par étapes ; chaque étape se basant sur le code créé dans l'atelier précédent. Au début de chaque atelier, vous pourrez continuer de travailler avec vos propres fichiers ou utiliser les fichiers prévus à cet effet.

Après avoir réalisé l'atelier 5.1, « Utilisation de structures de décision » du module 5, « Structures de décision et boucles » du cours 2560A, Introduction à la programmation en Visual Basic® NET avec Microsoft® .NET, le formulaire de l'application de simulation de prêt doit ressembler à ceci :


Scénario

Fichiers solution



Exercice 1 Validation des entrées de l'utilisateur

Dans cet exercice, vous effectuerez les opérations suivantes :

! définir une valeur par défaut pour la zone de liste déroulante Taux d'intérêt ;

! définir l'ordre de tabulation des contrôles pour guider l'utilisateur à travers le processus de saisie de données correctes dans le formulaire ;

! ajouter et configurer un composant ErrorProvider pour afficher une icône d'erreur clignotante et offrir des conseils permettant aux utilisateurs de corriger leurs saisies non valides dans la zone de texte Montant du prêt ;

! renvoyer l'utilisateur sur le contrôle contenant les données non valides saisies et sélectionner les données à corriger ;

! vérifier la présence de données numériques dans la zone de texte Montant du prêt et dans la zone de liste déroulante Taux d'intérêt ;

! produire le code de validation pour s'assurer que l'utilisateur sélectionne un taux d'intérêt valide (compris entre 2 et 12 pour-cent) ;

! utiliser le composant ErrorProvider pour gérer les saisies de données non valides.

! Ouverture du projet de simulation de prêt 1. Démarrez Visual Studio .NET. 2. Ouvrez le projet de simulation de prêt que vous avez complété dans

l'atelier 5.1, « Utilisation de structures de décision » dans le module 5, « Structures de décision et boucles » du cours 2560A, Introduction à la programmation en Visual Basic® NET avec Microsoft® .NET. Si vous n'avez pas réalisé l'atelier 5.1, utilisez le fichier LoanApplication.sln dans le dossier dossier_installation\Labfiles\Lab061\Ex01\Starter.

! Définition de l'ordre de tabulation pour les contrôles et spécification d'une valeur par défaut pour la zone de liste déroulante Taux d'intérêt

• Dans la fenêtre Propriétés, définissez les propriétés des contrôles, comme stipulé dans le tableau ci-dessous. Remarquez que vous pouvez également cliquer sur Ordre de tabulation dans le menu Affichage pour définir la propriété TabIndex de chaque contrôle.


LoanTextBox TabIndex 0

RateComboBox Text 4.5

RateComboBox TabIndex 1

MonthlyPaymentButton TabIndex 2

TotalPaidButton TabIndex 3

DoneButton TabIndex 4


! Ajout d'un composant ErrorProvider au formulaire 1. Ajoutez un composant ErrorProvider au formulaire MainForm. 2. Dans la fenêtre Propriétés, remplacez le nom de ErrorProvider1 par

MainErrorProvider.

! Ajout d'un code de validation à l'événement de validation LoanTextBox 1. Dans le gestionnaire d'événements LoanTextBox_Validating, écrivez une

instruction If�Then pour déclencher une erreur si les données de LoanTextBox ne sont pas numériques. Votre code doit ressembler au texte suivant : If Not IsNumeric(LoanTextBox.Text) Then MainErrorProvider.SetError(LoanTextBox, _ "Veuillez entrer un montant d'emprunt supérieur à 0" & _ "en caractères numériques.") e.Cancel = True Else e.Cancel = False End If

Le code définissant e.Cancel sur True bloque le focus dans la zone de texte tant qu'elle est vide et sélectionne son contenu.

2. Dans le gestionnaire d'événements LoanTextBox_Validating, ajoutez une autre expression conditionnelle pour rechercher zéro ou toute occurrence de "0,0" comme premiers caractères dans LoanTextBox. (Le test sur le zéro ou "0,0" évite que les utilisateurs utilisent des variations de zéro, par exemple "0,00" ou "0,00000", qui mettent votre validation en échec.) Votre code doit ressembler au texte suivant : If Not IsNumeric(LoanTextBox.Text) Or _ LoanTextBox.Text = "0" Or _ Microsoft.VisualBasic.Left(LoanTextBox.Text, 3) _ = "0,0" Then MainErrorProvider.SetError(LoanTextBox, _ "Veuillez entrer un montant d'emprunt" & _ "supérieur à 0 en caractères numériques.") e.Cancel = True Else e.Cancel = False End If

3. Au début du gestionnaire d'événements LoanTextBox_Validating, effacez

le message d'erreur entre chaque tentative de saisie de données valides. Votre code doit ressembler au texte suivant : MainErrorProvider.SetError(LoanTextBox,"") MainErrorProvider.SetError(RateComboBox,"")

Remarque


! Ajout d'un code de validation à l'événement de validation RateComboBox

1. Dans le gestionnaire d'événements RateComboBox_Validating, ajoutez une instruction If�Then pour déclencher une erreur si les données de RateComboxBox ne sont pas numériques. Votre code doit ressembler au texte suivant : If Not IsNumeric(RateComboBox.Text) Then MainErrorProvider.SetError(RateComboBox, _ "Veuillez choisir ou entrer un taux d'intérêt " & _ "compris entre 2 et 12 en caractères " & _ "numériques.") e.Cancel = True Else e.Cancel = False End If

2. Dans le gestionnaire d'événements RateComboBox_Validating, ajoutez

une instruction ElseIf pour vérifier la présence d'un taux au-dessous de 2 ou supérieur à 12 dans RateComboBox. Votre code doit ressembler au texte suivant : If Not IsNumeric(RateComboBox.Text) Then MainErrorProvider.SetError(RateComboBox, _ "Veuillez choisir ou entrer un taux d'intérêt " & _ "compris entre 2 et 12 en caractères " & _ "numériques.") e.Cancel = True ElseIf RateComboBox.Text >= 2 And _ RateComboBox.Text <= 12 Then e.Cancel = False Else MainErrorProvider.SetError(RateComboBox, _ "Veuillez choisir ou entrer un taux d'intérêt " & _ "compris entre 2 et 12 en caractères " & _ "numériques.") e.Cancel = True End If

3. Au début du gestionnaire d'événements RateComboBox_Validating,

effacez le message d'erreur entre chaque tentative de saisie de données valides. Votre code doit ressembler au texte suivant : MainErrorProvider.SetError(LoanTextBox,"") MainErrorProvider.SetError(RateComboBox,"")


! Utilisation du fournisseur d'erreur pour émettre une rétroaction de validation

1. Dans le gestionnaire d'événements LoanTextBox_Validated, appelez la méthode SetError de MainErrorProvider pour effacer le message de validation du contrôle LoanTextBox après la saisie de données valides par l'utilisateur. Votre code doit ressembler au texte suivant : MainErrorProvider.SetError(LoanTextBox,"")

2. Dans le gestionnaire d'événements RateComboBox_Validated, appelez la

méthode SetError de MainErrorProvider pour effacer le message de validation du contrôle RateComboBox après la saisie de données valides par l'utilisateur. Votre code doit ressembler au texte suivant : MainErrorProvider.SetError(RateComboBox,"")

! Effacement du fournisseur d'erreur entre les appels 1. Dans le gestionnaire d'événements MonthlyPaymentButton_Click,

supprimez le code de validation en cours pour que seule l'instruction MessageBox appelant la procédure MonthlyPayment demeure. Votre code doit ressembler au texte suivant : Private Sub MonthlyPaymentButton_Click(...) MessageBox.Show(FormatCurrency(MonthlyPayment(CDbl _ (LoanTextBox.Text), CDbl(RateComboBox.Text), _ loanTerm))) End Sub

2. Au début du gestionnaire d'événements MonthlyPaymentButton_Click,

effacez le message d'erreur entre les appels à la fonction MonthlyPayment. Votre code doit ressembler au texte suivant : MainErrorProvider.SetError(LoanTextBox,"") MainErrorProvider.SetError(RateComboBox,"")

3. Dans le gestionnaire d'événements TotalPaidButton_Click, supprimez le

code de validation en cours pour que seule l'instruction MessageBox appelant la procédure TotalPaid demeure. Votre code doit ressembler au texte suivant : Private Sub TotalPaidButton_Click(...) MessageBox.Show(FormatCurrency(TotalPaid(CDbl _ (LoanTextBox.Text), CDbl(RateComboBox.Text), _ loanTerm))) End Sub

4. Au début du gestionnaire d'événements TotalPaidButton_Click, effacez le

message d'erreur entre les appels à la fonction TotalPaid. Votre code doit ressembler au texte suivant : MainErrorProvider.SetError(LoanTextBox,"") MainErrorProvider.SetError(RateComboBox,"")


! Vérification de votre travail 1. Exécutez l'application. 2. Avant d'entrer des données, cliquez sur Mensualité.

Une icône d'erreur doit clignoter en regard de la zone de texte Montant du prêt. Pour lire le message d'erreur, immobilisez le pointeur de la souris sur l'icône d'erreur. Le message « Veuillez entrer un montant d'emprunt supérieur à 0 en caractères numériques. » doit s'afficher.

3. Tapez douze dans la zone de texte Montant du prêt et cliquez sur Mensualité. Une icône d'erreur doit clignoter en regard de la zone de texte Montant du prêt. Pour lire le message d'erreur, immobilisez le pointeur de la souris sur l'icône d'erreur. Le message « Veuillez entrer un montant d'emprunt supérieur à 0 en caractères numériques. » doit s'afficher.

4. Tapez 500000 dans la zone de texte Montant du prêt, puis douze dans la zone de liste déroulante Taux d'intérêt et cliquez sur Mensualité. Une icône d'erreur doit clignoter en regard de la zone de liste déroulante Taux d'intérêt. Pour lire le message d'erreur, immobilisez le pointeur de la souris sur l'icône d'erreur. Le message « Veuillez choisir ou entrer un taux d'intérêt compris entre 2 et 12 en caractères numériques. » doit s'afficher.

5. Entrez 48 dans la zone de liste déroulante Taux d'intérêt et cliquez sur Mensualité. Une icône d'erreur doit clignoter en regard de la zone de liste déroulante Taux d'intérêt. Pour lire le message d'erreur, immobilisez le pointeur de la souris sur l'icône d'erreur. Le message « Veuillez choisir ou entrer un taux d'intérêt compris entre 2 et 12 en caractères numériques. » doit s'afficher.

6. Entrez 0 dans la zone de liste déroulante Taux d'intérêt et cliquez sur Mensualité. Une icône d'erreur doit clignoter en regard de la zone de liste déroulante Taux d'intérêt. Pour lire le message d'erreur, immobilisez le pointeur de la souris sur l'icône d'erreur. Le message d'erreur « Veuillez choisir ou entrer un taux d'intérêt compris entre 2 et 12 en caractères numériques. » doit s'afficher.

7. Entrez 3 dans la zone de liste déroulante Taux d'intérêt et cliquez sur Mensualité. Un message affiche le montant de la mensualité, soit 8.984,35 �.

8. Cliquez sur OK dans le message. 9. Tapez des données non valides au choix dans la zone de texte Montant du

prêt ou dans la zone de liste déroulante Taux d'intérêt et cliquez sur Total remboursé. L'icône d'erreur clignotante et le même message de validation apparus pour le bouton Mensualité doivent s'afficher.

10. Tapez 500.000 dans la zone de texte Montant du prêt, puis 3 dans la zone Taux d'intérêt et cliquez sur Total remboursé. Un message affiche le montant de 539.060,72 �.

11. Cliquez sur le bouton OK dans le message, puis quittez l'application.

Table des matières

Vue d'ensemble 1

Présentation multimédia : Présentation des objets et des classes et mode d'utilisation 2

Leçon : Compréhension des classes 3

Leçon : Utilisation des classes 8

Leçon : Utilisation des membres partagés 22

Leçon : Héritage, polymorphisme et espaces de noms 28


Atelier 7.1 : Création d'une classe dérivée 38

Module 7 : Programmation orientée objet en Visual Basic .NET


Module 7 : Programmation orientée objet en Visual Basic .NET iii

Notes de l'instructeur Ce module explique aux stagiaires comment créer et utiliser des classes. Il aborde les concepts d'abstraction, d'encapsulation, d'instanciation, d'initialisation, de constructeur et de destructeur. Il décrit également en quoi consistent l'héritage, le polymorphisme et les espaces de noms.


! expliquer les concepts de la programmation orientée objet, notamment les notions de classe, d'abstraction, d'encapsulation et d'objet ;

! utiliser l'Explorateur d'objets pour étudier les éléments de programmation disponibles, notamment les classes et les objets ;

! créer une classe, y compris les méthodes, les propriétés et les données membres avec les niveaux d'accès appropriés ;

! créer et utiliser une instance d'une classe, y compris les données membres d'instance et partagées, et les méthodes partagées et non partagées ;

! expliquer le fonctionnement des constructeurs et des destructeurs ; ! expliquer ce que sont l'héritage, le polymorphisme et les espaces de noms.


! Fichier Microsoft® PowerPoint® 2560A_07.ppt ! Fichier d'animation multimédia 2560A_Basic OOP Concepts.htm


! lire tous les documents de cours relatifs à ce module ; ! prendre connaissance de l'animation multimédia ; ! réaliser les applications pratiques et l'atelier.


Documents de cours

Préparation

iv Module 7 : Programmation orientée objet en Visual Basic .NET


Présentation multimédia : Présentation des objets et des classes et mode d'utilisation

Ce module commence par une animation multimédia qui présente tous les concepts clés utilisés dans le module. Au cours de cette animation, les stagiaires vont apprendre à connaître les classes et les objets. Pour lancer cette démonstration, cliquez sur l'icône située au centre de la diapositive.

Leçon : Compréhension des classes Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Cette leçon s'attache à bien expliquer la définition conceptuelle des termes classe et objet. Dans cette leçon, il vous arrivera d'utiliser un mot particulier pour indiquer une classe (tous les exemples) et d'utiliser le même mot pour indiquer un objet (un exemple spécifique ou une instance de la classe). Efforcez-vous à utiliser le mot approprié à chaque cas. Autrement dit, commencez dès maintenant à bien distinguer les classes des objets.

Cette rubrique décrit les rôles d'abstraction et d'encapsulation rencontrés lors de la création d'une classe. Soulignez bien qu'il ne s'agit que d'aborder brièvement un sujet particulièrement complexe. Vous pouvez parler des analyses et des diagrammes de cas d'utilisation, mais ces outils ne sont pas mentionnés dans cette rubrique. Lorsque vous décrivez le concept d'encapsulation, utilisez l'exemple du guichet automatique bancaire pour aider les stagiaires à bien faire la différence entre ce que l'utilisateur voit et ce qui est encapsulé ou masqué.

Cette rubrique décrit l'identité, l'état et le comportement des objets.

La notion d'identité d'un objet peut être difficile à appréhender. Pour expliquer ce concept, imaginez que vous êtes au restaurant, mais n'avez pas la possibilité de lire le menu. Vous voyez quelqu'un manger un plat qui vous plaît et sent très bon. Vous décidez de prendre la même chose. Vous appelez un serveur et lui dites : « J'aimerais prendre ce que cette personne mange ». Deux résultats sont alors possibles. Avec identité, le serveur s'approche de la table voisine, enlève l'assiette du client et vous la donne. Sans identité, le serveur va en cuisine, donne le nom du plat au chef qui va alors reproduire le même plat avec un nouvel ensemble d'ingrédients similaires. Le concept d'identité peut se résumer en une seule question : avez-vous besoin de l'objet réel ou vous suffit-il d'une copie ?

Pour bien faire passer votre message, expliquez ce qu'est l'Explorateur d'objets et ce qu'il fait en travaillant directement dans l'environnement de développement de Microsoft Visual Studio® .NET.

Présentation d'une classe

Présentation d'un objet

Utilisation de l'Explorateur d'objets

Module 7 : Programmation orientée objet en Visual Basic .NET v

Leçon : Utilisation des classes Cette leçon explique comment créer des classes et des objets.

Cette rubrique explique comment créer une classe dans Microsoft Visual Basic® .NET. Le module s'attache à créer une classe à partir du menu Projet. Si vous le souhaitez, vous pouvez montrer aux stagiaires d'autres méthodes.

Dans cette rubrique, les stagiaires apprennent à ajouter des données membres d'instance à une classe. Ils apprennent aussi à faire référence aux données membres à l'aide du mot clé Me. De plus, cette rubrique explique aux stagiaires comment affecter des modificateurs d'accès. Reliez cette rubrique au cadre que fournit l'encapsulation. Expliquez que les membres de l'entité uniquement accessibles de l'intérieur sont privés et que ceux qui sont accessibles de l'intérieur et de l'extérieur sont publics.

Dans cette rubrique, les stagiaires apprennent à ajouter des méthodes à une classe. Cette rubrique explique également ce qu'est la surcharge de méthodes. Expliquez qu'il y a surcharge de méthodes lorsqu'une classe contient deux ou plusieurs méthodes de même nom, mais avec des signatures différentes.

Dans cette rubrique, les stagiaires apprennent à ajouter des propriétés à une classe. Expliquez aux stagiaires qu'ils peuvent attribuer des propriétés et récupérer les valeurs des propriétés à partir de la classe. Cette rubrique décrit aussi comment utiliser les spécificateurs ReadOnly et WriteOnly.

Cette rubrique montre comment créer une instance d'une classe. Expliquez qu'il s'agit de créer un objet capable d'exécuter les propriétés et les méthodes d'une classe. Montrez la donnée membre de l'instance dans le code exemple présenté sur la diapositive.

Cette application pratique passe en revue toutes les étapes nécessaires à la création d'une classe. Elle doit prendre environ 15 minutes.

Cette rubrique montre comment utiliser les constructeurs. Expliquez que le mot clé New sert à initialiser de nouveaux objets.

Cette rubrique montre comment utiliser les destructeurs. Expliquez que la sous-routine de destruction Finalize permet de libérer les ressources telles que les connexions aux bases de données.

Leçon : Utilisation des membres partagés Cette leçon décrit comment utiliser les données membres partagées et les membres de procédure partagés dans une classe.

Cette rubrique explique que les données membres partagées permettent à plusieurs instances d'une classe de faire référence à une même instance d'une variable de niveau de classe.

Cette rubrique explique comment utiliser des méthodes partagées pour concevoir des fonctions pouvant être appelées sans créer d'instance de cette classe. Expliquez que les membres partagés ne peuvent accéder qu'aux données accompagnées du mot clé Shared.

Création d'une classe

Ajout de données membres d'instance

Ajout de méthodes

Ajout de propriétés

Création d'une instance d'une classe

Application pratique : Création d'une classe

Utilisation des constructeurs

Utilisation des destructeurs

Utilisation des données membres partagées

Utilisation des méthodes partagées

vi Module 7 : Programmation orientée objet en Visual Basic .NET

Au cours de cette application pratique, les stagiaires auront à créer et à utiliser une classe où une méthode partagée permet de convertir les degrés Fahrenheit en degrés Celsius. Elle doit prendre environ 15 minutes.

Leçon : Héritage, polymorphisme et espaces de noms Cette leçon décrit les concepts de la programmation orientée objet, notamment les notions d'héritage et de polymorphisme. Ce module compare également les classes et les structures. Pour finir, ce module décrit les espaces de noms.

Cette rubrique explique en quoi consiste l'héritage. Expliquez que l'héritage permet de transférer les caractéristiques d'une classe de base vers toutes les classes qui en sont dérivées. Ce module ne traite que de l'héritage de classes. L'héritage d'interface n'y est pas abordé. Vous pouvez brièvement signaler que l'héritage d'interface est tout à fait possible dans Visual Basic .NET et conseiller aux stagiaires de consulter la documentation Visual Studio .NET appropriée.

Cette rubrique explique comment fonctionne l'héritage. Expliquez que, dans Visual Basic .NET, les stagiaires peuvent recourir à l'héritage pour dériver une classe à partir d'une classe de base existante. La classe dérivée peut hériter de l'ensemble des propriétés de la classe de base, de ses méthodes, données membres, événements et gestionnaires d'événements, simplifiant ainsi la réutilisation du code de la classe de base dans une application.

Cette rubrique explique en quoi consiste le polymorphisme. Le polymorphisme est une partie naturelle de la classification. Vous souhaiterez peut-être utiliser un exemple simple. En voici un. Demandez à un stagiaire l'heure qu'il est. Posez la même question à un deuxième stagiaire, puis à un troisième. Vous obtiendrez une variété d'« implémentations » et de réponses différentes. Certains stagiaires regarderont leurs montres ; d'autres jetteront un oeil à une horloge ; d'autres encore se contenteront de répéter la réponse précédente (ce qui est analogue à la mise en cache).

Cette rubrique aide les stagiaires à bien distinguer les classes des structures. Expliquez que les classes et les structures sont similaires sur plusieurs plans : toutes deux peuvent définir des données membres, des propriétés et des méthodes. Toutefois, les classes proposent quelques fonctionnalités avancées dont les stagiaires peuvent tirer parti.

Cette rubrique explique en quoi consistent les espaces de noms. Expliquez que les assemblys .NET Framework utilisent des espaces de noms pour organiser les objets d'un assembly (classes, interfaces et modules) en une structure aisément compréhensible.

Application pratique : Création de méthodes partagées

Présentation de l'héritage

Héritage d'une classe

Présentation du polymorphisme

Comparaison entre classes et structures

Organisation des classes en espaces de noms

Module 7 : Programmation orientée objet en Visual Basic .NET vii

Contrôle des acquis Ces questions sont l'occasion de réviser les concepts et les procédures abordés en détail dans ce module. Adoptez le principe de la discussion pour répondre aux questions afin que chacun ait la possibilité de connaître la bonne réponse.

1. Il est essentiel que les stagiaires comprennent le processus d'abstraction. 2. Il est également essentiel que les stagiaires comprennent le processus

d'encapsulation. 3. Cette question offre la possibilité d'écrire le code voulu pour créer un projet

et d'ajouter au code une donnée membre d'instance et une méthode. 4. Cette question est l'occasion d'écrire le code qui permet de créer une classe

et d'ajouter une donnée membre privées. 5. Cette question permet de revoir comment initialiser et désinitialiser des

objets. 6. Utilisez cette question pour renforcer le concept d'héritage.

Atelier 7.1 : Création d'une classe dérivée Avant de commencer cet atelier, les stagiaires doivent avoir réalisé toutes les applications pratiques et répondu aux questions du contrôle des acquis. Les stagiaires devront pouvoir accomplir la plupart des tâches apprises dans les leçons et les applications pratiques. Au commencement de cet atelier, les stagiaires peuvent décider de poursuivre avec leurs propres fichiers ou de démarrer avec les fichiers fournis.

Module 7 : Programmation orientée objet en Visual Basic .NET 1

Vue d'ensemble

! Compréhension des classes

! Utilisation des classes

! Utilisation des membres partagés

! Héritage, polymorphisme et espaces de noms

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


Ce module explique comment créer et utiliser les classes. Il aborde les concepts d'abstraction, d'encapsulation, d'instanciation, d'initialisation, de constructeur et de destructeur. Il décrit également en quoi consistent l'héritage, le polymorphisme et les espaces de noms.

Les objets sont la clé de voûte de la programmation en Microsoft® Visual Basic® .NET. Les formulaires, les contrôles et les bases de données sont tous des objets. Dans ce module, vous allez apprendre à créer vos propres objets à partir des classes que vous définissez et à les utiliser pour simplifier le code et en faciliter la réutilisation.


! expliquer les concepts de la programmation orientée objet, notamment les notions de classe, d'abstraction, d'encapsulation et d'objet ;

! utiliser l'Explorateur d'objets pour étudier les éléments de programmation disponibles, notamment les classes et les objets ;

! créer une classe, y compris les méthodes, les propriétés et les données membres ;

! créer et utiliser une instance d'une classe, y compris les données membres d'instance et partagées, et les méthodes partagées et non partagées ;

! expliquer le fonctionnement des constructeurs et des destructeurs ; ! expliquer ce que sont l'héritage, le polymorphisme et les espaces de noms.

Introduction

Objectifs

2 Module 7 : Programmation orientée objet en Visual Basic .NET

Présentation multimédia : Présentation des objets et des classes et mode d'utilisation


Cette animation vous présente les éléments fondamentaux dont vous allez vous servir dans Visual Basic .NET et tout au long de ce module, à savoir les classes et les objets.

Dans Microsoft® Visual Basic® .NET, vous pouvez utiliser des concepts de programmation orientée objet, tels que les classes et les objets.

Une classe peut représenter une entité concrète (comme une horloge), ou une entité abstraite (comme l�heure).

Vous pouvez vous représenter une classe comme un modèle comportant des variables, des méthodes, des propriétés et des événements.

Un objet est une instance de la classe. Par exemple, ce modèle de maison peut être assimilé à une classe (la classe Maison) et chaque maison construite à partir du modèle est considérée comme une instance de la classe Maison.

Dans Visual Basic .NET, vous pouvez hériter de votre classe afin de l'étendre. La classe dont vous héritez est appelée classe de base. La classe que vous étendez est appelée classe dérivée. Les classes dérivées héritent des propriétés, méthodes et événements définis dans la classe de base, et elles peuvent également les étendre.

Introduction

Script d'animation


Leçon : Compréhension des classes

abstractionabstraction

classeclasse

encapsulationencapsulation

objetobjet


Cette leçon décrit les concepts de la programmation orientée objet, notamment les classes, l'abstraction et l'encapsulation, et les objets. Si vous comprenez bien ces concepts, vous pourrez tirer pleinement parti des puissantes fonctions orientées objet de Visual Basic .NET. De plus, vous allez apprendre à utiliser l'Explorateur d'objets pour étudier les classes, les objets et les autres éléments de programmation.


! Présentation d'une classe ! Présentation d'un objet ! Utilisation de l'Explorateur d'objets


! décrire les classes et les objets ; ! expliquer le rôle de l'abstraction et de l'encapsulation lors de la création des

classes ; ! utiliser l'Explorateur d'objets pour étudier les classes et les objets, ainsi que

tous les autres éléments de programmation.

Introduction




Présentation d'une classe

! Une classe est un plan qui décrit un objet et qui définit des attributs et des opérations pour celui-ci

! Les classes utilisent l'abstraction pour rendre uniquementdisponibles les objets essentiels à la définition de l'objet

! Les classes utilisent l'encapsulation pour appliquer uneabstraction

Ce que l'utilisateur voit : Ce qui est encapsulé :

//verify language//authenticate PIN//validate account bal//adjust account bal


En programmation orientée objet, vous faites appel à l'abstraction et à l'encapsulation pour créer des classes bien conçues.

Une classe est un modèle ou un plan qui sert à créer à un objet. Ce modèle définit des attributs pour le stockage de données ainsi que des opérations pour la manipulation de ces dernières. Une classe définit en outre une série de restrictions destinées à autoriser ou à refuser l'accès à ses attributs et opérations.

Pour créer une classe bien conçue, vous avez recours à l'abstraction. Lors de la mise en �uvre de l'abstraction, vous définissez un concept en utilisant un ensemble minime de fonctionnalités soigneusement choisies qui dicte et rationalise le comportement essentiel de la classe. Malheureusement, il n'est pas toujours facile de créer de bonnes abstractions logicielles. Cela exige généralement une parfaite compréhension du problème que la classe doit résoudre et de son contexte, une grande clarté d'esprit et beaucoup d'expérience.

Le formulaire Visual Basic .NET avec lequel vous travaillez est un bon exemple d'abstraction. Les propriétés essentielles d'un formulaire (légende et couleur d'arrière-plan, par exemple) ont été extraites de la classe Form. Parmi les opérations fondamentales extraites, citons : ouvrir, fermer et réduire.

L'abstraction est assurée au moyen de l'encapsulation. L'encapsulation consiste à regrouper les attributs et les fonctionnalités nécessaires à la création d'un objet, autrement dit une « boîte noire » dont la structure interne reste privée. Vous empaquetez les détails de l'abstraction et ne permettez d'accéder qu'aux éléments indispensables. Les autres objets ne peuvent accéder aux services d'un objet encapsulé que par le biais de messages transmis par une interface clairement définie.

Introduction

Définition

Utilisation de l'abstraction

Exemple d'abstraction

Utilisation de l'encapsulation


Un guichet automatique bancaire (GAB) est un parfait exemple d'encapsulation. L'interface du GAB destinée au client est volontairement simplifiée et les mécanismes internes sont cachés. De même, une classe BankAccount encapsule les méthodes, les champs et les propriétés qui décrivent un compte bancaire. Sans encapsulation, il faudrait déclarer des procédures et des variables distinctes pour stocker et gérer les informations relatives au compte bancaire, et il serait difficile de travailler simultanément avec plusieurs comptes. L'encapsulation permet aux utilisateurs d'employer les données et les procédures de la classe BankAccount en tant qu'une seule unité, sans connaître le code exact encapsulé dans la classe.

Exemple d'encapsulation


Présentation d'un objet

! Un objet est une instance spécifique d'une classe

! Les objects possèdent les caractéristiques suivantes :

" Identité : Les objets peuvent être distingués les uns des autres

" Comportement : Les objets peuvent effectuer des tâches

" État : Les objets stockent des informations qui peuvent changer au fildu temps

123

245

12

245

ObjetObjetObjetObjet

ClasseClasse


En règle générale, pour exécuter les méthodes et utiliser les propriétés d'une classe, vous devez créer une instance de la classe. Une instance d'une classe est appelé un objet. Les termes classe et objet sont tellement utilisés dans la programmation orientée objet qu'il est très facile de les confondre. Considérez une classe comme une représentation abstraite de quelque chose et un objet comme un exemple utilisable de la chose que la classe représente.

Un objet est une unité de logiciel qui contient un ensemble de méthodes et de données en rapport. Un objet est une instance spécifique d'une classe et reprend les caractéristiques de cette classe.

Le mot voiture revêt différentes significations selon les contextes. Quelquefois, il a un rôle générique et fait référence à l'ensemble de toutes les voitures ; il peut alors être assimilé au mot classe. Dans d'autres cas, le mot voiture fait référence à une voiture spécifique ; il peut alors être assimilé au mot objet.

Les objets ont une identité. L'identité est la caractéristique qui distingue un objet de tous les autres.

Les objets ont un certain comportement. Le comportement est la caractéristique qui rend les objets utiles. Les objets existent pour assurer un comportement. La plupart du temps, par exemple, vous pouvez ignorer les mécanismes internes d'une voiture et penser à son comportement. Les voitures présentent une utilité parce que vous pouvez les conduire. Les mécanismes internes existent, mais ils sont quasiment inaccessibles ; c'est le comportement d'un objet qui est accessible. Les objets de la même classe partagent le même comportement. Une voiture est une voiture parce que vous pouvez la conduire.

Les objets ont un état. L'état est la caractéristique qui se réfère aux mécanismes internes d'un objet ; mécanismes qui permettent à l'objet de se comporter conformément à sa définition. Un objet bien conçu ne laisse pas accéder à son état. L'état est étroitement lié à l'abstraction et à l'encapsulation. Peu importe la façon dont l'objet réalise les actions, l'important est qu'il les réalise. Deux objets ayant par hasard le même état restent tout de même deux objets distincts.

Introduction

Définition

Exemple d'objet

Identité

Comportement

État



VoletObjetsVolet

ObjetsVolet

MembresVolet

Membres

VoletDescription

VoletDescription


Vous pouvez vous servir de l'Explorateur d'objets pour étudier les éléments de programmation (espaces de noms, classes, modules, structures, etc.) d'un composant, ainsi que les membres de ces éléments (propriétés, méthodes, événements, variables, etc.). Les composants que vous analysez peuvent être des projets de votre solution, des composants référencés dans ces projets ou des composants externes.

Pour ouvrir l'Explorateur d'objets, soit appuyez sur CTRL+ALT+J, soit, dans le menu Affichage, pointez sur Autres fenêtres et cliquez sur Explorateur d'objets.

L'Explorateur d'objets se compose de trois volets :

! le volet Objets affiche, sous forme d'arborescence, tous les objets conteneurs existant dans la portée de l'analyse. Lorsque vous développez un élément en double-cliquant dessus ou en cliquant sur le signe plus (+) en regard de son nom, les éléments définis au niveau inférieur s'affichent.

! Le volet Membres affiche les membres de l'élément que vous sélectionnez dans le volet Objets.

! Le volet Description affiche les informations détaillées relatives à l'élément ou au membre sélectionné.

Une icône spécifique identifie chaque élément de programmation dans l'Explorateur d'objets. Le tableau suivant montre quelques-unes des icônes utilisées.

Icône Description Icône Description

Espace de noms Module

Classe Structure

Introduction



Leçon : Utilisation des classes

! Création d'une classe

! Ajout de données membres d'instance

! Ajout de méthodes

! Ajout de propriétés

! Création d'une instance d'une classe

! Utilisation des constructeurs

! Utilisation des destructeurs


La plate-forme Microsoft .NET propose la bibliothèque de classe Microsoft .NET Framework, mais rien ne vous empêche de créer vos propres classes. Cette leçon explique comment créer une classe, y ajouter des données membres, des méthodes et des propriétés, et définir des modificateurs d'accès publics et privés. Elle explique également comment créer une instance d'une classe et comment initialiser et désinitialiser les objets.


! Création d'une classe ! Ajout de données membres d'instance ! Ajout de méthodes ! Ajout de propriétés ! Création d'une instance d'une classe ! Application pratique : Création d'une classe ! Utilisation des constructeurs ! Utilisation des destructeurs


! créer une classe ; ! ajouter des données membres d'instance à une nouvelle classe ; ! ajouter des méthodes à une nouvelle classe ; ! ajouter des propriétés à une nouvelle classe ; ! créer un objet ; ! utiliser les constructeurs pour initialiser les objets ; ! utiliser les destructeurs pour désinitialiser les objets.

Introduction





! Créez une classe à l'aide de la commande Ajouter uneclasse du menu Projet

! Exemple de classe appelée BankAccount :

Public Class Class1

End Class

Public Class Class1

End Class

Public Class BankAccount

End Class


End Class


Après avoir déterminé, lors de l'abstraction, les entités adaptées à un problème de gestion, vous pouvez envisager de créer les classes correspondant aux entités de l'abstraction.

! Pour créer une classe 1. Ouvrez un projet dans Microsoft Visual Studio® .NET (si aucun n'est encore

ouvert). 2. Dans le menu Projet, cliquez sur Ajouter une classe. 3. Dans la zone Nom, tapez le nom de votre nouvelle classe, puis cliquez sur

Ouvrir. L'Éditeur de code propose les instructions de programmation qui marquent le début et la fin de votre classe, comme vous le voyez ci-dessous : Public Class NomClasse End Class

Introduction



Ajout de données membres d'instance

! Ajout d'une donnée membre appelée balance

Public Class BankAccountPrivate balance As Double

End Class

Public Class BankAccountPrivate balance As Double

End Class

Mot cléMot Mot cléclé DéfinitionDéfinitionDéfinition

PublicPublic Accessible à partir de n'importe quel emplacementAccessible à partir de n'importe quel emplacement

PrivatePrivate Accessible uniquement au sein du typeAccessible uniquement au sein du type

ProtectedProtected Accessible uniquement par les classes qui héritent de la classeAccessible uniquement par les classes qui héritent de la classe


Après avoir ajouté une nouvelle classe à votre projet, vous pouvez y ajouter des données membres. Les données membres propres à une instance de la classe s'appellent les données membres d'instance. Lorsque vous ajoutez des données membres d'instance à une classe, vous précisez le niveau d'accès à l'aide des modificateurs d'accès.

Les données membres d'instance comportent des variables et des constantes. Les variables des membres sont aussi appelées champs.

Dans l'exemple suivant, une donnée membre de type Double appelée balance est ajoutée à la classe :

Private balance As Double

Vous pouvez également faire référence à la donnée membre balance à l'aide du mot clé Me, comme le montre l'exemple suivant :

Me.balance

Le mot clé Me se comporte comme une variable d'objet et fait référence à l'instance actuelle d'une classe. Lorsqu'une classe peut avoir plusieurs instances, le mot clé Me est un moyen de faire référence à l'instance spécifique de la classe où le code est en cours d'exécution.

Vous pouvez contrôler l'accès aux entités à l'intérieur de cette classe : certaines seront uniquement accessibles de l'intérieur et d'autres seront accessibles de l'intérieur et de l'extérieur. Les membres de l'entité uniquement accessibles de l'intérieur sont dits privés. Les membres de l'entité accessibles de l'intérieur et de l'extérieur sont dits publics. Il faut, par exemple, rendre privée la donnée membre d'instance balance de telle sorte que le solde du compte ne puisse pas être modifié en dehors de la classe BankAccount.

Vous pouvez aussi utiliser le mot clé Protected pour restreindre l'accès aux classes qui héritent de celle-ci. Vous en apprendrez davantage sur l'héritage dans la dernière leçon de ce module.

Introduction

Données membres d'instance

Exemple

Mot clé Me

Modificateurs d'accès


Ajout de méthodes

! Ajout d'une méthode appelée Deposit



Public Sub Deposit(ByVal amount As Double)balance +=amount

End Sub

End Class



Public Sub Deposit(ByVal amount As Double)balance +=amount

End Sub

End Class

! Méthodes surchargées : deux ou plusieurs méthodesportant le même nom, mais des signatures différentesExemple : MessageBox.Show


Vous pouvez ajouter des méthodes à une classe. Lors de cet ajout, vous devez spécifier le niveau d'accès à l'aide des modificateurs d'accès. Les méthodes incluent les fonctions et les procédures Sub.

Dans l'exemple suivant, une méthode appelée Deposit est ajoutée à la classe :

Public Sub Deposit(ByVal amount As Double) balance +=amount End Sub

Dans cet exemple, la méthode Deposit est publique de telle sorte que les utilisateurs de cette classe puissent déposer de l'argent sur un compte en faisant appel à la méthode Deposit.

La surcharge de méthodes se produit lorsqu'une classe contient deux ou plusieurs méthodes portant le même nom, mais des signatures différentes. Prenons un exemple de méthode surchargée : la méthode MessageBox.Show. La méthode Show propose douze surcharges. Grâce à ces surcharges, les utilisateurs de la méthode disposent d'une plus grande souplesse.

Pour surcharger une méthode, utilisez le mot clé Overloads. Le mot clé Overloads déclare une propriété ou une méthode sous le même nom qu'un membre existant, mais avec une liste de paramètres qui diffère de celle du membre d'origine.

Introduction

Exemple

Surcharge de méthodes


L'exemple suivant montre une méthode surchargée, appelée Execute. La première méthode Execute ne s'accompagne d'aucun paramètre. La deuxième s'accompagne d'une chaîne.

Public Overloads Sub Execute( ) ... End Sub Public Overloads Sub Execute(ByVal connection As String) ... End Sub



! Ajout d'une propriété :

Public Class BankAccountPrivate customerName As String

Public Property Name( ) As StringGet

Return customerNameEnd GetSet(ByVal Value As String)

customerName = ValueEnd Set

End Property

End Class

Public Class BankAccountPrivate customerName As String

Public Property Name( ) As StringGet

Return customerNameEnd GetSet(ByVal Value As String)

customerName = ValueEnd Set

End Property

End Class


Vous pouvez ajouter des propriétés à une nouvelle classe de votre projet. Vous pouvez affecter la propriété et pouvez en extraire la valeur de la classe.

Pour ajouter des membres propriété à une classe, vous définissez généralement une donnée membre publique et des procédures de propriété publiques. Dans Visual Basic .NET, vous pouvez exécuter deux types de procédure sur les propriétés : Get et Set.

! La procédure Get permet d'extraire de la classe la valeur de la propriété. Vous ne pouvez pas modifier la valeur.

! La procédure Set permet d'affecter la propriété.

Dans l'exemple suivant, une propriété appelée Name est ajoutée à la classe :

Public Class BankAccount Private customerName As String Public Property Name( ) As String Get Return customerName End Get Set(ByVal Value As String) customerName = Value End Set End Property End Class

Utilisez le spécificateur ReadOnly dans la déclaration de la propriété pour ne créer que la propriété Get. Utilisez le spécificateur WriteOnly dans la déclaration de la propriété pour ne créer que la propriété Set.

Introduction


Exemple

ReadOnly et WriteOnly


Création d'une instance d'une classe

! Utilisation du mot clé New pour créer une instance de la classe BankAccount :

Module Bank

Sub MainDim account As New BankAccount( )account.Deposit(500.00)

End Sub

End Module

Module Bank

Sub MainDim account As New BankAccount( )account.Deposit(500.00)

End Sub

End Module


Pour exécuter les méthodes et utiliser les propriétés d'une classe, vous devez créer une instance de la classe. Une instance de la classe est appelée un objet.

Pour créer une instance d'une classe, vous déclarez une variable du type de la classe et utilisez le mot clé New, comme le montre la ligne de code suivante :

Dim NomObjet As New TypeObjet( )

L'exemple suivant montre comment créer une instance de la classe BankAccount à l'aide du mot clé New :

Sub Main Dim account As New BankAccount( ) account.Deposit(500.00) End Sub

Introduction

Syntaxe

Exemple


Application pratique : Création d'une classe

! Au cours de cette application pratique, vous allez créer une classe BankAccountet y ajouter des méthodes et des propriétés


Au cours de cette application pratique, vous allez créer une classe BankAccount et y ajouter des méthodes et des propriétés.

! Ajout d'une classe à un projet 1. Ouvrez une nouvelle application Microsoft Windows® dans

Visual Basic .NET. Créez un nouveau projet nommé SimpleClass dans dossier_installation\Practices\Mod07.

2. Dans le menu Projet, cliquez sur Ajouter une classe. 3. Dans la boîte de dialogue Ajouter un nouvel élément, nommez la classe

BankAccount.vb, puis cliquez sur Ouvrir.

! Ajout de données membres, de méthodes et de propriétés à la classe 1. Ajoutez une donnée membre privée appelée customerBalance de type

Double, comme indiqué dans la ligne de code suivante : Private customerBalance As Double

2. Ajoutez une autre donnée membre privée appelée customerName de type

String, comme indiqué dans la ligne de code suivante : Private customerName As String

3. Créez une méthode publique, appelée Deposit, suivie d'un paramètre

amount de type Double par valeur, comme indiqué ci-dessous : Public Sub Deposit(ByVal amount As Double) End Sub


4. Dans la méthode, augmentez la valeur du solde en lui ajoutant la valeur de amount comme indiqué ci-dessous : customerBalance += amount

5. Créez une propriété appelée Name, comme indiqué ci-dessous :

Public Property Name( ) As String End Property

6. Dans le bloc Get de la propriété, renvoyez customerName, comme indiqué

ci-dessous : Get Return customerName End Get

7. Dans le bloc Set de la propriété, affectez Value à customerName, comme

indiqué ci-dessous : Set(ByVal Value As String) customerName = Value End Set

8. Créez une propriété en lecture seule appelée Balance qui renvoie le solde

actuel, comme indiqué ci-dessous : Public ReadOnly Property Balance( ) As Double Get Return customerBalance End Get End Property


Le code complet de la classe BankAccount doit ressembler à ce qui suit :

Public Class BankAccount Private customerBalance As Double Private customerName As String Public Sub Deposit(ByVal amount As Double) customerBalance += amount End Sub Public ReadOnly Property Balance( ) As Double Get Return customerBalance End Get End Property Public Property Name( ) As String Get Return customerName End Get Set(ByVal Value As String) customerName = Value End Set End Property End Class

! Création d'un module TestHarness pour tester la classe BankAccount 1. Ajoutez un module appelé TestHarness.vb au projet. 2. Créez une procédure Sub publique, appelée Main, comme indiqué

ci-dessous : Public Sub Main( ) End Sub

3. Sous Sub Main, créez une instance de la classe BankAccount, comme

indiqué ci-dessous : Dim account As New BankAccount( )

4. Utilisez la propriété Name pour affecter le nom du titulaire au compte,

comme indiqué ci-dessous : account.Name = "Joe"

5. Utilisez la méthode Deposit pour déposer de l'argent sur le compte, comme

indiqué ci-dessous : account.Deposit(500)

6. Créez un message pour afficher l'intitulé et le solde du compte, comme

indiqué ci-dessous : MessageBox.Show ("Nom : " & account.Name & _ ". Solde : " & account.Balance() & " €")


7. Modifiez l'objet de démarrage pour que le projet utilise Sub Main. 8. Compilez et exécutez le programme. Le code complet du module TestHarness doit ressembler à ce qui suit :

Module TestHarness Public Sub Main( ) Dim account As New BankAccount( ) account.Name = "Joe" account.Deposit(500) MessageBox.Show("Nom : " & account.Name & _ ". Solde : " & account.Balance() & " €") End Sub End Module

Les fichiers solution de cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod07\CreatingClass\Solution.

Fichiers solution


Utilisation des constructeurs

! Exécute le code lorsque l'objet est instancié

Public Sub New(ByVal i As Integer) ' Surchargé sans le mot clé Overloads' Effectue une initialisation plus complexevalue = i

End Sub

Public Sub New(ByVal i As Integer) ' Surchargé sans le mot clé Overloads' Effectue une initialisation plus complexevalue = i

End Sub

! Peut surcharger, mais n'utilise pas le mot clé Overloads

Public Sub New( )

' Effectue une initialisation simpleintValue = 1

End Sub

Public Sub New( )

' Effectue une initialisation simpleintValue = 1

End Sub


Dans Visual Basic .NET, vous commandez l'initialisation des nouveaux objets au moyen des constructeurs. Pour créer un constructeur pour une classe, créez une procédure appelée Sub New n'importe où dans la définition de la classe.

Le constructeur Sub New présente les caractéristiques suivantes :

! Le code figurant dans le bloc Sub New sera systématiquement exécuté avant tout autre code d'une classe.

! Le constructeur Sub New ne sera exécuté qu'une seule fois, lors de la création d'un objet.

L'exemple suivant montre comment utiliser le constructeur Sub New :

Public Sub New( ) 'Effectue une initialisation simple intValue = 1 End Sub

Avec la ligne de code suivante, vous créez un objet à partir d'une classe appelée BankAccount et déjà définie dans l'application.

Dim myAccount As New BankAccount( )

Vous pouvez surcharger New et créer autant de constructeurs de classe que nécessaire. Cette opération peut se révéler utile si vous souhaitez initialiser votre objet lors de sa création.

Introduction

Caractéristiques de Sub New

Exemple de Sub New


Vous pouvez surcharger des constructeurs, tout comme il est possible de surcharger n'importe quelle autre méthode dans une classe. Toutefois, le mot clé Overloads ne peut pas être utilisé pour surcharger des constructeurs. L'exemple ci-dessous montre comment surcharger New et créer plusieurs constructeurs de classes :

Class BankAccount Private balance as Double Sub New( ) ' Initialisation du solde balance = 0.0 End Sub Sub New(ByVal amount As Double) balance = amount End Sub End Class

Dans l'exemple ci-dessus, l'un des constructeurs est suivi d'un paramètre. Si vous créez un objet à partir d'une classe de cette nature, vous pouvez inclure ses paramètres dans la déclaration. L'exemple suivant montre comment appeler la méthode New accompagnée d'un paramètre.

Dim myAccount As New BankAccount(120.00)

Surcharge de constructeurs


Utilisation des destructeurs

! Utilisés pour le nettoyage des ressources

! Appelés au moment de l'exécution avant la destruction de l�objet

" Important : La destruction peut ne pas avoir lieu immédiatement

Protected Overrides Sub Finalize( )

' Peut fermer des connexions ou d'autres ressources

conn.Close

End Sub

Protected Overrides Sub Finalize( )

' Peut fermer des connexions ou d'autres ressources

conn.Close

End Sub


Dans Visual Basic .NET, il est possible de déterminer ce qui se produit lors de la destruction d'objets au moyen de procédures appelées destructeurs.

Le système appelle le destructeur Finalize avant de libérer l'objet. Vous pouvez l'utiliser pour nettoyer toutes les ressources ouvertes, telles que les connexions aux bases de données, ou pour libérer d'autres ressources. Il est toutefois important de signaler qu'un retard est constaté entre le moment où l'objet perd sa portée et où le destructeur Finalize est appelé.

L'exécution de Sub Finalize entraînant une légère perte de performances, mieux vaut ne définir une méthode Sub Finalize qu'en cas de libération explicite des objets.

Visual Basic .NET autorise une deuxième sorte de destructeur, appelé Dispose, qui peut être appelé explicitement à tout moment pour libérer immédiatement des ressources. Dispose ne fait pas l'objet de ce cours. Pour plus d'informations sur Dispose, consultez « Durée de vie d�un objet : création et destruction des objets » dans la documentation de Visual Studio .NET.

L'exemple ci-dessous montre comment utiliser le destructeur Finalize :

Protected Overrides Sub Finalize( ) 'Peut fermer des connexions ou d'autres ressources conn.Close End Sub

Protected est un modificateur d'accès qui définit le niveau d'accès autorisé.

Introduction

Finalize et Dispose

Remarque

Exemple de Sub Finalize


Leçon : Utilisation des membres partagés

! Utilisation des données membres partagées

! Utilisation des méthodes partagées


Cette leçon explique comment utiliser des données membres et des méthodes partagées. Il est également possible de recourir à des membres partagés pour les compteurs et tout type de données courantes ou de méthodes courantes dont la présence est requise par toutes les instances d'une classe.


! Utilisation des données membres partagées ! Utilisation des méthodes partagées ! Application pratique : Création de méthodes partagées


! utiliser des données membres partagées pour répartir des données dans des instances de classe ;

! utiliser des méthodes partagées.

Introduction




Utilisation des données membres partagées

! Les données membres partagées permettent àplusieurs instances d'une classe de faire référence àune même variable de niveau classe

SavingsAccount.InterestRate = 0.03SavingsAccount.InterestRate = 0.03

Class SavingsAccountPublic Shared InterestRate As DoublePublic Name As String, Balance As Double

. . .

End Class

Class SavingsAccountPublic Shared InterestRate As DoublePublic Name As String, Balance As Double

. . .

End Class


Dans Visual Basic .NET, vous pouvez utiliser des données membres partagées pour permettre à plusieurs instances d'une classe de faire référence à une même variable de niveau classe.

Utilisez la syntaxe suivante pour déclarer les données membres partagées :

NiveauAccès Shared DonnéesMembre As TypeDonnées

Les données membres partagées sont directement liées à la classe, et vous pouvez les déclarer en tant que publiques ou privées. Si vous déclarez des données membres en tant que publiques, celles-ci sont accessibles à tout code capable d'accéder à la classe. Si vous déclarez des données membres en tant que privées, précisez des propriétés partagées publiques pour accéder à la propriété partagée privée.

L'exemple ci-dessous montre comment créer une classe SavingsAccount qui utilise une donnée membre publique pour mettre à jour les taux d'intérêt d'un compte d'épargne :

Class SavingsAccount Public Shared InterestRate As Double Public Function CalculateInterest( ) As Double ... End Function End Class

La valeur de la donnée membre InterestRate de la classe SavingsAccount peut être définie globalement indépendamment du nombre d'instances de la classe utilisé. Cette valeur est ensuite employée pour calculer l'intérêt sur le solde courant.

Introduction

Syntaxe

Niveaux d'accès

Exemple


Après avoir créé une classe qui utilise des données membres partagées publiques, vous pouvez appeler les données membres de cette classe à partir d'une application cliente. Le code suivant montre comment appeler la classe SavingsAccount et ses données membres à partir d'une application cliente :

Sub Test( ) SavingsAccount.InterestRate = 0.03 Dim myAccount As New SavingsAccount( ) Dim yourAccount As New SavingsAccount( ) MessageBox.Show(myAccount.CalculateInterest( )) MessageBox.Show(yourAccount.CalculateInterest( )) End Sub

Lorsque vous étudiez ce code, gardez à l'esprit les points suivants :

! InterestRate peut être définie préalablement et ultérieurement à la création de toutes les instances de la classe SavingsAccount.

! Toute modification apportée à InterestRate s'appliquera à l'ensemble des instances de la classe SavingsAccount.

Vous pouvez également créer des propriétés partagées dans vos classes. L'exemple suivant montre comment déclarer une propriété partagée, appelée Rate, dans la classe SavingsAccount :

Class SavingsAccount Private Shared InterestRate As Double Shared Property Rate( ) As Double Get Return InterestRate End Get Set(ByVal Value As Double) interestRate = Value End Set End Property End Class

Une fois la propriété partagée Rate déclarée, vous pouvez l'utiliser dans une application cliente au lieu d'accéder directement à la donnée membre partagée interestRate. Vous pouvez appeler une propriété partagée en la qualifiant soit avec le nom de la classe, soit avec le nom de variable d'une instance spécifique de la classe.

Le code ci-dessous montre comment appeler une propriété partagée en la qualifiant avec le nom de la classe :

SavingsAccount.Rate = 0.03

Le code ci-dessous montre comment appeler une propriété partagée en utilisant le nom de variable d'une instance spécifique de la classe :

myAccount.Rate = 0.04

Appel de données membres partagées à partir d'un client

Propriétés partagées

Appel de propriétés partagées à partir d'un client


Utilisation des méthodes partagées

! Peuvent être utilisées sans déclarer une instance de classe

! Ne peuvent accéder qu'aux données partagées

'Code de classe de testPublic Shared Function GetComputerName( ) As String...End Function

'Code de classe de testPublic Shared Function GetComputerName( ) As String...End Function

'Code clientMessageBox.Show(TestClass.GetComputerName( ))

'Code clientMessageBox.Show(TestClass.GetComputerName( ))


Vous pouvez utiliser des membres de procédure partagés pour concevoir des fonctions pouvant être appelées sans créer une instance de cette classe. Les procédures partagées sont des méthodes de classe qui ne sont associées à aucune instance spécifique d'une classe. Les membres de procédure partagés ne peuvent accéder qu'aux données accompagnées du mot clé Shared. Par exemple, une méthode partagée ne peut pas faire référence à un membre d'instance d'une classe.

L'exemple ci-dessous montre comment une fonction fréquemment utilisée (GetComputerName, par exemple) peut être créée en tant que membre de procédure partagé afin qu'une application cliente puisse aisément l'utiliser. Il suffit au client de référencer la méthode précédée par le nom de classe puisque aucune instance de cette classe n'est nécessaire.

'Code de classe de test Public Shared Function GetComputerName( ) As String ... End Function 'Code client MessageBox.Show(TestClass.GetComputerName( ))

Remarquez également que, dans le code ci-dessus, Show est une méthode partagée de la classe MessageBox.

Introduction

Exemple d'utilisation d'un membre de procédure partagé


Application pratique : Création de méthodes partagées

! Au cours de cette application pratique, vous allez effectuer les tâches suivantes :

" Création d'une classe

" Ajout de méthodes partagées

" Utilisation de méthodes partagées


Au cours de cette application pratique, vous allez créer et utiliser une classe dotée d'une méthode partagée qui convertit les degrés Fahrenheit en degrés Celsius.

! Création d'une classe 1. Ouvrez une nouvelle application Windows dans Visual Basic .NET. Créez

un nouveau projet appelé TemperatureApplication dans dossier_installation\Practices\Mod07\SharedMethod.

2. Créez une classe et appelez-la TemperatureConverter. 3. Ajoutez-y une méthode partagée appelée FahrenheitToCelsius, comme

indiqué ci-dessous : Public Shared Function FahrenheitToCelsius _ (ByVal degreesFahrenheit As Double) As Double End Function

4. Utilisez la formule suivante dans votre fonction afin de calculer la

température en degrés Celsius. Renvoyez le résultat obtenu de la fonction. (degreesFahrenheit - 32) * 5 / 9

Votre code doit ressembler à ce qui suit : Public Shared Function FahrenheitToCelsius _ (ByVal degreesFahrenheit As Double) As Double Return (degreesFahrenheit - 32) * 5 / 9 End Function


! Appel des méthodes de la classe 1. Ouvrez Form1 dans votre projet. 2. Ajoutez un contrôle Button au formulaire. 3. Modifiez l'événement Click du bouton afin d'appeler la méthode partagée,

comme le montrent les lignes de code ci-dessous : MessageBox.Show(TemperatureConverter.FahrenheitToCelsius _ (212))

4. Exécutez le programme et vérifiez le résultat. 5. Quittez l'application.

Les fichiers solution de cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod07\SharedMethod\Solution.

Fichiers solution


Leçon : Héritage, polymorphisme et espaces de noms

héritagehéritage

polymorphismepolymorphisme

structures et classes

structures et classes

espaces de noms

espaces de noms


Vous pouvez ajouter des fonctionnalités aux classes de Microsoft .NET Framework ou à vos propres classes à l'aide de l'héritage et du polymorphisme. Cette leçon explique ce que sont l'héritage et le polymorphisme. Cette leçon compare également les classes et les structures.


! Présentation de l'héritage ! Héritage d'une classe ! Présentation du polymorphisme ! Comparaison entre classes et structures ! Organisation des classes en espaces de noms


! expliquer le concept d'héritage ; ! expliquer le concept de polymorphisme ; ! comparer les classes aux structures ; ! expliquer ce qu'est un espace de noms.

Introduction




Présentation de l'héritage

! L'héritage spécifie une relation « de type »

! Plusieurs classes partagent les mêmes attributs et opérations, ce qui permet une réutilisation efficace du code

! Exemples :" Un client « est un type de » de personne

" Un employé « est un type de » de personne

Customer(Client)

Employee(Employé)

Person(Personne)

Classe de base

Classes dérivées


En programmation orientée objet, vous pouvez transmettre les caractéristiques d'une classe de base aux autres classes qui en sont dérivées. Cette opération s'appelle l'héritage.

L'héritage est le concept selon lequel des attributs et des opérations d'une classe de base sont réutilisés dans une classe dérivée.

Imaginez trois classes : Customer, Employee et Person. Les attributs et les opérations de la classe de base Person peuvent également s'appliquer à Customer ou à Employee. Il est donc pratique et efficace de réutiliser ces attributs et ces opérations.

Visual Basic .NET prend en charge l'héritage simple au niveau de la classe. Autrement dit, une classe ne peut hériter que d'une seule classe de base. C'est ce qui s'est produit dans l'exemple de l'illustration précédente. D'autres langages, tels que C++, permettent à une classe d'hériter de plusieurs autres.

Introduction

Définition

Exemple d'héritage


Héritage d'une classe

! Une classe dérivée hérite d'une classe de base

! Les propriétés, méthodes, données membres, événements et gestionnaires d'événements peuvent être hérités (selon la portée)

! Mots clés

" Inherits : Hérite de la classe de base

" NotInheritable : Ne peut pas être héritée

" MustInherit : Les instances de la classe ne peuventpas être créées ; doit être héritée comme une classe de base


Dans Visual Basic .NET, vous pouvez recourir à l'héritage pour dériver une classe à partir d'une classe de base existante. La classe dérivée peut hériter de l'ensemble des propriétés de la classe de base, de ses méthodes, données membres, événements et gestionnaires d'événements, simplifiant ainsi la réutilisation du code de la classe de base dans une application.

Vous utilisez le mot clé Inherits pour définir la classe dérivée qui héritera de la classe de base existante.

L'exemple suivant montre comment utiliser l'attribut Inherits :

Public Class CheckingAccount Inherits BankAccount Private Sub ProcessCheck( ) ' Ajouter le code pour traiter un chèque tiré sur ce ' compte End Sub End Class

Vous pouvez utiliser le mot clé MyBase pour appeler les méthodes d'une classe de base lorsque vous substituez les méthodes dans une classe dérivée. Vous pouvez encore utiliser le mot clé MyBase pour appeler le constructeur et le destructeur de la classe de base dans votre classe dérivée.

Introduction

Mot clé Inherits

Exemple

Remarque


Vous utilisez le mot clé NotInheritable pour définir une classe qui ne peut pas servir de classe de base en cas d'héritage. Une erreur de compilation est générée si une autre classe tente d'hériter de cette classe.

L'exemple suivant montre comment utiliser l'attribut NotInheritable :

Public NotInheritable Class TestClass ... End Class Public Class DerivedClass 'La ligne ci-dessous génère une erreur de compilation Inherits TestClass ... End Class

Vous devez employer le mot clé MustInherit pour définir les classes qui ne sont pas destinées à un usage immédiat en tant qu'objets instanciés. La classe résultante doit être héritée comme une classe de base pour être utilisée dans une classe dérivée instanciée.

L'exemple suivant montre comment utiliser l'attribut MustInherit :

Public MustInherit Class BaseClass ... End Class ...

Si le code client tente de créer une instance de ce type de classe, une erreur de compilation est générée, comme indiqué dans l'exemple suivant :

'Code client 'La ligne ci-dessous génère une erreur de compilation Dim x As New BaseClass( )

Vous devez recourir à un accès Protected (protégé) pour limiter la portée d'une propriété, d'une méthode, d'une donnée membre, d'un événement ou d'un gestionnaire d'événements à la classe de définition et à toute classe dérivée fondée sur cette classe de base.

L'exemple suivant montre comment utiliser l'attribut Protected :

Public Class BaseClass 'Accessible de partout Public counter As Integer 'Accessible uniquement dans cette classe ou dans une 'classe dérivée Protected name As String ... End Class

Mot clé NotInheritable

Exemple

Mot clé MustInheritd

Exemple

Mot clé Protected

Exemple


Présentation du polymorphisme

! Le nom de la méthode réside dans la classe de base

! Les implémentations de la méthode résident dans les classes dérivées

BaseTaxBaseTax

CalculateTax( )CalculateTax( )

CountyTaxCountyTax


CityTaxCityTax



Presque tous les systèmes de programmation orientée objet prennent en charge le polymorphisme au moyen de l'héritage. Le polymorphisme d'héritage impose de définir des méthodes dans une classe de base et de les remplacer par de nouvelles implémentations dans les classes dérivées.

Le polymorphisme est le concept selon lequel il est possible de définir plusieurs classes avec des méthodes ou des propriétés aux fonctions différentes, mais aux noms identiques, de façon à ce que le code client puisse les utiliser de manière interchangeable lors de l'exécution. Le nom de la méthode réside dans la classe de base. Les implémentations de la méthode résident dans les classes dérivées. À des fins de clarté, seul le nom de la méthode (et pas le code qui fournit la fonctionnalité de la méthode) peut être déclaré dans la classe de base.

Supposons que vous définissiez une classe appelée BaseTax, qui fournit les fonctionnalités de base pour calculer les taxes sur les ventes dans un État. Les classes dérivées de BaseTax (CountyTax ou CityTax, par exemple) pourraient implémenter des méthodes telles que CalculateTax.

Le polymorphisme sous-entend que l'implémentation de la méthode CalculateTax peut être différente dans chacune des classes dérivées. Le taux du comté peut, par exemple, différer du taux de la ville. Toutes les classes qui héritent de BaseTax disposeront d'une méthode CalculateTax, mais la façon dont la taxe sera réellement calculée pourra varier d'une classe dérivée à une autre.

Introduction

Définition

Exemple de polymorphisme


Comparaison entre classes et structures

ClassesClassesClasses StructuresStructuresStructuresPeuvent définir des données membres, des propriétés et des méthodes

Peuvent définir des données membres, des propriétés et des méthodes

Peuvent définir des donnée membres, des propriétés et des méthodesPeuvent définir des donnée membres, des propriétés et des méthodes

Prennent en charge les constructeurset l'initialisation des membres

Prennent en charge les constructeurset l'initialisation des membres

Aucun constructeur par défaut et aucuneinitialisation des membresAucun constructeur par défaut et aucuneinitialisation des membres

Prennent en charge la méthodeFinalize

Prennent en charge la méthodeFinalize

Ne prennent pas en charge la méthodeFinalizeNe prennent pas en charge la méthodeFinalize

Extensibles par héritageExtensibles par héritage Ne prennent pas en charge l'héritageNe prennent pas en charge l'héritage

Type de données référenceType de données référence Type de données valeurType de données valeur


Les classes et les structures sont similaires sur plusieurs plans : toutes deux peuvent définir des données membres, des propriétés et des méthodes. Toutefois, les classes proposent quelques fonctionnalités avancées dont vous pouvez tirer parti.

Le tableau ci-dessous compare les classes aux structures.

Classes Structures

Initialisation Prennent en charge les constructeurs et l'initialisation des membres.

Aucun constructeur par défaut et aucune initialisation des membres.

Méthode Finalize Prennent en charge la méthode Finalize. Ne prennent pas en charge la méthode Finalize. Vous devez libérer les ressources manuellement .

Héritage Extensibles par héritage. Ne prennent pas en charge l'héritage.

Type de données Type de données référence.

Lorsqu'une variable d'objet est passée à une fonction, c'est la référence d'adresse des données qui est passée et non les données elles-mêmes.

L'assignation d'une variable de classe à une autre pointe les deux variables vers le même objet. Par conséquent, toute mise à jour d'une variable affectera l'autre.

Type de données valeur.

Lorsqu'une variable de structure est passée à une fonction, les données réelles doivent être copiées vers cette fonction.

L'assignation d'une variable de structure à une autre crée une véritable copie de la structure. Par conséquent, les mises à jour opérées sur l'une de ces variables seront sans effet sur l'autre.

Les types de données ont un impact considérable sur l'application en termes de performances. Une classe comportant beaucoup de données internes donnera de meilleures performances qu'une structure de données imposantes dans ces conditions.

Introduction


Organisation des classes en espaces de noms

! Les espaces de noms servent de systèmed'organisation

! Les espaces de noms fournissent des noms qualifiés complets pour les classes

" Exemple : System.Windows.Forms.Button

! Pour importer un espace de noms :

" Au niveau du projet, vous devez inclure une référence àla DLL qui contient l'espace de noms

" Vous devez utiliser le mot clé Imports


Les espaces de noms servent de système d'organisation ; ils permettent de présenter des composants de programme liés logiquement dont peuvent disposer les autres programmes et applications. Un espace de noms peut contenir aussi bien d'autres espaces de noms que des types.

L'espace de noms System.Windows.Forms est un parfait exemple d'espace de noms. Cet espace de noms fournit les classes appropriées nécessaires à la création des formulaires. L'espace de noms Forms est contenu dans l'espace de noms Windows, lui-même contenu dans l'espace de noms System.

Pour faire référence à une classe à l'aide d'un nom qualifié complet, vous devez utiliser l'espace de noms auquel la classe appartient comme préfixe du nom de la classe. Par exemple, le nom qualifié complet de la classe Button est System.Windows.Forms.Button. Grâce aux noms qualifiés complets, vous pouvez déclarer deux classes de même nom dans des espaces de noms, sans aucun risque de conflit. Par défaut, chaque fichier exécutable que vous créez avec Visual Basic .NET contient une espace de noms portant le nom de votre projet.

Les espaces de noms sont toujours de type Public, de façon à ne pas pouvoir déclarer un espace de noms avec un modificateur d'accès. Toutefois, les composants de l'espace de noms peuvent bénéficier d'un accès de type Public ou Friend. Si le modificateur d'accès n'est pas mentionné, l'accès est de type Friend par défaut.

Dans Visual Basic .NET, vous utilisez l'instruction Namespace pour définir un nouvel espace de noms qui encapsule les classes que vous créez, comme le montre l'exemple ci-dessous :

Namespace CompVB Public Class StringComponent ... End Class End Namespace

Introduction

Exemple d'espace de noms

Noms qualifiés complets

Droits d'accès

Définition d'un espace de noms


Au niveau du projet, vous devez inclure une référence à la bibliothèque de liaison dynamique (DLL � dynamic-link library) qui contient l'espace de noms. Dans Visual Basic .NET, vous utilisez l'instruction Imports pour importer les types contenus dans l'espace de noms donné afin qu'il soit possible d'y faire référence directement. Le code ci-dessous montre comment utiliser l'instruction Imports :

Imports System.Windows.Forms Public Class Form1 Inherits Form

Si vous omettez l'instruction Imports, vous devrez utiliser le nom complet de l'espace de noms, comme le montre l'exemple ci-dessous :

Public Class Form1 Inherits System.Windows.Forms.Form

Utilisation d'un espace de noms



! Compréhension des classes

! Utilisation des classes

! Utilisation des membrespartagés

! Héritage, polymorphismeet espaces de noms

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


1. Lors de la conception d'une application de dépôt direct, les développeurs analysent tous les objets afin de garder les objets appropriés et de rejeter tous les autres. Comment s'appelle ce processus ? Abstraction.

2. Dans une application de dépôt direct, les mécanismes internes et l'implémentation sont dissimulés à l'utilisateur. Comment s'appelle ce processus ? Encapsulation.

3. Écrivez le code qui permet de créer une classe publique, appelée Student, qui possède une donnée membre d'instance privée nommée testScore de type Integer. Public Class Student

Private testScore As Integer

End Class


4. Écrivez le code voulu pour ajouter à la classe Student une propriété en lecture seule appelée Score. Public Class Student

Private testScore As Integer

Public ReadOnly Property Score( ) As Integer

Get

Return testScore

End Get

End Property

End Class

5. Expliquez ce que font Sub New et Sub Finalize. Sub New est un constructeur qui sert à contrôler l'initialisation des nouveaux objets. Sub Finalize est un destructeur qui sert à contrôler ce qui se passe au cours de la destruction des objets.

6. Pouvez-vous hériter de plusieurs classes dans Visual Basic .NET ? Non. Visual Basic .NET ne prend en charge que l'héritage simple au niveau de la classe.


Atelier 7.1 : Création d'une classe dérivée

! Exercice 1 : Création d'une classe dérivéede formulaire


À la fin de cet atelier, vous serez à même de créer une classe dérivée ainsi que ses méthodes.


Avant de poursuivre, vous devez savoir :

! créer une classe dans Visual Basic .NET ; ! déclarer des données membres et des méthodes dans une classe.


Objectifs

Remarque


Fichiers solution



Exercice 1 Création d'une classe dérivée de formulaire

Dans cet exercice, vous allez créer une classe dérivée de formulaires. Cette classe héritera de la classe System.Windows.Forms. Vous y ajouterez des données membres, une méthode et un constructeur afin de créer une application de formulaire simple où s'affiche la date et l'heure actuelles.

! Création d'un nouveau projet 1. Démarrez Visual Studio .NET et créez un nouveau projet Visual Basic basé

sur le modèle Projet vide. 2. Nommez le projet SimpleWindowsApplication dans le dossier

dossier_installation\Labfiles\Lab071\Ex01\Starter, puis cliquez sur OK.

! Ajout de références au projet • Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

Références, puis cliquez sur Ajouter une référence. Dans la boîte de dialogue Ajouter une référence, sous l'onglet .NET, sélectionnez System.dll, System.Drawing.dll et System.Windows.Forms.dll. Cliquez sur Sélectionner après chaque sélection, puis cliquez sur OK.

! Ajout d'une nouvelle classe au projet 1. Ajoutez une nouvelle classe, appelée Clock, au projet

a. Dans le menu Projet, cliquez sur Ajouter un nouvel élément. b. Dans la boîte de dialogue Ajouter un nouvel élément, cliquez sur

Classe. c. Dans la zone Nom, tapez Clock.vb et cliquez sur Ouvrir.

2. Ajoutez l'instruction Imports au début du fichier Clock.vb afin d'importer l'espace de noms System.Windows.Forms. Votre code doit ressembler à ce qui suit : Imports System.Windows.Forms Public Class Clock End Class

! Héritage de la classe System.Windows.Forms.Form dans la classe Clock • Modifiez la déclaration de la classe Clock pour que cette dernière hérite de

la classe System.Windows.Forms.Form, comme le montre l'exemple ci-dessous : Public Class Clock Inherits Form End Class


! Ajout de données membres à la classe Clock 1. Ajoutez une donnée membre privée appelée displayTimeLabel et de type

System.Windows.Forms.Label, comme indiqué ci-dessous : Private displayTimeLabel As Label

2. Ajoutez une donnée membre privée, appelée getTimeButton de type

System.Windows.Forms.Button, comme indiqué ci-dessous : Private WithEvents getTimeButton As Button

Le mot clé WithEvents permet à une variable d'objet de déclencher des événements.

! Ajout d'une méthode à la classe Clock 1. Ajoutez la méthode suivante à la définition de la classe.

Nom de la méthode Type Paramètres

Initialize Private Sub Aucun

2. Créez une instance du type Label à l'aide du mot clé New. Votre code doit ressembler à ce qui suit : Private Sub Initialize( ) Me.displayTimeLabel = New Label( ) End Sub

3. Écrivez le code voulu pour définir les propriétés de displayTimeLabel

conformément aux indications du tableau qui suit.

Propriété Valeur

BorderStyle BorderStyle.Fixed3D

Left 104

Top 56

Height 30

Width 130

Votre code doit ressembler à ce qui suit : Me.displayTimeLabel.BorderStyle = BorderStyle.Fixed3D Me.displayTimeLabel.Left = 104 Me.displayTimeLabel.Top = 56 Me.displayTimeLabel.Height = 30 Me.displayTimeLabel.Width = 130

4. Ajoutez displayTimeLabel à la collection de contrôles du formulaire,

comme indiqué ci-dessous : Me.Controls.Add(displayTimeLabel)

Remarque


5. Créez une instance du type Button, comme indiqué ci-dessous : Me.getTimeButton = New Button( )

6. Écrivez le code voulu pour définir les propriétés de getTimeButton

conformément aux indications du tableau qui suit.

Propriété Valeur

FlatStyle FlatStyle.Flat

Left 128

Top 104

Text Date Heure

Votre code doit ressembler à ce qui suit : Me.getTimeButton.FlatStyle = FlatStyle.Flat Me.getTimeButton.Left = 128 Me.getTimeButton.Top = 104 Me.getTimeButton.Text = "Date Heure"

7. Ajoutez getTimeButton à la collection de contrôles du formulaire, comme

indiqué ci-dessous : Me.Controls.Add(getTimeButton)

Le code complet de la méthode Initialize de la classe Clock doit ressembler à ce qui suit : Private Sub Initialize( ) Me.displayTimeLabel = New Label( ) Me.getTimeButton = New Button( ) Me.displayTimeLabel.BorderStyle = BorderStyle.Fixed3D Me.displayTimeLabel.Left = 104 Me.displayTimeLabel.Top = 56 Me.displayTimeLabel.Height = 30 Me.displayTimeLabel.Width = 130 Me.Controls.Add(displayTimeLabel) Me.getTimeButton.FlatStyle = FlatStyle.Flat Me.getTimeButton.Left = 128 Me.getTimeButton.Top = 104 Me.getTimeButton.Text = "Date Heure" Me.Controls.Add(getTimeButton) End Sub


! Ajout d'un constructeur à la classe Clock 1. Créez un constructeur pour la classe Clock, comme indiqué ci-dessous :

Sub New( ) End Sub

2. Dans le constructeur, ajoutez un appel au constructeur de la classe de base et

à la méthode Initialize, comme indiqué ci-dessous : MyBase.New( ) Initialize( )

! Ajout de code à l'événement Click de getTimeButton 1. Créez un gestionnaire d'événements pour l'événement Click de

getTimeButton. 2. Ajoutez du code pour afficher la date et l'heure actuelles dans le contrôle

displayTimeLabel. Votre code doit ressembler à ce qui suit : Private Sub getTimeButton_Click (...) Me.displayTimeLabel.Text = Now( ) End Sub

! Modification de l'objet de démarrage • Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet

SimpleWindowsApplication, puis cliquez sur Propriétés. Dans la boîte de dialogue Objet de démarrage, modifiez l'objet de démarrage en Clock.

! Test de l'application 1. Compilez et exécutez l'application. Cliquez sur le bouton Date Heure pour

afficher la date et l'heure actuelles. 2. Quittez l'application.

Table des matières

Vue d'ensemble 1

Leçon : Types d'erreurs 2

Leçon : Utilisation du débogueur 8

Leçon : Gestion des exceptions 33


Atelier 8.1 : Mise en �uvre de la gestion structurée des exceptions 49

Module 8 : Gestion des erreurs et des exceptions


Module 8 : Gestion des erreurs et des exceptions iii

Notes de l'instructeur Dans ce module, les stagiaires découvriront les types d'erreurs susceptibles de survenir dans un programme ainsi que les outils de débogage de Microsoft® Visual Basic® .NET qui leur permettront de diagnostiquer et de corriger ces erreurs. Ce module explique comment utiliser le débogueur de Microsoft Visual Studio® .NET, les fenêtres de débogage et la gestion structurée des exceptions pour déboguer un programme.


! citer des exemples d'erreurs de syntaxe, d'exécution et de logique ; ! déboguer du code à l'aide de la barre d'outils Déboguer, des points d'arrêt,

des commandes Pas à pas, de la syntaxe Exécuter jusqu'au curseur, des fenêtres de débogage et de la fenêtre Commande ;

! appliquer la gestion structurée des exceptions à du code.


! Fichier Microsoft PowerPoint® 2560A_08.ppt ! Fichier de démonstration multimédia 2560A_08d005.wmv


! lire tous les documents de cours relatifs à ce module ; ! réaliser l'application pratique et l'atelier de ce module ; ! passer en revue la démonstration multimédia ; ! suivre les étapes des trois démonstrations dirigées.

Présentation et application pratique : 105 minutes Atelier : 45 minutes

Documents de cours

Préparation

iv Module 8 : Gestion des erreurs et des exceptions


Leçon : Types d'erreurs Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon. Dans la démonstration dirigée, en fin de leçon, vous présenterez aux stagiaires un exemple de chaque type d'erreur susceptible de se produire dans un environnement de développement Microsoft Visual Studio .NET.

À ce stade du cours, les stagiaires doivent être familiarisés avec la notion d'erreur de syntaxe mais le terme leur est peut-être inconnu. C'est peut-être pour vous l'occasion de présenter la fenêtre Liste des tâches et de montrer aux stagiaires comment y ajouter des tâches et les visualiser en même temps que les erreurs de syntaxe non résolues.

Insistez sur le fait qu'une erreur d'exécution non résolue peut être la cause d'un programme qui ne répond plus. Dans ce module, les stagiaires apprendront à tester, à isoler et à écrire des gestionnaires structurés d'exceptions pour du code susceptible de provoquer une erreur d'exécution.

Citez aux stagiaires quelques exemples personnels d'erreurs de logique. Vous présenterez un exemple d'erreur de logique lors de la démonstration dirigée.

Au cours de cette démonstration, vous présenterez des exemples d'erreurs de syntaxe, d'exécution et de logique. Les étapes à suivre lors de cette démonstration sont énoncées dans la section Démonstrations des notes de l'instructeur.

Leçon : Utilisation du débogueur Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de la leçon.

Cette démonstration explique comment utiliser des points d'arrêt, parcourir chaque ligne du code et examiner ses variables à l'aide de la fenêtre Espion pour déboguer une application.

Pour la réaliser, cliquez sur l'icône située au centre de la diapositive relative à cette rubrique. Si vous préférez mener cette démonstration multimédia sous forme de démonstration dirigée, les étapes à suivre dans ce cas sont décrites dans la section Démonstrations des notes de l'instructeur.

Pour plus d'informations sur les paramètres corrects à définir pour garantir une présentation visuelle optimale des démonstrations multimédia, reportez-vous à la Liste de préparation au cours incluse dans le kit de l'instructeur.

Présentation des erreurs de syntaxe

Présentation des erreurs d'exécution

Présentation des erreurs de logique

Démonstration dirigée : Types d'erreurs

Présentation multimédia : Procédure de débogage d'une application

Module 8 : Gestion des erreurs et des exceptions v

Présentez aux stagiaires la zone de liste déroulante à partir de laquelle ils peuvent choisir de créer la version déboguée ou la version finale d'une application. Insistez sur le fait qu'ils peuvent sélectionner le mode arrêt uniquement lorsque l'application est créée à l'aide d'une version déboguée. Montrez-leur où le mot [break] apparaît dans l'environnement de développement Microsoft Visual Studio .NET pour indiquer que l'application est passée en mode arrêt. Vous pouvez aussi faire appel à la capture d'écran disponible dans les notes du stagiaire.

Ouvrez un projet dans l'éditeur de code, puis montrez aux stagiaires comment définir et supprimer un point d'arrêt. Ouvrez la fenêtre Points d'arrêt mais n'abordez pas en détail les propriétés Condition et Nombre d'accès. Elles le seront dans la rubrique suivante.

Montrez comment définir les propriétés Condition et Nombre d'accès, puis citez un exemple illustrant le moment opportun de leur utilisation. Vous pouvez aussi utiliser l'exemple fourni dans les notes du stagiaire.

Ce sujet peut être traité assez rapidement. Montrez aux stagiaires comment afficher la barre d'outils Déboguer si elle n'est pas visible. Signalez la présence de ses trois commandes Pas à pas (Pas à pas détaillé, Pas à pas sortant et Pas à pas principal) mais ne les décrivez pas en détail. Chacune de ces commandes sera présentée dans la rubrique suivante. Si vous n'avez pas présenté le bouton Points d'arrêt lors de la rubrique réservée aux points d'arrêt, montrez aux stagiaires comment ouvrir la fenêtre Points d'arrêt à partir de la barre d'outils Déboguer.

Expliquez la différence entre les commandes Pas à pas détaillé et Pas à pas principal. Si vous le souhaitez, vous pouvez ouvrir la solution LoanApplication.sln à partir du dossier dossier_installation\Labfiles\Lab051\ Ex02\solution. Utilisez cette application pour démontrer comment les deux commandes répondent dans l'appel de fonction.

Soulignez que la touche F11 correspond à la touche de raccourci de la commande Pas à pas détaillé. Les stagiaires utiliseront la commande Exécuter jusqu'au curseur dans l'atelier. Expliquez comment accéder à cette commande et décrivez sa fonction.

Au cours de cette démonstration, vous procéderez au débogage d'une application modèle conçue pour déterminer le prénom le plus long parmi cinq prénoms figurant dans un tableau. L'objectif de cette démonstration est d'expliquer comment déboguer une application à l'aide des fenêtres Automatique, Variables locales, Espion et Commande, des points d'arrêt et de la commande Exécuter jusqu'au curseur.

Les étapes à suivre lors de cette démonstration sont énoncées dans la section Démonstrations des notes de l'instructeur.

Montrez comment ouvrir chacune des fenêtres de débogage détaillées dans cette rubrique, puis expliquez la différence entre la fenêtre Espion et la boîte de dialogue Espion express.

Cette rubrique présente sommairement la fenêtre Commande à l'aide de laquelle les stagiaires peuvent déboguer des applications. Montrez-leur comment l'utiliser et expliquez la différence entre les modes Immédiat et Commande.

Présentation du mode arrêt

Utilisation des points d'arrêt

Modification des points d'arrêt

Barre d'outils Déboguer

Procédure d'analyse pas à pas du code

Démonstration dirigée : Utilisation des fenêtres de débogage

Utilisation des fenêtres de débogage

Utilisation de la fenêtre Commande

vi Module 8 : Gestion des erreurs et des exceptions

L'objectif de cette application pratique est de permettre aux stagiaires de passer en revue la procédure de débogage d'une simple application à l'aide de quelques outils présentés dans cette leçon. L'application pratique est conçue pour une durée de 45 à 60 minutes variant selon le temps nécessaire pour répondre aux questions et le niveau de vos stagiaires.

Il est primordial que les stagiaires comprennent le fonctionnement du code avant de tenter de localiser et de résoudre une erreur. Discutez des réponses aux questions dans la première partie de l'application pratique pour vérifier si le sujet est compris. Vous pouvez également montrer aux étudiants comment vérifier leurs propres réponses à l'aide du CD-ROM du stagiaire. À la fin de l'application pratique, commentez les suggestions de résolution du code des stagiaires.

Leçon : Gestion des exceptions Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de la leçon.

Insistez sur le fait que les exceptions sont stockées en tant qu'objets et que les stagiaires peuvent utiliser les propriétés d'un objet pour rechercher la cause et l'emplacement d'une exception. Vous pouvez aussi décrire, à titre d'exemple, les raisons susceptibles de causer chacune des exceptions présentées dans la diapositive.

Expliquez ce qui se passe lorsque survient une exception, plus particulièrement comment la recherche d'un gestionnaire dans la pile des appels progresse et peut, en définitive, provoquer la fermeture du programme si elle ne trouve aucun gestionnaire.

Expliquez comment le code est exécuté dans un bloc Try�Catch, surtout en présence de plusieurs instructions Catch. Décrivez le code fourni à titre d'exemple dans les notes du stagiaire.

Décrivez le code fourni à titre d'exemple dans les notes du stagiaire et soulignez que le code du bloc Finally est toujours exécuté, que des instructions Catch aient été exécutées ou non.

La syntaxe permettant de lever une exception est simple. Dans cette rubrique, demandez surtout à vos stagiaires à quel moment ils peuvent décider de lever une exception dans leur code.

Il est primordial que les stagiaires retiennent qu'ils ne doivent pas utiliser la gestion structurée des exceptions aveuglément ou dans toute situation impliquant obligatoirement la gestion d'une erreur. Prenez le temps d'aborder d'autres options de gestion des erreurs que la gestion structurée des exceptions. Expliquez pourquoi elle ne constitue pas la meilleure solution dans tous les cas.

Au cours de cette démonstration, les stagiaires analyseront le flux du code intervenant dans l'instruction Try�Catch lors de la mise en �uvre d'une gestion structurée des exceptions. Les étapes que vous devez suivre lors de cette démonstration sont énoncées dans la section Démonstrations des notes de l'instructeur.

Application pratique : Débogage du code

Classe Exception

Présentation de la gestion structurée des exceptions

Utilisation de l'instruction Try�Catch

Utilisation du bloc Finally

Procédure de déclenchement des exceptions

Principes d'utilisation de la gestion structurée des exceptions

Démonstration dirigée : Utilisation de la gestion structurée des exceptions

Module 8 : Gestion des erreurs et des exceptions vii

Contrôle des acquis Les questions de contrôle des acquis reposent principalement sur la maîtrise des concepts et sur les procédures abordées de manière détaillée dans ce module. Vous pouvez répondre aux questions posées sous forme de débat afin que tout le monde puisse tirer parti des réponses correctes.

1. L'objectif de cette question est de s'assurer que certains termes clés du module ont été compris.

2. Si les stagiaires éprouvent quelques difficultés de compréhension face à cette question, reportez-les à la rubrique Modification des points d'arrêt de ce module.

3. L'objectif de cette question est de s'assurer que le mécanisme de flux du code dans un bloc Try�Catch�Finally a été compris.

4. Demandez aux stagiaires de rédiger sur papier une réponse à cette question avant de dévoiler la réponse correcte.

5. Cette question reprend un des concepts clés de ce module. Si les stagiaires éprouvent quelques difficultés de compréhension face à cette question, prenez le temps de leur expliquer à nouveau le concept.

Atelier 8.1 : Mise en �uvre de la gestion structurée des exceptions

Au cours du premier exercice de cet atelier, les stagiaires ajouteront des instructions Try�Catch pour gérer des exceptions dans un programme existant qui ouvre et affiche le contenu d'un fichier texte. Lors du deuxième exercice, ils utiliseront des points d'arrêt et la commande Exécuter jusqu'au curseur pour déboguer une application, puis ajouteront un bloc Finally à une application.

Démonstrations Cette section fournit les instructions pas à pas propres aux démonstrations et décrit notamment la procédure à suivre pour mener des démonstrations multimédia sous forme de démonstrations dirigées.

Pour plus d'informations sur les paramètres corrects à définir pour garantir une présentation visuelle optimale des démonstrations multimédia, reportez-vous à la Liste de préparation au cours incluse dans le kit de l'instructeur.

Démonstration dirigée : Types d'erreurs Au cours de cette démonstration, vous présenterez des exemples d'erreurs de syntaxe, d'exécution et de logique.

! Création d'une erreur de syntaxe 1. Démarrez Visual Studio .NET. 2. Créez une application Microsoft Windows®. 3. Ajoutez un contrôle Button à Form1. 4. Créez un gestionnaire d'événements pour l'événement Button1_Click. Le

gestionnaire d'événements affiche un message lorsque l'utilisateur clique sur le bouton.

viii Module 8 : Gestion des erreurs et des exceptions

5. Dans la liste des paramètres de la fonction MessageBox, utilisez le signe de continuation pour simuler une rupture incorrecte du code dans les paramètres du message. Votre code doit se présenter de la manière suivante : MessageBox.Show("Erreur de compilation", MessageBox _ Buttons.OK)

6. Essayez de générer l'application. Une erreur de syntaxe est créée. 7. Résolvez le problème en supprimant le signe de continuation, puis regénérez

l'application.

! Création d'une erreur d'exécution 1. Modifiez le gestionnaire d'événements Button1_Click. Remplacez le code

par le code suivant pour générer une erreur d'exécution en tentant une division par zéro. Dim i, j As Integer j = 0 i = 4 / j

2. Générez, puis exécutez l'application. 3. Cliquez sur Button1. Le système génère une erreur d'exécution. 4. Dans la boîte de dialogue Microsoft Development Environment, cliquez

sur Continuer pour quitter l'application.

! Création d'une erreur de logique 1. Ajoutez deux contrôles TextBox à Form1. 2. Supprimez le code existant dans le gestionnaire d'événements

Button1_Click. 3. Ajoutez le code suivant. Il lit deux valeurs dans les zones de texte, ajoute

ces valeurs, puis affiche le résultat dans un message. MessageBox.Show(TextBox1.Text + TextBox2.Text)

4. Générez, puis exécutez l'application. 5. Entrez deux nombres dans les zones de texte. 6. Cliquez sur Button1. Le résultat obtenu inattendu est la concaténation des

deux nombres. Il s'agit d'une erreur de logique. 7. Quittez l'application, puis modifiez le code pour utiliser la fonction CInt.

Votre code doit se présenter de la manière suivante : MessageBox.Show(CInt(TextBox1.Text) + CInt(TextBox2.Text))

8. Générez, puis exécutez l'application. 9. Entrez deux valeurs d'entier dans les zones de texte, puis cliquez sur

Button1. 10. Quittez l'application.

Module 8 : Gestion des erreurs et des exceptions ix

Présentation multimédia : Procédure de débogage d'une application Au cours de cette démonstration, vous procéderez au débogage d'une application. L'application a été conçue pour déterminer le prénom le plus long parmi cinq prénoms figurant dans un tableau mais elle ne fonctionne pas correctement.

! Démarrage de Microsoft Visual Studio .NET et chargement du projet de démonstration

1. Cliquez sur Démarrer, pointez successivement sur Tous les programmes, sur Microsoft Visual Studio .NET, puis cliquez sur Microsoft Visual Studio .NET.

2. À partir de la page de démarrage, dans le volet Commencer, cliquez sur Ouvrir un projet.

3. Dans la boîte de dialogue Ouvrir un projet, accédez au dossier dossier_installation\Democode\Mod08\DebuggingApplication, puis double-cliquez sur DebuggingApplication.sln.

! Exécution de l'application 1. Dans la barre d'outils, cliquez sur le bouton Démarrer. 2. Dans la fenêtre Form1, cliquez sur Button1.

Une exception non gérée de type System.IndexOutOfRangeException survient.

3. Dans la boîte de dialogue Microsoft Development Environment, cliquez sur Arrêter.

4. Placez le pointeur de la souris sur index dans la ligne de code sélectionnée. Notez que l'info-bulle affiche la valeur de la variable index à 5. La variable index, dans la boucle For, est incrémentée de 0 dans le résultat de names.GetLength(0). Le problème est que la méthode GetLength renvoie le nombre d'éléments dans un tableau. Les tableaux étant numérotés à partir de zéro, la valeur renvoyée par la méthode GetLength doit être réduite à 1 pour la boucle For�Next.

! Résolution du code et nouveau test de l'application 1. Dans le menu Déboguer, cliquez sur Arrêter le débogage. 2. Dans l'éditeur de code Form1.vb, ajoutez le code � 1 à la fin de la ligne

suivante : For index = 0 to names.GetLength(0)

3. Dans la barre d'outils, cliquez sur le bouton Démarrer. 4. Dans la boîte de dialogue Form1, cliquez sur Button1.

Notez le résultat indiqué dans le message : le prénom le plus long est Tina, ce qui est incorrect.

5. Dans le message, cliquez sur OK. 6. Fermez Form1.

x Module 8 : Gestion des erreurs et des exceptions

! Utilisation d'un point d'arrêt en vue de déboguer l'application 1. Dans l'éditeur de code Form1.vb, cliquez dans la marge pour ajouter un

point d'arrêt à la ligne de code suivante : For index = 0 To names.GetLength(0) � 1

2. Dans la barre d'outils, cliquez sur le bouton Démarrer. 3. Dans la boîte de dialogue Form1, cliquez sur Button1.

Notez que l'exécution s'arrête sur la ligne où vous avez défini le point d'arrêt.

4. Dans la ligne de code suivante, cliquez avec le bouton droit sur index, puis cliquez sur Ajouter un espion. For index = 0 To names.GetLength(0) -1

Une fenêtre Espion apparaît sous l'éditeur de code. Elle affiche la valeur de la variable index.

5. Cliquez avec le bouton droit sur la variable maxLen, puis cliquez sur Ajouter un espion.

6. Cliquez avec le bouton droit sur la variable longestName, puis cliquez sur Ajouter un espion.

7. Dans la ligne de code suivante, sélectionnez names(index), cliquez avec le bouton droit sur la zone sélectionnée, puis cliquez sur Ajouter un espion. If names(index).Length > maxLen then

8. Appuyez sur la touche F11.

La flèche jaune indique la ligne de code suivante à exécuter. 9. Appuyez sur la touche F11.

La longueur du prénom Brandon étant plus importante que la valeur maxLen actuelle, l'exécution se poursuit à la ligne suivante.

10. Appuyez sur la touche F11. Notez que la variable longestName dans la fenêtre Espion affiche désormais le prénom Brandon.

11. Appuyez sur la touche F11. 12. Appuyez sur la touche F11.

Notez que la valeur index est incrémentée de 1. En revanche, la ligne suivante à exécuter est l'instruction If et non la boucle For, puisque celle-ci est déjà en cours d'exécution.

13. Appuyez sur la touche F11. Bien que Bob soit un prénom plus court que Brandon, l'exécution passe à la ligne suivante. Cela est dû au fait que la variable maxLen n'a pas été mise à jour et affiche toujours 0. C'est le bogue qui hante le code.

14. Appuyez sur MAJ+F5 pour arrêter l'application.

Module 8 : Gestion des erreurs et des exceptions xi

15. Après l'instruction de code longestName = names(index)

ajoutez la ligne de code suivante : maxLen = names(index).Length

16. Cliquez sur le marqueur du point d'arrêt pour supprimer ce dernier. 17. Dans la barre d'outils, cliquez sur le bouton Démarrer. 18. Dans la boîte de dialogue Form1, cliquez sur Button1.

Le message affiche désormais correctement le prénom le plus long, soit Brandon.

19. Dans le message, cliquez sur OK. 20. Fermez Form1. 21. Dans la barre d'outils, cliquez sur Enregistrer tout.

! Fermeture de Microsoft Visual Studio .NET • Dans le menu Fichier, cliquez sur Quitter.

Démonstration dirigée : Utilisation des fenêtres de débogage Au cours de cette démonstration, vous procéderez au débogage d'une application modèle conçue pour déterminer le prénom le plus long parmi cinq prénoms figurant dans un tableau. L'objectif de cette démonstration est d'expliquer comment déboguer une application à l'aide des fenêtres Automatique, Variables locales, Espion et Commande, des points d'arrêt et de la commande Exécuter jusqu'au curseur.

! Démarrage de Microsoft Visual Studio .NET et chargement du projet de démonstration

1. Cliquez sur Démarrer, pointez successivement sur Tous les programmes, sur Microsoft Visual Studio .NET, puis cliquez sur Microsoft Visual Studio .NET.

2. À partir de la page de démarrage, dans le volet Commencer, cliquez sur Ouvrir un projet.

3. Dans la boîte de dialogue Ouvrir un projet, accédez au dossier dossier_installation\Democode\Mod08\DebuggingApplication2, puis double-cliquez sur DebuggingApplication2.sln.

xii Module 8 : Gestion des erreurs et des exceptions

! Utilisation de la commande Exécuter jusqu'au curseur 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

Form1.vb, puis cliquez sur Afficher le code. 2. À partir de l'éditeur de code, dans le code d'événement Form1_Load,

cliquez avec le bouton droit sur la ligne suivante, puis cliquez sur Exécuter jusqu'au curseur. names(0)= "Brandon"

Vous constatez que l'application démarre et que l'exécution s'arrête à la ligne spécifiée.

! Utilisation de la fenêtre Automatique 1. Examinez la fenêtre Automatique. Si cette fenêtre n'apparaît pas, cliquez sur

le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Automatique. Remarquez que le tableau names est actuellement vide.

2. Dans la barre d'outils Déboguer, cliquez sur Pas à pas détaillé. Remarquez que names(0) affiche désormais le prénom Brandon.

3. Dans la barre d'outils Déboguer, cliquez sur Pas à pas détaillé. Remarquez que names(1) affiche désormais le prénom Bob. La fenêtre Automatique affiche les variables dans l'instruction de code en cours ainsi que dans la précédente.

! Utilisation de la fenêtre Variables locales 1. Examinez la fenêtre Variables locales. Si cette fenêtre n'apparaît pas,

cliquez sur le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Variables locales. La fenêtre Variables locales affiche les variables locales dans le contexte actuel.

2. Dans la fenêtre Variables locales, développez la valeur Me. 3. Sous Me, développez names.

! Utilisation de la fenêtre Espion 1. Examinez la fenêtre Espion 1. Si cette fenêtre n'apparaît pas, cliquez sur le

menu Déboguer, pointez sur Fenêtres, cliquez sur Espion, puis cliquez sur Espion 1.

2. Dans l'éditeur de code, cliquez avec le bouton droit sur names(0), puis cliquez sur Ajouter un espion. La fenêtre Espion vous permet de créer votre propre liste personnalisée de variables à contrôler lors de l'exécution du code.

3. À partir de l'éditeur de code Form1.vb, dans la fonction Sub Button1_Click, cliquez avec le bouton droit sur maxLen, puis cliquez sur Ajouter un espion. Remarquez que la valeur maxLen s'affiche sous la forme d'un message Le nom 'maxLen' n'est pas déclaré. Cela est dû au fait que le code chargé de déclarer maxLen n'a pas encore été exécuté.

Module 8 : Gestion des erreurs et des exceptions xiii

4. À partir de l'éditeur de code Form1.vb, dans la fonction Sub Button1_Click, cliquez avec le bouton droit sur l'instruction For, puis cliquez sur Exécuter jusqu'au curseur.

5. Dans la boîte de dialogue Form1, cliquez sur Button1. L'exécution s'arrête sur l'instruction For dans le code de l'événement Button1_Click. Examinez la fenêtre Espion 1 et notez que la valeur de maxLen est désormais 0. Notez également, dans la fenêtre Variables locales, que les valeurs des éléments 2 à 4 dans le tableau names s'affichent en rouge. Ce changement de couleur est lié au fait que les valeurs ont été modifiées depuis le dernier débogage de l'application.

! Utilisation des points d'arrêt et de la fenêtre Commande 1. À partir de l'éditeur de code Form1.vb, dans la fonction Sub

Button1_Click, cliquez avec le bouton droit sur la ligne de code suivante, puis cliquez sur Insérer un point d'arrêt. If names(index).Length > maxLen Then

2. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Points

d'arrêt. 3. Dans la fenêtre Points d'arrêt, cliquez avec le bouton droit sur l'entrée du

point d'arrêt, puis cliquez sur Propriétés. 4. Dans la fenêtre Propriétés des points d'arrêt, dans l'onglet Fichier, cliquez

sur Condition. Les conditions vous permettent d'arrêter l'exécution sur la ligne d'un point d'arrêt lorsque qu'une condition particulière est satisfaite.

5. Dans la fenêtre Condition de point d'arrêt, sous Condition, tapez index=3 puis cliquez sur OK.

6. Dans la fenêtre Propriétés des points d'arrêt, cliquez sur OK. 7. Cliquez sur le bouton Continuer de la barre d'outils.

L'exécution s'arrête sur la ligne du point d'arrêt. 8. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Immédiat.

Deux modes différents sont pris en charge dans la fenêtre Commande : le mode Commande et le mode Immédiat. Vous pouvez faire appel au mode Commande pour exécuter des commandes Visual Studio .NET directement dans l'environnement de développement, indépendamment du système de menus. Le mode Immédiat peut être employé pour le débogage d'une application. Utilisez-le pour évaluer des expressions, exécuter des instructions, afficher les valeurs des variables, etc.

9. Dans la fenêtre Commande, tapez ?index puis appuyez sur la touche ENTRÉE. La valeur 3 s'affiche dans la fenêtre. Elle confirme que le point d'arrêt conditionnel a été créé.

10. Dans la fenêtre Commande, tapez names(4)=�Christopher� puis appuyez sur la touche ENTRÉE.

xiv Module 8 : Gestion des erreurs et des exceptions

11. Dans la fenêtre Commande, tapez ?names(4) puis appuyez sur la touche ENTRÉE. La chaîne Christopher s'affiche dans la fenêtre. Ceci démontre donc que vous pouvez utiliser la fenêtre Commande pour modifier la valeur des variables.

12. Cliquez sur le bouton Continuer de la barre d'outils. Remarquez que le message affiche désormais le prénom Christopher comme le prénom le plus long dans le tableau names.

13. Dans le message, cliquez sur OK. 14. Fermez Form1.

! Fermeture de Microsoft Visual Studio .NET • Dans le menu Fichier, cliquez sur Quitter.

Démonstration dirigée : Utilisation de la gestion structurée des exceptions Au cours de cette démonstration, les stagiaires analyseront le flux du code intervenant dans l'instruction Try�Catch lors de la mise en �uvre d'une gestion structurée des exceptions.

! Exécution de l'application 1. Ouvrez la solution Exceptions.sln, disponible dans le dossier

dossier_installation\Democode\Mod08\Exceptions. 2. Ouvrez le formulaire Exceptions.vb à partir de l'éditeur de code et définissez

six points d'arrêt : un dans l'instruction Try, puis un dans chaque instruction Catch de la routine RunExceptions.

3. Exécutez le projet Exceptions. 4. Cliquez sur le bouton Dépassement du formulaire. Le processus

Visual Basic s'interrompt au premier point d'arrêt. 5. Parcourez le code du bloc Try à l'aide de la touche F11 et expliquez les

détails du dépassement. Expliquez comment la classe OverflowException filtre l'exception.

6. Parcourez le reste du code pour rechercher l'exception de dépassement. Lorsque le message s'affiche, cliquez sur OK, puis appuyez sur la touche F5 pour permettre à l'exécution de se poursuivre.

7. Présentez de la même manière chacun des boutons restants dans le formulaire de test (Division par zéro, Index hors limite et Erreur de cast). a. Cliquez sur le bouton approprié du formulaire. b. Utilisez la touche F11 pour parcourir le code et montrer comment les

exceptions sont gérées dans chaque cas. c. Cliquez sur OK, puis appuyez sur la touche F5 pour permettre à

l'exécution de se poursuivre. 8. Après avoir décrit la gestion des exceptions pour chaque bouton, fermez le

formulaire pour clore la session de débogage. 9. Fermez l'environnement de développement Microsoft Visual Studio .NET.

Module 8 : Gestion des erreurs et des exceptions 1

Vue d'ensemble

! Types d'erreurs

! Utilisation du débogueur

! Gestion des exceptionsUtilisationde Visual

Studio .NET

Accèsaux données

Écriturede code

Créationd'une

interface



Plus les programmes deviennent volumineux et complexes, plus un certain nombre d'erreurs devient inévitable. Les efforts de programmation les plus minutieux peuvent eux-aussi être gênés par des erreurs inattendues appelées « bogues ». La technique visant à rechercher et à éliminer ces bogues est le débogage.

Dans ce module, vous vous familiariserez avec les types d'erreurs susceptibles de se produire dans un programme et apprendrez à utiliser le débogueur Microsoft® Visual Studio® .NET, les diverses fenêtres de débogage et la gestion structurée des exceptions en vue de diagnostiquer, de corriger et de gérer des erreurs.


! définir et fournir des exemples d'erreurs de syntaxe, d'exécution et de logique ;

! déboguer du code à l'aide du débogueur Microsoft Visual Studio .NET ; ! mettre en �uvre la gestion structurée des exceptions dans votre application.

Introduction

Objectifs

2 Module 8 : Gestion des erreurs et des exceptions

Leçon : Types d'erreurs

! Présentation des erreurs de syntaxe

! Présentation des erreurs d'exécution

! Présentation des erreurs de logique


Les erreurs de programmation sont généralement classées dans trois catégories : les erreurs de syntaxe, les erreurs d'exécution et les erreurs de logique. Différentes méthodes et différents outils vous permettront de rechercher et de résoudre chaque type d'erreur.


! Présentation des erreurs de syntaxe ! Présentation des erreurs d'exécution ! Présentation des erreurs de logique ! Démonstration : Types d'erreurs

Une fois cette leçon terminée, vous serez en mesure d'expliquer la différence entre des erreurs de syntaxe et des erreurs d'exécution et de logique.

Introduction


Objectif de la leçon


Présentation des erreurs de syntaxe

Affichage des erreurs dans la fenêtre Liste des tâches :

Erreur de syntaxeErreur de syntaxeErreur de syntaxeErreur de syntaxe


Le type d'erreur le plus visible est l'erreur de syntaxe. Il survient lorsque vous rédigez du code selon une méthode contraire aux règles du langage. Il peut s'agir, par exemple, d'un mot clé incorrectement saisi, de l'oubli d'une ponctuation obligatoire ou d'une construction incorrecte (par exemple, une instruction For sans instruction Next correspondante ou un mot clé If sur une ligne sans opérateur conditionnel).

Microsoft Visual Basic .NET affiche les erreurs de syntaxe à mesure que vous tapez chaque instruction dans le code de votre application. La portion de code contenant l'erreur apparaît avec un soulignement irrégulier. Dès que vous placez le pointeur de la souris sur le code souligné, une info-bulle affichant une description sommaire de l'erreur apparaît en regard du pointeur.

Les erreurs de syntaxe sont relevées par le compilateur qui affiche un message d'erreur pour vous informer du problème. Si vous ignorez ces erreurs lors de l'écriture de votre code, vous pouvez toujours les consulter et les traiter à tout moment à partir de la fenêtre Liste des tâches. Si vous tentez de générer votre application sans résoudre les erreurs de syntaxe, la fenêtre Liste des tâches apparaît automatiquement et affiche l'ensemble des erreurs.

Introduction

Recherche d'erreurs de syntaxe


La fenêtre Liste des tâches fournit une description de l'erreur et précise le chemin d'accès au fichier dans lequel l'erreur est survenue ainsi que le numéro de la ligne de code qui contient l'erreur. La description de l'erreur affiche les mêmes informations que celles obtenues lorsque vous placez le pointeur de la souris sur la partie soulignée de votre code dans l'éditeur de code.

Vous pouvez rectifier une erreur en double-cliquant sur l'entrée correspondante dans la Liste des tâches. Le point d'insertion est alors placé dans le fichier correct et sur la ligne exacte où se trouve l'erreur afin que vous puissiez modifier votre code. Dès que vous avez effectué vos corrections et déplacé le pointeur hors de la ligne modifiée, les entrées de la fenêtre Liste des tâches sont mises à jour.

Vous pouvez également utiliser la fenêtre Liste des tâches pour consulter les tâches créées par vos propres soins en ajoutant un commentaire TODO à votre code.

Vous pouvez également consulter les erreurs de génération survenues à partir de la fenêtre Sortie. Cette fenêtre répertorie les avertissements, les erreurs et l'état de la génération tandis que Microsoft Visual Studio .NET génère l'application. Une fois la procédure de génération menée à terme, elle fournit un récapitulatif et inclut notamment l'emplacement des erreurs de syntaxe (numéro de ligne et fichier) ainsi qu'une description sommaire de chaque problème.

Affichage des erreurs dans la fenêtre Liste des tâches

Affichage des erreurs dans la fenêtre Sortie


Présentation des erreurs d'exécution

Vitesse = Kilomètres/Heures

' Si la variable Heures = 0, la division n'est pas une opération valide, même sil'instruction elle-même estsyntaxiquement correcte


' Si la variable Heures = 0, la division n'est pas une opération valide, même sil'instruction elle-même estsyntaxiquement correcte


Les erreurs d'exécution surviennent lorsqu'une instruction tente d'exécuter une opération irréalisable (par exemple, référencer un objet inaccessible). Elles apparaissent lors de l'exécution de votre code.

Les erreurs d'exécution sont souvent la conséquence d'actions imprévues. Un utilisateur peut, par exemple, oublier d'insérer une disquette dans un lecteur de disquette ou sélectionner un fichier d'entrée non valide. La tentative de division par zéro est une erreur d'exécution courante. Examinez le code suivant :


Si la variable Heures est égale à zéro, la division n'est pas une opération valide, même si l'instruction elle-même est syntaxiquement correcte.

Les compilateurs ne relèvent pas les erreurs d'exécution. Ils permettent uniquement de relever les erreurs inhérentes à la structure du code rédigé et non les erreurs liées aux fonctionnalités.

Si une erreur d'exécution non gérée survient lorsque votre programme fonctionne en tant que version déboguée, un message d'erreur apparaît et vous permet de passer en mode arrêt et de résoudre le problème. Si une erreur d'exécution survient lorsque votre application fonctionne en tant que version finale, votre programme risque de ne plus répondre avec ou sans message d'erreur pour vous avertir. En termes familiers, votre programme risque de tomber en panne ou de planter.

Vous pouvez faire appel aux outils de débogage de Microsoft Visual Studio .NET pour identifier les erreurs et rédiger du code de gestion des erreurs pour gérer les conditions susceptibles de générer des erreurs d'exécution. Pour gérer les erreurs d'exécution, vous pouvez également rédiger des gestionnaires d'exceptions capables d'isoler des erreurs et de prendre les mesures prescrites (résolution du problème, message invitant l'utilisateur à agir ou enregistrement des données avant la fermeture du programme). Une autre solution possible, susceptible de réduire le nombre d'erreurs d'exécution, est de valider tous les formulaires d'entrée utilisateur.

Introduction

Exemple d'erreur d'exécution

Conséquences des erreurs d'exécution


Présentation des erreurs de logique

! Définition : Une erreur qui entraîne la production de résultats incorrects par une application

" Peut ne pas générer de message d'erreur

" Peut être recherchée en testant l'application et en analysant ses résultats

Dim x As Integer = 2

Do While x < 10

' Instructions du code

x -= 1

Loop

Dim x As Integer = 2

Do While x < 10

' Instructions du code

x -= 1

Loop


Les erreurs de logique se produisent lorsqu'une application ne fonctionne pas comme elle le devrait. Ces erreurs sont particulièrement difficiles à rechercher puisqu'elles ne génèrent pas de message d'erreur. Une application peut contenir du code syntaxiquement correct, s'exécuter sans effectuer d'opérations non valides et, pourtant, produire des résultats incorrects.

Le code suivant contient une erreur de logique amenée à générer une erreur d'exécution.

Dim x As Integer = 2 Do While x < 10 ' Instructions du code x -= 1 Loop

Dans ce code, la boucle While s'exécute tant que la valeur x reste inférieure à 10. À l'intérieur de la boucle, l'instruction x -= 1 contient une erreur de logique car la valeur de début de x est 2 et est décrémentée de 1 à chaque exécution de la boucle. La condition x < 10 reste toujours définie à True, créant ainsi une boucle infinie. Une erreur d'exécution survient lorsque la valeur x dépasse la valeur qu'il est possible de stocker dans un Integer.

Le seul moyen de vérifier qu'une application fonctionne correctement est de la tester en d'en analyser les résultats. Dans le cadre du processus de débogage, vous pouvez utiliser les outils de débogage de Microsoft Visual Studio .NET pour identifier et résoudre les erreurs de logique dissimulées dans votre code.

Introduction

Exemple d'erreur de logique

Recherche et résolution des erreurs de logique


Démonstration : Types d'erreurs

! Au cours de cette démonstration, vousvous familiariserez avec les types d'erreurs suivants et vous verrez un exemple de chaque erreur dans l'environnement Visual Studio .NET :

" Erreur de syntaxe

" Erreur d'exécution

" Erreur de logique


Au cours de cette démonstration, vous vous familiariserez avec les différents types d'erreurs.


Leçon : Utilisation du débogueur

! Présentation du mode arrêt

! Utilisation des points d'arrêt

! Modification des points d'arrêt

! Barre d'outils Déboguer

! Procédure d'analyse pas à pas du code

! Utilisation des fenêtres de débogage

! Utilisation de la fenêtre Commande


Les outils de débogage vous aident à diagnostiquer des erreurs de programme en examinant le flux du programme. Vous pouvez les utiliser pour interrompre votre programme à des moments définis de l'exécution du code, examiner les modifications apportées aux valeurs des variables et des propriétés et parcourir des parties du code pas à pas.


! Démonstration multimédia : Procédure de débogage d'une application ! Présentation du mode arrêt (Break) ! Utilisation des points d'arrêt ! Modification des points d'arrêt ! Barre d'outils Déboguer ! Procédure d'analyse pas à pas du code ! Démonstration : Utilisation des fenêtres de débogage ! Utilisation des fenêtres de débogage ! Utilisation de la fenêtre Commande ! Application pratique : Débogage du code


! définir, supprimer et modifier des points d'arrêt ; ! parcourir le code à l'aide des commandes Pas à pas et de la syntaxe

Exécuter jusqu'au curseur ; ! utiliser les fenêtres suivantes pour examiner votre programme :

Automatique, Pile des appels, Commande, Variables locales et Espion.

Introduction




Présentation multimédia : Procédure de débogage d'une application


Au cours de cette démonstration, vous apprendrez à utiliser des points d'arrêt, parcourir chaque ligne du code et examiner ses variables à l'aide de la fenêtre Espion pour déboguer une application.


Présentation du mode arrêt

! Permet d'interrompre le fonctionnement d'une application

! Vous pouvez effectuer les opérations suivantes lorsque vous êtes en mode arrêt : " Parcourir votre code ligne après ligne" Déterminer les procédures actives qui ont été appelées " Contrôler les valeurs des variables, des propriétés et des

expressions " Utiliser les fenêtres de débogage pour modifier les valeurs

des variables et des propriétés" Modifier le flux du programme" Exécuter les instructions du code


Lorsque vous développez une application à l'aide de Microsoft Visual Basic .NET, vous faites appel principalement à deux modes distincts : le mode design et le mode exécution. Conçu pour créer et modifier du code, le mode design vous offre la possibilité de résoudre des erreurs de syntaxe mais ne vous permet pas de tester des erreurs de logique et d'exécution. Vous pouvez choisir le mode exécution pour vérifier l'exécution du programme et relever la présence éventuelle d'erreurs de logique et d'exécution. En revanche, il ne vous permet pas de modifier le code. Un troisième mode, le mode arrêt, permet d'interrompre le fonctionnement d'une application et offre à tout moment un aperçu de sa condition. La sélection du mode arrêt ne signifie pas la fin de l'exécution de votre programme. Vous pouvez relancer l'exécution à tout moment.

Seule l'exécution d'une version déboguée de votre application autorise l'utilisation du mode arrêt. Cette utilisation n'est pas possible dans le cadre d'une version finale de l'application.

Visual Basic passe en mode arrêt dans les cas suivants :

! lorsqu'il rencontre un point d'arrêt que vous avez défini dans votre code ; ! lorsqu'il rencontre une instruction Stop dans votre code ; ! lors du déclenchement d'une expression espionne que vous avez insérée ; ! lorsque vous appuyez sur les touches CTRL+PAUSE de votre clavier lors

de l'exécution d'une version déboguée de votre programme ; ! lorsque vous cliquez sur le bouton Interrompre tout de la barre d'outils

Déboguer lors de l'exécution d'une version déboguée de votre programme ;

Introduction

Passage en mode arrêt


! lorsqu'une instruction dans une ligne du code génère une erreur d'exécution non interceptée et que vous cliquez sur Déboguer dans la boîte de dialogue qui apparaît ;

! lorsqu'une instruction Debug.Assert prend la valeur False. L'instruction Debug.Assert fait l'objet d'une étude plus poussée plus loin dans cette rubrique.

Lorsque vous travaillez en mode arrêt, le texte [break] s'affiche dans la barre de titre de Microsoft Visual Studio. La capture d'écran ci-dessous présente, en mode arrêt, une application intitulée DebuggingApplication.

Vous pouvez effectuer les opérations suivantes lorsque vous êtes en mode arrêt :

! parcourir votre code ligne après ligne ; ! déterminer les procédures actives qui ont été appelées ; ! contrôler les valeurs des variables, des propriétés et des expressions ; ! utiliser les fenêtres de débogage pour modifier les valeurs des variables et

des propriétés ; ! modifier le flux du programme ; ! exécuter les instructions du code.

Vous pouvez, sous certaines conditions, passer en mode arrêt à l'aide de la méthode Debug.Assert. Cette méthode utilise une expression booléenne pour déterminer le passage ou non en mode arrêt. Le passage en mode arrêt s'effectue lorsque l'instruction Debug.Assert prend la valeur False.

Pour utiliser la méthode Debug.Assert, adoptez la syntaxe suivante :

Debug.Assert expression booléenne

Utilisation du mode arrêt

Utilisation de la méthode Debug.Assert


Dans le code suivant, l'instruction Debug.Assert force Visual Basic à passer en mode arrêt lorsque la variable Counter est supérieure ou égale à cinq :

Private Sub Count_Click( ) Dim Counter As Integer For Counter = 1 To 10 Debug.Assert Counter < 5 'Passer en mode arrêt lorsque cette instruction prend la 'valeur False Next End Sub

Vous pouvez utiliser l'instruction Debug.Assert uniquement dans la version déboguée d'une application. Lors de la compilation du code avec une version finale de l'application, les appels de la méthode Debug sont ignorés.

Remarque


Utilisation des points d'arrêt

! Un point d'arrêt est un marqueur intégré à votre code qui permet à Visual Basic d'interrompre l'exécution du code sur une ligne spécifique

! Vous ne pouvez pas placer un point d'arrêt dans du code non exécutable

Points d'arrêtPoints d'arrêt


Un point d'arrêt est un marqueur intégré à votre code qui permet à Visual Basic d'interrompre l'exécution du code sur une ligne spécifique. À defaut de parcourir votre code ligne après ligne ou instruction après instruction, vous pouvez exécuter votre programme jusqu'à ce qu'il rencontre un point d'arrêt, puis démarrer une opération de débogage.

Pour arrêter votre programme à un emplacement de votre code, là où vous suspectez la présence d'un problème, définissez un point d'arrêt à ce même emplacement. Vous pouvez définir des points d'arrêt lors de la conception ou au cours d'une session de débogage.

Il existe plusieurs techniques permettant de définir un point d'arrêt :

! Dans la marge à gauche de l'éditeur de code, cliquez sur la ligne contenant l'instruction sur laquelle vous souhaitez que s'arrête le débogueur.

! Placez le pointeur de la souris sur la ligne sur laquelle le débogueur doit s'arrêter. Appuyez sur F9 pour activer/désactiver le point d'arrêt.

! Cliquez avec le bouton droit sur une ligne du code, puis cliquez sur Insérer un point d'arrêt dans le menu contextuel.

Une fois le point d'arrêt défini, un cercle (!) apparaît dans la marge, à gauche de la ligne de code sur laquelle le point d'arrêt est défini, et la ligne de code est mise en surbrillance de la même couleur que le point d'arrêt.

Une fois le point d'arrêt atteint lors de l'exécution, un indicateur d'exécution apparaît sur la ligne suivante à exécuter. Si vous le souhaitez, vous pouvez déplacer cet indicateur sur une autre ligne. L'illustration ci-dessous présente l'indicateur d'exécution.

Introduction

Définition d'un point d'arrêt


Il existe plusieurs techniques permettant de supprimer un point d'arrêt :

! Cliquez sur le cercle identifiant le point d'arrêt (!), en regard de la ligne où se trouve ce dernier, dans la marge, à gauche de l'éditeur de code.

! Placez le curseur sur la ligne sur laquelle est défini le point d'arrêt, puis appuyez sur F9 pour désactiver le point d'arrêt.

! Cliquez avec le bouton droit sur la ligne de code sur laquelle le point d'arrêt est défini, puis cliquez sur Supprimer le point d'arrêt dans le menu contextuel.

Pour supprimer tous les points d'arrêt en même temps, cliquez sur Effacer tous les points d'arrêt à partir du menu Déboguer.

La fenêtre Points d'arrêt répertorie tous les points d'arrêt actuellement définis dans votre programme et affiche leurs propriétés. Elle vous permet de définir de nouveaux points d'arrêt, de supprimer des points d'arrêt, d'activer ou de désactiver des points d'arrêt, de modifier les propriétés d'un point d'arrêt ou d'atteindre le code source ou le code machine correspondant à un point d'arrêt donné.

! Pour ouvrir la fenêtre Points d'arrêt • Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Points

d'arrêt.

La capture d'écran ci-dessous présente la fenêtre Points d'arrêt.

Pour plus d'informations sur l'utilisation de la fenêtre Points d'arrêt, reportez-vous à la section Utilisation de la fenêtre Points d'arrêt de la documentation Microsoft Visual Studio .NET.

Suppression d'un point d'arrêt

Remarque

Fenêtre Points d'arrêt

Remarque


Modification des points d'arrêt

PropriétéConditionPropriétéCondition

PropriétéNombred'accès

PropriétéNombred'accès


Vous pouvez définir deux propriétés capables de modifier le comportement d'un point d'arrêt : la propriété Condition et la propriété Nombre d'accès.

Vous pouvez utiliser la boîte de dialogue Propriétés des points d'arrêt pour définir un point d'arrêt conditionnel. Une condition est une expression qui détermine le passage ou non du débogueur en mode arrêt lorsqu'il atteint le point d'arrêt. Une fois le point d'arrêt atteint, le débogueur évalue la condition et passe en mode arrêt uniquement si la condition est satisfaite.

! Pour définir la propriété Condition d'un point d'arrêt 1. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Points

d'arrêt. 2. Ouvrez la boîte de dialogue Propriétés des points d'arrêt en cliquant sur le

point d'arrêt approprié dans la fenêtre Points d'arrêt, puis sur Propriétés dans la barre d'outils de cette même fenêtre.

3. Dans la boîte de dialogue Propriétés des points d'arrêt, cliquez sur Condition.

4. Tapez l'expression que vous souhaitez évaluer à l'aide du débogueur. 5. Indiquez comment la condition est satisfaite en précisant les paramètres

suivants : a. Si l'expression est définie à True. b. Si la valeur de l'expression a changé (cliquez sur a changé dans la boîte

de dialogue Condition de point d'arrêt). Lorsque vous définissez une condition de point d'arrêt évaluant si une expression a changé, le débogueur ne s'arrête pas la première fois qu'un point d'arrêt est atteint. L'expression est évaluée et une valeur est stockée mais le système n'interprète pas ce premier stockage comme un changement de valeur.

Introduction

Utilisation de la propriété Condition

Définition de la propriété Condition


Supposons, par exemple, que vous déboguiez un programme bancaire dans lequel le solde d'un compte n'est pas autorisé à descendre en dessous de zéro. Vous pourriez définir des points d'arrêt à certains emplacements du code et joindre la condition accountBalance < 0 à chacun de ces emplacements.

Lors de l'exécution du programme, l'exécution s'arrête sur les points d'arrêt uniquement si la variable accountBalance est inférieure à zéro. Vous pouvez examiner les variables et l'état du programme à l'emplacement du premier point d'arrêt, puis poursuivre l'exécution à partir de l'emplacement du deuxième point d'arrêt, et ainsi de suite. La capture d'écran ci-dessous explique comment définir la propriété Condition du point d'arrêt dans le cadre du scénario évoqué ci-avant.

Par défaut, le débogueur interrompt l'exécution du code à chaque point d'arrêt atteint. En revanche, certains bogues n'apparaissent pas la première fois que votre programme exécute une boucle, appelle une fonction ou accède à une variable. Vous pouvez alors décider d'interrompre l'exécution uniquement lorsque le point d'arrêt a été atteint un nombre de fois spécifique. Ce nombre est qualifié de nombre d'accès. Vous pouvez utiliser la propriéte Nombre d'accès pour spécifier le nombre de fois qu'un point d'arrêt a été atteint avant que le débogueur arrête la procédure d'exécution.

! Pour définir la propriété Nombre d'accès d'un point d'arrêt 1. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Points

d'arrêt. 2. Ouvrez la boîte de dialogue Propriétés des points d'arrêt en sélectionnant

le point d'arrêt approprié dans la fenêtre Points d'arrêt, puis en cliquant sur Propriétés dans la barre d'outils de cette même fenêtre.

3. Dans la boîte de dialogue Propriétés des points d'arrêt, cliquez sur Nombre d'accès.

Exemple d'utilisation de la propriété Condition

Utilisation de la propriété Nombre d'accès

Définition de la propriété Nombre d'accès


4. Dans la boîte de dialogue Nombre d'accès à un point d'arrêt, dans le champ Lorsque le point d'arrêt est atteint, cliquez sur le type de test du nombre d'accès que vous souhaitez effectuer. Les choix possibles sont les suivants : a. toujours s'arrêter b. s'arrêter lorsque le nombre d'accès est égal à c. s'arrêter lorsque le nombre d'accès est un multiple de d. s'arrêter lorsque le nombre d'accès est supérieur ou égal à

5. Entrez le nombre d'accès approprié, puis cliquez sur OK.

Dans l'exemple ci-dessous, le nombre d'accès est défini à 3. L'exécution s'arrête la troisième fois que le point d'arrêt est atteint. Si vous avez défini une propriété Condition, l'exécution s'arrête la troisième fois que le point d'arrêt est atteint sous cette condition.

Exemple d'utilisation de la propriété Nombre d'accès



DémarrerDémarrer

Interrompretout

Interrompretout

Arrêter le débogageArrêter le débogage

RedémarrerRedémarrer

Afficherl'instruction

suivante

Afficherl'instruction

suivante

Pas à pas détaillé

Pas à pas détaillé

Pas à pas sortant

Pas à pas sortant

Pas à pas principal

Pas à pas principal

Points d'arrêtPoints d'arrêt

AffichagehexadécimalAffichage

hexadécimal


Lorsque l'exécution de votre programme s'arrête près d'un point susceptible, selon vous, de poser un problème, vous pouvez faire appel aux outils de débogage de Microsoft Visual Basic pour étudier le problème. La barre d'outils Déboguer permet un accès rapide à un grand nombre des fonctionnalités de débogage les plus fréquemment utilisées.

Si la barre d'outils n'est pas visible, cliquez avec le bouton droit sur n'importe quelle barre d'outils lorsque vous travaillez en mode design ou en mode arrêt, puis cliquez sur Déboguer. Le tableau ci-dessous décrit les boutons les plus courants de la barre d'outils :

Nom du bouton

Touche de raccourci par défaut

Description

Démarrer/Continuer F5 Exécute l'application à partir du formulaire de démarrage (ou Sub Main) spécifié dans l'onglet Général de la boîte de dialogue Pages de propriétés. En mode arrêt, le texte de l'info-bulle du bouton Démarrer devient Continuer.

Interrompre tout CTRL+ALT+PAUSE Arrête l'exécution de tous les programmes fonctionnant lors de l'application du débogueur. Les programmes ne sont pas fermés et vous pouvez reprendre l'exécution à tout moment.

Arrêter le débogage MAJ+F5 Arrête l'exécution du programme et retourne en mode design.

Pas à pas détaillé F11 Exécute la ligne de code exécutable suivante et parcourt chaque ligne suivante du code. Si le code appelle une autre procédure, la fonction Pas à pas détaillé parcourt chaque ligne de cette procédure.

Pas à pas principal F10 Exécute la ligne de code exécutable suivante et parcourt chaque ligne suivante du code. Si le code appelle une autre procédure, cette dernière est exécutée de A à Z avant de passer à la ligne de code suivante dans la première procédure.

Introduction



(suite) Nom du bouton

Touche de raccourci par défaut

Description

Pas à pas sortant MAJ+F11 Exécute le reste de la procédure en cours et s'arrête sur la ligne suivante dans la procédure appelante.

Points d'arrêt CTRL+ALT+B Ouvre la fenêtre Points d'arrêt.


Procédure d'analyse pas à pas du code

! Pas à pas détaillé et Pas à pas principal : Exécutent la ligne de code suivante. Si la ligne contient un appel de procédure : " Pas à pas détaillé : Exécute uniquement l'appel, puis

s'arrête à la première ligne de code dans la procédure" Pas à pas principal : Exécute l'intégralité de la

procédure, puis s'arrête à la première ligne de code hors procédure

! Pas à pas sortant : Reprend l'exécution de votre code jusqu'au retour de la procédure, puis s'arrête au point de retour dans la procédure appelante

! Exécuter jusqu'au curseur : Le débogueur exécute votreapplication jusqu'à ce qu'il atteigne le point d'insertion que vous avez défini


Une des procédures de débogage les plus courantes est l'analyse pas à pas du code ou l'exécution du code une ligne à la fois. Le menu Déboguer est doté de trois commandes qui permettent de parcourir le code pas à pas : Pas à pas détaillé, Pas à pas principal et Pas à pas sortant. En outre, la commande Exécuter jusqu'au curseur vous permet d'exécuter votre application jusqu'à ce que le débogueur atteigne le point d'insertion que vous avez défini. Vous pouvez parcourir votre code à partir de ce point.

Vous ne pouvez pas accéder aux commandes Pas à pas si votre application est en cours d'exécution. Ces commandes sont valides uniquement en mode arrêt ou avant tout démarrage de l'application.

Les deux commandes Pas à pas détaillé et Pas à pas principal demandent au débogueur d'exécuter la ligne de code suivante. Un seul point les différencie : la méthode employée pour gérer les appels de procédure.

Si la ligne contient un appel de procédure :

! La commande Pas à pas détaillé exécute uniquement l'appel, puis s'arrête à la première ligne de code dans la procédure.

! La commande Pas à pas principal exécute l'intégralité de la procédure, puis s'arrête à la première ligne de code hors procédure.

Utilisez la commande Pas à pas détaillé si vous souhaitez visualiser l'appel de procédure. Utilisez la commande Pas à pas principal si vous souhaitez éviter de parcourir les procédures de manière détaillée.

Introduction

Remarque

Utilisation des commandes Pas à pas détaillé et Pas à pas principal


Utilisez la commande Pas à pas sortant lorsque vous vous trouvez dans un appel de procédure et souhaitez revenir à la procédure appelante. La fonction Pas à pas sortant reprend l'exécution de votre code jusqu'au retour de la procédure, puis s'arrête au point de retour dans la procédure appelante.

Vous pouvez utiliser la commande Exécuter jusqu'au curseur pour demander au débogueur d'exécuter votre application jusqu'à ce qu'il atteigne le point d'insertion que vous avez défini en cliquant sur l'éditeur de code avec le pointeur de la souris. La commande Exécuter jusqu'au curseur n'est pas disponible à partir du menu Déboguer. Pour l'exécuter, cliquez avec le bouton droit dans la fenêtre source, puis cliquez sur Exécuter jusqu'au curseur dans le menu contextuel.

Pour démarrer le débogage d'une application, vous pouvez faire appel aux commandes Démarrer, Pas à pas détaillé, Pas à pas principal ou Exécuter jusqu'au curseur.

! Si vous cliquez sur Démarrer, votre application démarre et s'exécute jusqu'à ce qu'elle atteigne un point d'arrêt. Vous pouvez interrompre à tout moment l'exécution pour examiner les valeurs, modifier les variables et même analyser l'état de votre programme.

! Si vous choisissez les commandes Pas à pas détaillé ou Pas à pas principal, votre application s'arrête à la première ligne exécutable du code.

! Si vous cliquez sur Exécuter jusqu'au curseur, votre application démarre et s'exécute jusqu'à ce qu'elle atteigne un point d'arrêt ou l'emplacement du point d'insertion, quel que soit celui qui se présente le premier. Dans certains cas, aucun arrêt ne se produit. Cela signifie que l'exécution n'a jamais atteint la ligne de code sur laquelle vous avez défini le point d'insertion.

Utilisation de la commande Pas à pas sortant

Utilisation de la commande Exécuter jusqu'au curseur

Démarrage d'une analyse pas à pas du code


Démonstration : Utilisation des fenêtres de débogage

! Au cours de cette démonstration, vousapprendrez à déboguer une application à l'aide des éléments suivants :

" Fenêtres Automatique, Variables locales, Espion et Commande

" Points d'arrêt

" Commande Exécuter jusqu'au curseur


Au cours de cette démonstration, vous apprendrez à déboguer une application à l'aide des fenêtres Automatique, Variables locales, Espion et Commande, des points d'arrêt et de la commande Exécuter jusqu'au curseur.


Utilisation des fenêtres de débogage

FenêtreFenêtreFenêtre UtilisationUtilisationUtilisation

AutomatiqueAutomatiquePermet d'afficher des variables dans l'instruction en cours et dans les trois instructions suivant et précédant l'instruction en cours

Permet d'afficher des variables dans l'instruction en cours et dans les trois instructions suivant et précédant l'instruction en cours

Pile des appels

Pile des appels

Permet d'afficher l'historique des appels à la ligne de code en cours de débogagePermet d'afficher l'historique des appels à la ligne de code en cours de débogage

Variables locales

Variables locales

Permet d'afficher et de modifier les variables localesPermet d'afficher et de modifier les variables locales

EspionEspion# Permet de créer votre liste personnalisée de

variables ou d'expressions à contrôler# Permet de visualiser et manipuler toutes les

expressions espionnes

# Permet de créer votre liste personnalisée de variables ou d'expressions à contrôler

# Permet de visualiser et manipuler toutes les expressions espionnes


Le débogueur de Microsoft Visual Studio .NET présente diverses fenêtres qui vous permettent d'examiner en détail votre programme et de modifier son état. Les fenêtres Automatique, Pile des appels, Variables locales et Espion sont les fenêtres de débogage que vous utiliserez le plus souvent.

Vous pouvez utiliser la fenêtre Automatique pour afficher les variables dans l'instruction en cours et dans les trois instructions suivant et précédant l'instruction en cours. L'instruction en cours est l'instruction située à l'emplacement d'exécution actuel (la prochaine instruction à exécuter si l'exécution se poursuit). Vous pouvez également faire appel à la fenêtre Automatique pour modifier la valeur d'une variable.

! Pour modifier la valeur d'une variable à l'aide de la fenêtre Automatique

1. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Automatique.

2. Dans la colonne Valeur, double-cliquez sur la valeur à modifier. 3. Entrez la nouvelle valeur, puis appuyez sur ENTRÉE.

Vous pouvez utiliser la fenêtre Pile des appels pour afficher l'historique des appels à la ligne de code en cours de débogage, y compris les types et les valeurs de paramètre. Une pile des appels désigne la série des procédures appelées dans une application.

! Pour afficher le code source d'une procédure dans la pile des appels 1. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Pile des

appels. 2. Dans la fenêtre Pile des appels, cliquez avec le bouton droit sur la procédure

dont vous souhaitez afficher le code source, puis cliquez sur Atteindre le code source dans le menu contextuel.

Introduction

Utilisation de la fenêtre Automatique

Utilisation de la fenêtre Pile des appels


La fenêtre Pile des appels affiche le nom de chaque procédure et le langage de programmation dans laquelle elle est rédigée. Le nom de la procédure doit être accompagné d'informations facultatives, telles que le nom de module, le numéro de ligne, l'offset d'octet et les noms, les types et les valeurs de paramètre. Vous pouvez activer ou désactiver l'affichage de ces informations.

! Pour modifier les informations facultatives de la fenêtre Pile des appels 1. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Pile des

appels. 2. Cliquez avec le bouton droit dans la fenêtre Pile des appels, puis

sélectionnez ou désélectionnez les informations souhaitées dans le menu contextuel.

Vous pouvez utiliser la fenêtre Variables locales pour afficher et modifier les variables locales du contexte en cours. Cette fenêtre fournit des détails explicites concernant des objets, tels que des informations sur l'héritage.

! Pour modifier la valeur d'une variable à l'aide de la fenêtre Variables locales

1. Dans le menu Déboguer, pointez sur Fenêtres, puis cliquez sur Variables locales.

2. Dans la fenêtre Variables locales, double-cliquez sur la valeur à modifier. 3. Entrez la nouvelle valeur, puis appuyez sur ENTRÉE.

Parce qu'elle affiche toutes les variables du contexte en cours, la fenêtre Variables locales peut ne pas être la fenêtre idéale si vous souhaitez vous concentrer uniquement sur un petit nombre de variables précises. Pour gérer uniquement les variables spécifiées par vos soins, faitez appel à la fenêtre Espion.

Vous pouvez utiliser la fenêtre Espion pour créer votre liste personnalisée de variables ou d'expressions à contrôler lors de l'exécution du code. Vous pouvez alors visualiser et manipuler toutes les expressions espionnes dans la fenêtre Espion.

! Pour ajouter une variable à la fenêtre Espion • Cliquez avec le bouton droit sur la variable dans l'éditeur de code, puis

cliquez sur Ajouter un espion.

! Pour évaluer une variable ou une expression à l'aide de la fenêtre Espion

1. Dans le menu Déboguer, pointez sur Fenêtres, cliquez sur Espion, puis sur Espion 1.

2. Dans la fenêtre Espion, cliquez sur une ligne vide de la colonne Nom. 3. Entrez ou collez la variable ou l'expression dans la ligne sélectionnée.

Utilisation de la fenêtre Variables locales

Utilisation de la fenêtre Espion


4. Appuyez sur ENTRÉE. Le résultat apparaît dans la colonne Valeur. Si vous avez entré le nom d'une variable tableau ou celui d'une variable objet, un contrôle Tree apparaît en regard du nom dans la colonne Nom. Cliquez sur le signe plus (+) ou le signe moins (-) dans la colonne Nom pour développer ou réduire la variable.

5. L'expression demeure dans la fenêtre Espion jusqu'à ce que vous la supprimiez.

Le débogueur de Microsoft Visual Studio .NET offre une boîte de dialogue modale, appelée Espion express, à partir de laquelle vous pouvez rapidement évaluer ou modifier une seule variable ou expression. Du fait de son caractère modal, vous pouvez laisser la boîte de dialogue Espion express ouverte pour consulter une variable ou une expression tout en parcourant votre programme. Si vous souhaitez consulter une variable ou une expression tout en parcourant votre programme pas à pas, ajoutez la variable ou l'expression en question dans la fenêtre Espion. En revanche, si vous souhaitez simplement effectuer un calcul rapide impliquant une ou plusieurs variables, utilisez la boîte de dialogue Espion express.

! Pour manipuler une variable à l'aide de l'outil Espion express • En mode arrêt, à partir d'une fenêtre source, cliquez avec le bouton droit sur

le nom d'une variable, puis cliquez sur Espion express dans le menu contextuel. La variable est automatiquement insérée dans la boîte de dialogue Espion express.

Fenêtre Espion ou boîte de dialogue Espion express



! Utilisez la fenêtre Commande pour : " Émettre des commandes (mode Commande)" Déboguer et évaluer des expressions (mode Immédiat)

TâcheTâcheTâche SolutionSolutionSolution ExempleExempleExemple

Évaluation des expressionsÉvaluation des expressions Faites précéder l'expression d'un point d'interrogation (?)

Faites précéder l'expression d'un point d'interrogation (?) ?myVariable ?myVariable

Passage du mode Commandeen mode Immédiat

Passage du mode Commandeen mode Immédiat

Tapez immed dans la fenêtre sans le signe Supérieur à (>)

Tapez immed dans la fenêtre sans le signe Supérieur à (>) immedimmed

Passage du mode Immédiat en mode Commande

Passage du mode Immédiat en mode Commande Tapez >cmd dans la fenêtreTapez >cmd dans la fenêtre >cmd>cmd

Passage provisoire en mode Commande lors d'un travail en mode Immédiat

Passage provisoire en mode Commande lors d'un travail en mode Immédiat

Tapez la commande dans la fenêtre et faites-la précéder d'un signe Supérieur à (>)

Tapez la commande dans la fenêtre et faites-la précéder d'un signe Supérieur à (>)

>alias >alias


La fenêtre Commande n'est pas une fenêtre de débogage. Elle peut, néanmoins, s'avérer fort utile lors du débogage de votre code. Vous pouvez l'utiliser pour émettre des commandes (mode Commande) ou déboguer et évaluer des expressions (mode Immédiat).

! Pour ouvrir la fenêtre Commande • Dans le menu Affichage, pointez sur Autres fenêtres, puis cliquez sur

Fenêtre Commande.

Le tableau ci-dessous décrit plusieurs commandes disponibles à partir de la fenêtre Commande.

Tâche Solution Exemple

Évaluation des expressions Faites précéder l'expression d'un point d'interrogation (?).

?myVariable

Passage du mode Commande en mode Immédiat

Tapez immed dans la fenêtre, sans le signe Supérieur à (>).

immed

Passage du mode Immédiat en mode Commande

Tapez >cmd dans la fenêtre. >cmd

Passage provisoire en mode Commande lors d'un travail en mode Immédiat (pour exécuter une seule commande)

Tapez la commande dans la fenêtre et faites-la précéder d'un signe Supérieur à (>).

>alias

Vous devez inclure le signe Supérieur à (>) lorsque vous émettez des commandes Visual Studio .NET en mode Immédiat. Les commandes saisies en mode Commande ne sont pas précédées du signe Supérieur à.

Introduction


Remarque


Application pratique : Débogage du code

Examinez le code dans le gestionnaire d'événements Click

Générez et exécutez l'application

Suggérez une méthode pour corrigerl'erreur

Utilisez les outils de débogage pour localiser l'erreur de logique


Au cours de cette application pratique, vous apprendrez à déboguer une simple application. Pour localiser une erreur de logique dans un programme, vous devrez définir un point d'arrêt, parcourir le code pas à pas et faire appel à la fenêtre Automatique pour vérifier les valeurs stockées dans les variables lorsque votre code fonctionne en mode arrêt. Vous devrez ensuite proposer une méthode susceptible de résoudre l'erreur de logique, puis mettre en �uvre une solution possible.

! Ouverture du projet • Ouvrez le projet DebugApplication.sln disponible à partir du dossier

dossier_installation\Practices\Mod08\Starter. Cette application est conçue pour calculer le nombre de mots contenus dans une phrase. L'utilisateur entre une phrase dans la zone de texte d'un formulaire, puis clique sur un bouton. Le message qui apparaît lui indique combien de mots figurent dans la phrase qu'il vient d'entrer. La capture d'écran ci-dessous présente l'application en cours d'exécution.


! Examen du gestionnaire d'événements NumberOfWords_Click • Ouvrez le gestionnaire d'événements NumberOfWords_Click, puis

examinez le code pour comprendre comment l'application a été rédigée pour accomplir les fonctionnalités attendues d'elle. Répondez aux questions suivantes à propos du code. a. Remarquez les déclarations de variable. Comment la valeur de la

variable sentence est-elle affectée ? À quelle fin la fonction Trim est-elle destinée ? La chaîne saisie par l'utilisateur dans InputTextBox est affectée à la variable sentence. La fonction Trim supprime tous les espaces au début et à la fin de la chaîne. __________________________________________________________

__________________________________________________________

b. Expliquez le code qui affecte au départ une valeur à location. Notez que le terme Chr(32) dans la déclaration de constante de spaceDelimeter se rapporte à un espace. La fonction InStr recherche un espace dans la phrase en commençant par le premier caractère. Si elle trouve un espace, la position du caractère est alors affectée à location. Dans le cas contraire, la fonction renvoie la valeur 0. __________________________________________________________

__________________________________________________________

c. Quelle condition peut empêcher l'itération de la boucle While ? Si aucun espace n'est présent, la valeur adoptée pour location est 0. Dans ce cas, le code du bloc While n'est pas exécuté. L'exécution du code se poursuivra au bloc If�Then. __________________________________________________________

__________________________________________________________

d. À quelle fin la variable wordCount est-elle destinée ? La variable wordCount stocke le nombre total de mots dans la phrase. __________________________________________________________

__________________________________________________________

e. Quel est l'intérêt d'affecter une nouvelle valeur à location dans la boucle While ? Pourquoi l'affectation à location à l'aide de la fonction InStr se reproduit-elle ? Après chaque espace trouvé, la recherche d'autres espaces est nécessaire. Le code recherche les occurrences supplémentaires de l'espace sans tenir compte des occurrences déjà comptabilisées. __________________________________________________________

__________________________________________________________


f. Décrivez le flux du code prévisible si un utilisateur tapait le mot « Test » sans espaces dans InputTextBox. Quelle valeur le message renverrait-il ? Du fait que le texte de l'utilisateur ne contient aucun espace, la valeur de location est définie à 0. La boucle While évalue la valeur en question. Cette dernière étant définie à 0, l'exécution du code passe au bloc If�Then. La longueur de sentence n'est pas égale à 0. La variable wordCount est donc incrémentée de 0 à 1 dans le bloc If�Then. Le message affiche le texte « Nombre total de mots 1 ». _________________________________________________________

_________________________________________________________

g. Décrivez le flux du code prévisible si un utilisateur tapait les mots « Me tester » dans InputTextBox. Quelle valeur le message renverrait-il ? Du fait de la présence d'un espace à la position 5 du texte saisi par l'utilisateur, la valeur de location est définie à 5. La boucle While évalue la valeur en question et incrémente wordCount de 0 à 1. Le texte restant ne contient aucun espace ; la valeur de location est donc rétablie à 0. La boucle While évalue la nouvelle valeur de location. Cette dernière étant désormais définie à 0, l'exécution du code passe au bloc If�Then. La longueur de sentence n'est pas égale à 0. La variable wordCount est donc incrémentée de 1 à 2 dans le bloc If�Then. Le message affiche le texte « Nombre total de mots 2 ». _________________________________________________________

_________________________________________________________

Vérifiez vos réponses avant de passer à la partie suivante de l'application pratique. Pour cela, utilisez au besoin les réponses fournies dans le CD-ROM du stagiaire, comparez vos réponses avec celles d'un autre stagiaire ou montrez-les à l'instructeur. Pour vérifier vos réponses aux deux dernières questions, vous pouvez également définir un point d'arrêt au début de la boucle While et utiliser les commandes Pas à pas detaillé (touche F11) pour parcourir le code pas à pas.

Remarque


! Génération et exécution de l'application 1. Exécutez l'application en mode débogage. 2. Dans le champ Entrez une phrase, entrez le mot Test, puis cliquez sur

Nombre total de mots. Le message doit afficher 1, soit le nombre correct de mots. Cliquez sur OK.

3. Dans la zone Entrez une phrase, entrez le mot Me tester, puis cliquez sur Nombre total de mots. Le message doit afficher 2, soit le nombre correct de mots dans cette phrase. Cliquez sur OK.

4. Modifiez la phrase existante dans le champ Entrez une phrase en ajoutant des espaces supplémentaires entre les deux mots.

5. Cliquez sur Nombre total de mots. Un nombre de mots incorrect s'affiche dans le message. Cliquez sur OK.

! Localisation du code responsable de l'erreur 1. Pour localiser l'erreur de logique dans cette application, réfléchissez aux

questions suivantes : a. Quelles données saisies par l'utilisateur ont engendré cette erreur ?

L'erreur survient lorsque l'utilisateur tape plusieurs espaces entre deux mots consécutifs. __________________________________________________________

__________________________________________________________

b. Quels outils de débogage pouvez-vous utiliser pour localiser le code responsable de cette erreur ? Réponse possible : Définissez un point d'arrêt dans le gestionnaire d'événements, exécutez l'application, puis utilisez la commande Pas à pas détaillé pour parcourir le code ligne après ligne. Utilisez la fenêtre Automatique pour examiner les valeurs des variables et déterminer le moment où survient l'erreur. __________________________________________________________

__________________________________________________________

2. Dans le gestionnaire d'événements NumberOfWords_Click, sur la ligne de code où débute la boucle While, définissez un point d'arrêt.

3. Exécutez l'application. Dans le champ Entrez une phrase, tapez Me tester avec des espaces supplémentaires entre les deux mots, puis cliquez sur le bouton Nombre total de mots.

4. Utilisez la commande Pas à pas détaillé (touche F11) pour parcourir le code ligne après ligne. À mesure que vous parcourez le code, utilisez la fenêtre Automatique pour examiner les valeurs des variables et déterminer le moment où survient l'erreur.


Vous pouvez utiliser les questions suivantes pour vous aider à localiser l'erreur de logique : a. Quelle est la valeur de location lors de la première itération de la boucle

While ? 5. _________________________________________________________

_________________________________________________________

b. La valeur de wordCount est-elle correctement incrémentée une fois le premier espace trouvé ? Oui. _________________________________________________________

_________________________________________________________

c. Quelle est la valeur de location lorsque la valeur de wordCount passe à 2 ? 6. _________________________________________________________

_________________________________________________________

d. Combien de mots ont été réellement comptabilisés si la valeur actuelle de location est 6 ? Un. _________________________________________________________

_________________________________________________________

e. Décrivez le problème inhérent à ce code et proposez une solution pour résoudre l'erreur. La présence d'un espace dans la chaîne sentence indique au code de la boucle While qu'il existe un mot à comptabiliser. Cette logique n'explique pas la présence éventuelle de deux ou plusieurs espaces entre les deux mots consécutifs. La procédure présentée ci-après décrit une méthode capable de résoudre l'erreur. _________________________________________________________

_________________________________________________________


! Correction de l'erreur de logique L'une des méthodes possibles pour résoudre le problème propre à ce code est de supprimer chaque mot une fois comptabilisé, puis de supprimer les espaces au début de la chaîne restante. La variable sentence est un type de données String qui utilise la méthode Remove pour supprimer les caractères d'une chaîne. Le code suivant explique comment utiliser la méthode Remove et la fonction LTrim pour résoudre l'erreur : sentence = LTrim(sentence.Remove(0, location))

Après avoir supprimé un mot de la chaîne à l'aide du code ci-dessus, vous devez également modifier l'appel de fonction InStr dans la boucle While, puis définir la position de début à 1 à chaque exécution du code. • Corrigez le code dans le gestionnaire d'événements

NumberOfWords_Click. Le code corrigé doit se présenter de la manière suivante : While location < > 0 wordCount += 1 sentence = LTrim(sentence.Remove(0, location)) location = InStr(1, sentence, spaceDelimeter) End While

! Test de l'application • Exécutez et testez l'application en mode débogage.

Les fichiers solution sont disponibles dans le dossier dossier_installation\Practices\Mod08\Solution.

Fichiers solution


Leçon : Gestion des exceptions

! Classe Exception

! Présentation de la gestion structurée des exceptions

! Utilisation de l'instruction Try�Catch

! Utilisation du bloc Finally

! Procédure de déclenchement des exceptions

! Principes d'utilisation de la gestion structurée des exceptions


Microsoft Visual Basic prend en charge la gestion structurée des exceptions. La gestion structurée des exceptions vous permet de gérer les erreurs susceptibles de se produire dans un bloc de code tout en exécutant votre application. Grâce à elle, vous pouvez prévoir l'apparition d'erreurs éventuelles et les empêcher de gêner les fonctionnalités essentielles de votre application.

Au cours de cette leçon, vous apprendrez à mettre en �uvre la gestion structurée des exceptions dans Microsoft Visual Basic .NET, puis à l'utiliser en tant que méthode de gestion des erreurs.


! Classe Exception ! Présentation de la gestion structurée des exceptions ! Utilisation de l'instruction Try�Catch ! Utilisation du bloc Finally ! Procédure de déclenchement des exceptions ! Principes d'utilisation de la gestion structurée des exceptions ! Démonstration : Utilisation de la gestion structurée des exceptions


! expliquer l'objectif de la gestion structurée des exceptions ; ! créer et utiliser les blocs Try�Catch�Finally ; ! lever des exceptions.

Introduction




Classe Exception

! Les classes d'exception vous permettent d'extraire des informationssur toutes les exceptions rencontrées

! Les propriétés de la classe de base Exception vous permettentd'analyser les exceptions

" Propriétés principales : StackTrace, Message, HelpLink et Source

IOExceptionIOException

ExceptionException

OutOfMemoryExceptionOutOfMemoryException

ApplicationExceptionApplicationException

SystemExceptionSystemException

FileNotFoundExceptionFileNotFoundException

! .NET Framework fournit le modèle objet d'exception suivant :


Une exception désigne une condition d'erreur ou un comportement inattendu survenant lors de l'exécution d'un programme et exigeant l'exécution d'un code hors du flux de contrôle normal. Plusieurs causes peuvent être à l'origine des exceptions : un défaut dans votre code ou le code appelé, des ressources du système d'exploitation indisponibles, des conditions inattendues dans le Common Language Runtime, et ainsi de suite. Une exception est levée à partir de la zone de code (en d'autres termes, elle provient de cette zone) où survient le problème.

Dans Microsoft .NET Framework, le runtime crée un objet destiné à représenter une exception lorsqu'elle survient. Les exceptions sont des objets qui héritent de la classe de base Exception. Le modèle de programmation .NET Framework définit un éventail de classes d'exception. Ces classes fournissent des données significatives relatives aux exceptions et vous permettent d'extraire des informations sur toutes les exceptions rencontrées. Ce sont ces informations qui vous permettent de déboguer vos applications avec efficacité.

Le tableau ci-dessous décrit plusieurs des propriétés de la classe de base Exception à l'aide desquelles vous pouvez identifier le type et la cause de l'exception ainsi que son emplacement dans le code. Toutes les exceptions héritant de la classe de base présentent ces propriétés.

Propriété Description

StackTrace Répertorie les méthodes appelées menant à l'exception et vous aide à retrouver l'origine de l'erreur dans le code.

Message Renvoie un message texte décrivant l'erreur. Utilisez cette propriété pour extraire des informations sur la cause d'une exception.

Vous pouvez modifier le texte pour créer un message crypté plus facile à comprendre. Si aucune chaîne de texte de message d'erreur n'est fournie, c'est la valeur par défaut qui est adoptée.

Qu'est-ce qu'une exception ?

Classe Exception


(suite) Propriété Description

HelpLink Permet d'obtenir ou de définir un lien à un fichier d'aide associé.

Source Permet d'obtenir ou de définir une chaîne contenant le nom de l'objet ayant causé l'erreur ou le nom de l'assembly d'où provient l'exception.


Présentation de la gestion structurée des exceptions

! Détecte et répond à des erreurs lors de l'exécution d'uneapplication

! Utilisez l'instruction Try�Catch�Finally pour encapsuleret protéger des blocs de code pouvant potentiellementprovoquer des erreurs" Chaque bloc possède un ou plusieurs gestionnaires

associés" Chaque gestionnaire spécifie une forme de condition de

filtre sur le type d'exception qu'il gère! Avantages :

" Permet de séparer le code de gestion des erreurs du code de logique

" Facilite la lecture, le débogage et la gestion du code


La gestion structurée des exceptions correspond à du code conçu pour détecter et répondre à des erreurs lors d'une exécution en associant une structure de contrôle (semblable à Select Case ou While) à des exceptions, des blocs de code protégés et des filtres.

Si une exception survient au sein d'une méthode non équipée pour la gérer, l'exception est renvoyée vers la méthode d'appel. Si elle n'est pas gérée dans la méthode d'appel, la recherche d'un gestionnaire s'étend à la pile des appels. Si aucun gestionnaire n'existe pour l'exception, un message d'erreur apparaît et l'application est fermée.

Vous pouvez recourir à l'instruction Try�Catch�Finally pour protéger des blocs de code pouvant potentiellement provoquer des erreurs.

Le bloc Try comprend une expression susceptible de générer une exception. Il est constitué d'une ou plusieurs instructions Catch associées permettant de filtrer les exceptions et de les faire correspondre à une action particulière. Si l'exception survient, le runtime interrompt la procédure d'exécution normale et part à la recherche d'un bloc Catch capable d'intercepter l'exception en fonction de son type.

! Si aucun bloc Catch approprié n'est immédiatement trouvé, le runtime continue dans la pile des appels et recherche la procédure d'appel.

! Si aucun bloc Catch approprié n'est trouvé dans la pile des appels, le runtime recherche la procédure ayant appelé la procédure d'appel, et ainsi de suite, jusqu'à ce qu'il trouve un bloc Catch convenable.

Introduction

Conséquences en cas d'absence de gestion des exceptions

Utilisation de la gestion structurée des exceptions


! Si un bloc Catch est trouvé, l'exception est considérée comme interceptée et la procédure d'exécution redémarre en commençant par le corps du bloc Catch.

! Si aucun bloc Catch n'est trouvé, un message d'erreur apparaît et l'application est fermée.

En utilisant les blocs Try et Catch, vous séparez les instructions de gestion des erreurs des instructions de logique clés. La lecture et le débogage de votre programme s'en trouvent facilités.


Utilisation de l'instruction Try�Catch

! Placez les sections du code suceptibles de lever des exceptions dans un bloc Try

! Gérez les exceptions dans un bloc Catch distinct

Try

fs = New FileStream("data.txt", _ FileMode.Open)

Catch ex As FileNotFoundException

MessageBox.Show("Fichier introuvable")

Catch ex As Exception

MessageBox.Show(ex.Message)

End Try

Try

fs = New FileStream("data.txt", _ FileMode.Open)


MessageBox.Show("Fichier introuvable")



End Try

Logique du programmeLogique du programme

Gestion des exceptionsGestion des exceptions


Vous pouvez mettre en �uvre la gestion structurée des exceptions dans Visual Basic .NET à l'aide de l'instruction Try�Catch. Les lignes de code suivantes illustrent la structure d'une instruction Try�Catch simple :

Try ' Démarre un gestionnaire structuré des exceptions Catch [optional filter] ' Ce code est exécuté si les instructions du bloc Try ' échouent et le filtre de l'instruction Catch est true End Try ' Termine un gestionnaire structuré des exceptions

Le bloc Try d'un gestionnaire d'exceptions Try�Catch contient la section du code que vous souhaitez gérer à l'aide de votre gestionnaire d'exceptions. Placez les sections du code susceptibles de lever des exceptions dans un bloc Try, puis le code chargé de la gestion des exceptions dans un bloc Catch.

Le code d'un bloc Try est toujours exécuté. Si une erreur survient lors de l'exécution d'un code de la section Try, Visual Basic examine chaque instruction Catch dans le gestionnaire des exceptions jusqu'à ce que le type de l'exception survenue corresponde au nom de l'exception spécifiée dans l'instruction Catch, puis il transfère le contrôle de la première ligne du code vers l'instruction Catch. Si aucun bloc Catch n'est trouvé, une erreur survient.

Les instructions Catch étant traitées dans l'ordre, l'ordre dans lequel vous rédigez vos instructions Catch est, lui aussi, primordial. Les blocs Catch destinés à des exceptions spécifiques doivent être placés devant le bloc Catch d'une exception générale.

Syntaxe

Placement du code

Traitement de l'instruction Try�Catch

Important


Les lignes de code suivantes présentent un exemple de gestionnaire structuré des exceptions simple. Dans cet exemple, le bloc Try s'exécute. Si une erreur FileNotFoundException survient, le code du premier bloc Catch est alors exécuté. Pour toutes les autres erreurs, c'est le code du deuxième bloc Catch qui est exécuté.

Notez que les erreurs ciblées dans le premier bloc Catch sont des erreurs spécifiques. Le deuxième bloc Catch est réservé à l'interception d'erreurs générales.

Try fs = New FileStream("data.txt", FileMode.Open) Catch ex As FileNotFoundException MessageBox.Show("Fichier introuvable") Catch ex As Exception MessageBox.Show(ex.Message) End Try

Exemple d'utilisation de l'instruction Try�Catch


Utilisation du bloc Finally

! Bloc de code facultatif qui, s'il est inclu, est toujours exécuté! Placez dans le bloc Finally le code de nettoyage, tel que le

code pour la fermeture de fichiers

Try

fs = New FileStream("data.txt", FileMode.Open)


MessageBox.Show("Fichier de données manquant")



Finally

If Not (fs Is Nothing) Then fs.Close( )

End Try

Try

fs = New FileStream("data.txt", FileMode.Open)


MessageBox.Show("Fichier de données manquant")



Finally

If Not (fs Is Nothing) Then fs.Close( )

End Try


Le bloc Finally est un bloc de code facultatif qui, s'il est inclus, est toujours exécuté. Dans ce bloc, vous pouvez définir les actions à entreprendre, indépendamment de l'apparition ou non d'une exception. Ces actions peuvent inclure notamment la fermeture de fichiers ou la libération d'objets. Le bloc Finally est le plus souvent employé pour éliminer des ressources utilisées dans votre code lorsqu'une méthode échoue.

Le code de la section Finally est toujours exécuté en dernier, juste avant que le bloc de gestion des erreurs devienne hors de portée. Si vous incluez ce bloc, il est exécuté après le bloc Try si aucune erreur ne s'est produite ou après le traitement du bloc Catch approprié si une exception est interceptée.

Introduction


Les lignes de code suivantes décrivent, à titre d'exemple, l'utilisation d'un bloc Finally pour fermer un fichier ouvert.

Dans cet exemple :

! Le bloc Try s'exécute toujours.

• Si une erreur FileNotFoundException survient, le code du premier bloc Catch est exécuté ensuite, suivi du code du bloc Finally..

• Si un autre type d'erreur survient, le code du deuxième bloc Catch est exécuté ensuite, suivi du code du bloc Finally..

! S'il n'y a aucune erreur, le code du bloc Finally est exécuté après le code du bloc Try. Try fs = New FileStream("data.txt", FileMode.Open) Catch ex As FileNotFoundException MessageBox.Show("Fichier de données manquant") Catch ex As Exception MessageBox.Show(ex.Message) Finally If Not (fs Is Nothing) Then fs.Close( ) End Try

Exemple d'utilisation de Try�Catch�Finally


Procédure de déclenchement des exceptions

! L'instruction Throw crée une exception que vouspouvez gérer à l'aide du code de gestion structurée des exceptions

If (day < 1) Or (day > 365) Then

Throw New ArgumentOutOfRangeException( )

Else

...

End If

If (day < 1) Or (day > 365) Then


Else

...

End If


L'instruction Throw crée une exception que vous pouvez gérer à l'aide du code de gestion structurée des exceptions. Dans certains cas, vous devriez utiliser une instruction Throw pour lever une exception que vous pouvez intercepter en appelant du code. Pour comprendre à quel moment lever une exception, considérez le scénario présenté ci-après.

Lors du développement d'applications plus volumineuses, il est courant de rédiger du code réutilisable : des procédures Function et Sub qu'il est possible d'utiliser à maintes reprises dans l'application ou dans d'autres applications. Traditionnellement, une fonction adopte certains paramètres, effectue une tâche et peut renvoyer une valeur. Par exemple, prenons une fonction qui interprète le jour d'une année comme un entier et renvoie pour valeur la date du calendrier. Une fois le nombre 33 transmis, la fonction doit renvoyer la valeur « 2 février ».

En tant que personne ayant rédigé cette fonction, vous devez tenir compte de cas où votre fonction transmet des données non valides. Par exemple, si votre fonction transmet un nombre négatif ou supérieur à 365 pour les années non bissextiles, une erreur se produit et la valeur renvoyée est incorrecte.

La meilleure solution à ce problème dépend de l'application. Dans un cas simple, vous pouvez demander à l'utilisateur d'entrer les informations correctes. En revanche, si cette fonction est appelée par une autre fonction, et non un utilisateur, la solution apparaît moins simple. Dans ce cas, vous pouvez rédiger une instruction Throw permettant de lever l'exception adéquate lorsque l'argument transmis à votre fonction est hors limites.

Introduction

Scénario d'utilisation de l'instruction Throw


Les lignes de code suivantes utilisent l'instruction Throw pour générer une erreur ArgumentOutOfRangeException :

If (day < 1) Or (day > 365) Then Throw New ArgumentOutOfRangeException( ) Else ... End If

Exemple d'utilisation de l'instruction Throw


Principes d'utilisation de la gestion structurée des exceptions

N'utilisez pas la gestion structurée des exceptions pour les erreurs qui ne sont pas suceptibles de se produire régulièrement. Utilisez d'autres blocs de code pour résoudre ces erreurs

" If�End If, etc.

N'utilisez pas la gestion structurée des exceptions pour les erreurs qui ne sont pas suceptibles de se produire régulièrement. Utilisez d'autres blocs de code pour résoudre ces erreurs

" If�End If, etc.

Utilisez la valeur de retour pour les erreurs courantes" Exemple : Les méthodes de lecture d'E/S sur fichier ne lèvent

pas une exception de fin de fichier

Utilisez la valeur de retour pour les erreurs courantes" Exemple : Les méthodes de lecture d'E/S sur fichier ne lèvent

pas une exception de fin de fichier

Levez toujours des exceptions dans les blocs Catch qui vont de la plus spécifique à la moins spécifiqueLevez toujours des exceptions dans les blocs Catch qui vont de la plus spécifique à la moins spécifique


La gestion structurée des exceptions peut être un moyen efficace de gérer des erreurs éventuelles dans votre application. Néanmoins, il est primordial de savoir quand utiliser un bloc Try�Catch�Finally et d'autres solutions de code pour résoudre un problème. Si un problème est susceptible de se produire, vous pouvez le vérifier et le traiter par programme sans recourir à la gestion structurée des exceptions. L'utilisation de la gestion structurée convient lorsqu'une erreur est bel et bien une exception (c.-à-d. une occurrence improbable mais possible).

L'exemple ci-dessous utilise une instruction If pour vérifier si une connexion est fermée. Vous pouvez utiliser cette méthode comme une solution alternative au déclenchement d'une exception si la connexion n'est pas fermée.

If conn.State <> ConnectionState.Closed Then conn.Close() End If

Dans l'exemple ci-dessous, une exception est levée si la connexion n'est pas fermée.

Try conn.Close() Catch ex As InvalidOperationException ' Traiter l'erreur ou l'ignorer End Try

Le choix de la méthode à adopter pour gérer des erreurs potentielles dépend de la fréquence à laquelle un événement particulier est supposé se produire. Si l'événement constitue véritablement une exception et s'avère être une erreur (par exemple, une erreur de fin de fichier inattendue), l'utilisation de la gestion structurée des exceptions est conseillée du fait que la quantité de code exécutée dans un cas normal est moindre. Si l'événement se produit couramment, il est préférable d'utiliser une autre méthode pour vérifier des erreurs. Dans ce cas, si une exception survient, elle prendra plus de temps à gérer.

Introduction

Exemple de gestion d'une erreur possible à l'aide de l'instruction If

Exemple de gestion de la même erreur avec Try�Catch

Utilisation de chaque méthode


La liste suivante mentionne d'autres instructions à suivre lors de la mise en �uvre de la gestion structurée des exceptions :

! Si vous êtes en mesure de prévoir une situation (par exemple, une erreur de fin de fichier), n'utilisez pas d'exception pour l'indiquer. Utilisez plutôt la valeur de retour de la méthode. Par exemple, dans .NET Framework, les méthodes de lecture d'entrée/sortie (E/S) sur fichier ne lèvent pas une exception de fin de fichier. À la place, elles renvoient une valeur indiquant que le fichier est impossible à lire.

! Levez toujours des exceptions dans les blocs Catch qui vont de la plus spécifique à la moins spécifique. Cette technique permet de gérer l'exception spécifique avant qu'elle ne soit transmise à un bloc Catch plus général.

! Utilisez les blocs Try�Finally avec du code susceptible de générer une exception et placez vos instructions Catch dans un seul emplacement. L'instruction Try génère alors l'exception, l'instruction Finally se ferme ou alloue à nouveau des ressources et l'instruction Catch gère l'exception à partir d'un emplacement central.

Pour plus d'informations détaillant quand utiliser la gestion structurée des exceptions, reportez-vous à la section Instructions de gestion des exceptions structurée dans la documentation Microsoft Visual Studio .NET.

Autres instructions relatives à la gestion structurée des exceptions

Remarque


Démonstration : Utilisation de la gestion structurée des exceptions

! Au cours de cette démonstration, vousapprendrez à mettre en �uvre la gestionstructurée des exceptions dans votre code


Au cours de cette démonstration, vous apprendrez à utiliser l'instruction Try�Catch pour mettre en �uvre la gestion structurée des exceptions.



! Types d'erreurs

! Utilisation du débogueur

! Gestion des exceptionsUtilisationde Visual

Studio .NET

Accèsaux données

Écriturede code

Créationd'une

interface



1. Expliquez les termes suivants : a. Erreur de syntaxe b. Erreur d'exécution c. Point d'arrêt d. Pile des appels a. Une erreur de syntaxe survient lorsque vous rédigez du code selon une

méthode contraire aux règles du langage. b. Une erreur d'exécution survient lorsqu'une instruction tente

d'exécuter une opération irréalisable. Les erreurs d'exécution apparaissent après la compilation et l'exécution de votre code.

c. Un point d'arrêt est un marqueur intégré à votre code qui permet à Visual Basic d'interrompre l'exécution du code sur une ligne spécifique.

d. Une pile des appels désigne la série des procédures appelées dans une application.

2. Imaginons que vous souhaitez passer en mode arrêt uniquement si une condition précise est vraie (true). Comment pouvez-vous définir ce type de point d'arrêt ? Utilisez la boîte de dialogue Propriétés des points d'arrêt pour définir la propriété Condition du point d'arrêt.


3. Examinez le code ci-dessous. Dans quel ordre les instructions du bloc Try�Catch�Finally sont-elles exécutées dans chacun des cas suivants ? a. Aucune exception ne se produit. b. Une exception FileNotFoundException se produit. c. Une exception IOException se produit. Try fs = New FileStream("data.txt", FileMode.Open) Catch ex As FileNotFoundException MessageBox.Show("Fichier introuvable") Catch ex As Exception MessageBox.Show(ex.Message) Finally If Not (fs Is Nothing) Then fs.Close( ) End Try

a. L'instruction Try est exécutée, suivie de l'instruction Finally. b. L'instruction Try est exécutée, suivie de la première instruction

Catch et de son message associé, suivie ensuite de l'instruction Finally.

c. L'instruction Try est exécutée, suivie de la deuxième instruction Catch et de son message associé, suivie ensuite de l'instruction Finally.

4. Rédigez une instruction permettant de lever une exception de type ArgumentOutOfRangeException si la variable percent est inférieure à zéro ou supérieure à 100. If (percent < 0) Or (percent > 100) Then


End If

5. Pour quelle raison la gestion structurée des exceptions ne doit-elle pas être utilisée pour gérer une erreur susceptible de se produire fréquemment ? Si la gestion d'exceptions dans votre code n'affecte nullement les performances lorsque vous levez des exceptions, il n'en va pas de même pour la procédure visant à déterminer quel bloc Catch est capable d'intercepter une exception et à exécuter en plus tous les blocs Finally.


Atelier 8.1 : Mise en �uvre de la gestion structurée des exceptions

! Exercice 1 : Utilisation des blocs Try�Catch

! Exercice 2 : Utilisation des blocs Try�Catch�Finally



• gérer des exceptions à l'aide de la gestion structurée des exceptions.

Cet atelier porte sur les concepts évoqués dans ce module. Il risque, en conséquence, de ne pas être conforme aux recommandations de sécurité énoncées par Microsoft.


! Maîtrisez la gestion structurée des exceptions en tant que technique de gestion des erreurs.

! Connaître les bases de la syntaxe Try�Catch�Finally.

Les fichiers solution de cet atelier sont disponibles dans les dossiers dossier_installation\Labfiles\Lab081\Ex01\Solution et dossier_installation\Labfiles\Lab081\Ex02\Solution.

Objectifs

Remarque


Fichiers solution



Exercice 1 Utilisation des blocs Try�Catch

Au cours de cet exercice, vous apprendrez à ajouter des blocs Try�Catch pour gérer des exceptions dans un programme existant qui ouvre et affiche le contenu d'un fichier texte.

! Ouverture du projet • Ouvrez le projet ExceptionApplication.sln situé dans le dossier


! Examen de la procédure Sub Main • Ouvrez la procédure Sub Main à partir du fichier FileOpen.vb, puis

observez les actions suivantes : a. La fonction FileStream est utilisée pour ouvrir un fichier. b. La fonction StreamReader est utilisée pour lire les lignes d'un fichier

texte. c. La fonction MessageBox est utilisée pour afficher la ligne lue à partir du

fichier. d. Enfin, les fonctions FileStream et StreamReader sont fermées.

! Génération de l'application • Dans le menu Générer, cliquez sur Générer la solution.

Que se passe-t-il ? La génération échoue suite à des erreurs de syntaxe. Ces erreurs sont dues au fait que la bibliothèque qui contient la classe MessageBox n'est pas référencée dans le projet. ____________________________________________________________

____________________________________________________________


! Résolution de l'erreur 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

Références, puis cliquez sur Ajouter une référence. À partir de la boîte de dialogue Ajouter une référence, dans l'onglet .NET, cliquez sur System.Windows.Forms.dll. Cliquez enfin sur Sélectionner, puis sur OK.

2. Une fois les erreurs résolues, générez l'application, puis exécutez-la en mode débogage. Que se passe-t-il lorsque vous exécutez l'application ? Pourquoi ? L'application ne répond plus en raison d'une exception non gérée. Le fichier test.txt n'existe pas. ____________________________________________________________

____________________________________________________________

Comment géreriez-vous l'erreur ? Ajoutez la gestion structurée des exceptions pour empêcher l'application de tomber en panne lorsqu'un fichier n'existe pas. ____________________________________________________________

____________________________________________________________

3. Cliquez sur Continuer pour quitter l'application.

! Gestion de l'exception avec Try�Catch • Modifiez le code dans la procédure Sub Main en y ajoutant un bloc

Try�Catch. a. Joignez le code existant au bloc Try�End Try. b. Rédigez un bloc Catch général pour intercepter toutes les exceptions.

Utilisez un message pour afficher le texte « Fichier introuvable ». Votre code doit se présenter de la manière suivante : Try Dim file As New FileStream ("C:\test\test.txt",_ FileMode.Open) Dim reader As New StreamReader (file) Dim line As String = reader.ReadLine ( ) MessageBox.Show (line) reader.Close ( ) file.Close ( ) Catch ex As Exception MessageBox.Show("Fichier introuvable") End Try


! Génération de l'application 1. Exécutez l'application en mode débogage.

Que se passe-t-il ? L'application affiche un message informant l'utilisateur que le fichier est introuvable. ____________________________________________________________

____________________________________________________________

2. Cliquez sur OK dans le message pour quitter l'application.

! Création d'un dossier et d'un fichier 1. Créez un dossier intitulé Test dans le lecteur C. 2. Dans le menu Démarrer, pointez successivement sur Tous les

programmes, sur Accessoires, puis cliquez sur Bloc-notes. 3. Dans le Bloc-notes, tapez une ligne de texte. 4. Dans le menu Fichier, cliquez sur Enregistrer. 5. Dans la boîte de dialogue Enregistrer sous, accédez au dossier C:\Test,

puis enregistrez le fichier sous le nom de test.txt. Fermez le fichier.

! Génération et exécution de l'application 1. Générez et exécutez l'application en mode débogage.

Que se passe-t-il ? L'application affiche la ligne de texte du fichier test.txt dans un message. ____________________________________________________________

____________________________________________________________


! Ajout d'un autre bloc Catch • Ajoutez un autre bloc Catch après le bloc Catch existant. Le deuxième bloc

Catch doit intercepter une exception DirectoryNotFoundException. Dans le bloc Catch, utilisez un message pour afficher le message d'erreur « Chemin d'accès incorrect ». Votre code final doit se présenter de la manière suivante : Catch ex As Exception MessageBox.Show("Fichier introuvable") Catch ex As DirectoryNotFoundException MessageBox.Show("Chemin d'accès incorrect")


! Modification du chemin d'accès au fichier • Dans votre code, redéfinissez le chemin d'accès au fichier test.txt à

C:\CheminIncorrect\test.txt. Votre code doit se présenter de la manière suivante : Dim file As New FileStream ("c:\CheminIncorrect\test.txt", _ FileMode.Open)

! Génération et test de l'application 1. Exécutez l'application en mode débogage.

Que se passe-t-il ? Pourquoi ? Un message d'erreur incorrect, « Fichier introuvable », apparaît car l'ordre des blocs Catch est incorrect. L'organisation des blocs Catch doit inclure dans l'ordre les blocs spécifiques, puis les blocs généraux. Dans ce cas, le premier bloc Catch est le bloc général. C'est pourquoi il intercepte tous les types d'exceptions. Le deuxième bloc Catch n'est pas exécuté. ____________________________________________________________

____________________________________________________________

Comment devez-vous résoudre cette erreur ? Déplacez le bloc Catch ex As Exception à la fin du bloc Try�Catch, modifiez le message affiché par le bloc Catch général, puis ajoutez un autre bloc Catch pour gérer une exception FileNotFoundException. ____________________________________________________________

____________________________________________________________

2. Cliquez sur OK pour quitter l'application.


! Modification des blocs Catch 1. Dans votre code, redéfinissez le chemin d'accès au fichier test.txt à

C:\test.txt. Votre code doit se présenter de la manière suivante : Dim file As New FileStream ("c:\test.txt", FileMode.Open)

2. Déplacez le bloc Catch ex As Exception à la fin du bloc Try�Catch.

Utilisez le message pour afficher la propriété Message de la classe Exception.

3. Ajoutez un nouveau bloc Catch en tant que premier bloc Catch pour gérer une exception FileNotFoundException. Utilisez un message pour afficher une indication adéquate. Votre code doit se présenter de la manière suivante : Catch ex As FileNotFoundException MessageBox.Show("Fichier introuvable") Catch ex As DirectoryNotFoundException MessageBox.Show("Chemin d'accès incorrect") Catch ex As Exception MessageBox.Show(ex.Message)

! Génération et test de l'application 1. Exécutez l'application en mode débogage et vérifiez si le message d'erreur

« Fichier introuvable » apparaît. 2. Cliquez sur OK pour quitter l'application. 3. Dans votre code, redéfinissez le chemin d'accès au fichier test.txt à

A:\test.txt. Votre code doit se présenter de la manière suivante : Dim file As New FileStream ("a:\test.txt", FileMode.Open)

4. Exécutez à nouveau l'application en mode débogage.

Le dernier bloc Catch gère l'exception et affiche le message approprié à l'aide de la propriété Message de la classe Exception.



Exercice 2 Utilisation des blocs Try�Catch�Finally

Au cours de cet exercice, vous utiliserez les blocs Try�Catch�Finally pour gérer des exceptions. Vous utiliserez des points d'arrêt et la commande Exécuter jusqu'au curseur pour déboguer une application. Vous modifierez enfin un programme existant développé pour lire le montant d'une vente à partir d'un fichier texte, puis calculer et afficher une remise.

! Ouverture du projet • Ouvrez le projet ExceptionApplication.sln situé dans le dossier


! Examen de la procédure Sub Main • Ouvrez la procédure Sub Main à partir du fichier FileOpen.vb, puis

observez les actions suivantes : a. La fonction FileStream est utilisée pour ouvrir le fichier input.txt situé

dans le dossier dossier_installation\Labfiles\Lab081\Ex02\Starter\bin. b. La fonction StreamReader est utilisée pour lire le texte du fichier. c. La fonction CInt est utilisée pour convertir les données lues à partir du

fichier en données de type Integer. d. Un message est utilisé pour calculer une remise sur le montant lu dans le

fichier, puis dévoiler le montant de la remise à l'utilisateur. e. Les fonctions file et reader sont fermées. f. Un bloc Catch est utilisé pour gérer toutes les exceptions.

! Examen du fichier texte • Ouvrez le fichier input.txt situé dans le dossier dossier_installation\Labfiles\

Lab081\Ex02\Starter\bin. Remarquez que le fichier contient un montant d'achat défini à 100.


Que se passe-t-il ? Un message affiche une remise de 8,00 euros. ____________________________________________________________

____________________________________________________________


! Modification du fichier texte 1. À l'aide du Bloc-notes, ouvrez le fichier disponible dans le dossier

dossier_installation\Labfiles\Lab081\Ex02\Starter\bin. Modifiez le montant de 100 à 100b.

2. Enregistrez et fermez le fichier.



Que se passe-t-il ? Un message affiche un texte indiquant qu'une erreur de cast est survenue. ____________________________________________________________

____________________________________________________________


! Débogage de l'application 1. Définissez un point d'arrêt dans la ligne de code MessageBox.Show. 2. Exécutez à nouveau l'application en mode débogage.

Pourquoi l'application n'est-elle pas passée en mode arrêt une fois le point d'arrêt atteint ? L'exception s'est produite avant la ligne de code MessageBox.Show. Lorsqu'une exception survient sur la ligne d'un bloc Try, les lignes de code restantes du bloc Try ne sont pas exécutées et le flux est transféré vers le bloc Catch. ____________________________________________________________

____________________________________________________________

3. Cliquez sur OK dans le message pour quitter l'application. 4. Supprimez le point d'arrêt. 5. Placez le point d'insertion sur la ligne Try, puis démarrez l'application à

l'aide de la commande Exécuter jusqu'au curseur. 6. Utilisez la touche F11 pour parcourir votre code pas à pas.

Quelle ligne lève l'exception ? Pourquoi ? La ligne CInt(reader.ReadLine( )) lève une erreur InvalidCastException car la conversion du type de données à échoué. ____________________________________________________________

____________________________________________________________

Le code permettant de fermer les fonctions file et reader s'exécute-t-il une fois l'exception survenue ? Non. ____________________________________________________________

____________________________________________________________


Comment s'assurer que le code destiné à fermer les fonctions file et reader est toujours exécuté ? Rédigez dans un bloc Finally le code permettant de fermer ces resources. ____________________________________________________________

____________________________________________________________


! Ajout d'un bloc Finally 1. Ajoutez un bloc Finally avant l'instruction End Try. 2. Dans le bloc Try, supprimez les appels de la méthode Close. 3. Dans le bloc Finally, fermez les objets file et reader. Votre code doit se

présenter de la manière suivante : Finally file.Close ( ) reader.Close ( )

4. Notez que ce code présente deux erreurs de syntaxe. À quoi ces erreurs

sont-elles dues ? La portée des objets file et reader se limite uniquement au bloc parce qu'ils sont déclarés dans le bloc Try. ____________________________________________________________

____________________________________________________________

5. Déclarez les variables file et reader hors du bloc Try, puis modifiez le code du bloc Try afin de créer de nouvelles instances des classes FileStream et StreamReader et les assigner à ces variables. Votre code doit se présenter de la manière suivante : Sub Main Dim file As FileStream Dim reader As StreamReader Try file = New FileStream("input.txt", FileMode.Open) reader = New StreamReader(file) ... Catch ex as Exception MessageBox.Show(ex.Message) Finally ... End Try


! Test de l'application 1. Définissez un point d'arrêt dans l'instruction Finally. 2. Générez et exécutez l'application en mode débogage. 3. Cliquez sur OK dans le message, puis appuyez sur la touche F11 pour

parcourir le code pas à pas et vérifier que l'application exécute le code dans le bloc Finally.

4. Quittez l'application. 5. Supprimez le point d'arrêt.

! Modification du chemin d'accès au fichier • Modifiez le chemin d'accès au fichier comme décrit dans la ligne de code

ci-dessous : file = New FileStream("c:\input.txt", FileMode.Open)

! Test de l'application 1. Exécutez l'application en mode débogage. Dans le message qui apparaît,

cliquez sur OK. Pourquoi une exception non gérée de type NullReferenceException se produit-elle ? Cette exception se produit suite à une tentative d'appel de la méthode Close sur un objet file qui n'existe pas. Le fichier d'entrée n'existe pas dans le dossier C:\. La nouvelle instance de la classe FileStream n'a donc pas été créée. ____________________________________________________________

____________________________________________________________

2. Cliquez sur Continuer pour quitter l'application. 3. Dans le bloc Finally, avant d'appeler la méthode Close, utilisez la fonction

IsNothing pour vérifier si les objets existent. Votre code doit se présenter de la manière suivante : ... Finally If Not IsNothing (reader) Then reader.Close( ) If Not IsNothing (file) Then file.Close( ) End Try

! Test de l'application • Générez, puis exécutez l'application.

L'application doit alors intercepter l'exception, afficher un message, puis se fermer dès que vous cliquez sur OK dans le message.

Table des matières

Vue d'ensemble 1

Leçon : Création de menus 2

Leçon : Création de barres d'état 14

Leçon : Création de barres d'outils 22


Module 9 : Amélioration de l'interface utilisateur

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaines, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs et toute ressemblance avec des sociétés, produits, noms de domaines, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l�objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d'autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d'un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Module 9 : Amélioration de l'interface utilisateur iii

Notes de l'instructeur Ce module présente aux stagiaires les menus, les barres d'état et les barres d'outils comme des moyens d'offrir des fonctionnalités aux utilisateurs ou de leur donner des informations importantes dans une application. Dans ce module, les stagiaires apprendront à créer des menus, des barres d'état et des barres d'outils afin d'améliorer la convivialité d'une application.


! créer des menus personnalisés afin de grouper les commandes d'une application ;

! créer une barre d'état en vue de fournir des commentaires aux utilisateurs à propos d'une application ;

! créer une barre d'outils afin de fournir une interface graphique grâce à laquelle les utilisateurs pourront accéder aux fonctions principales d'une application.


! Fichier Microsoft® PowerPoint® 2560A_09.ppt ! Fichier de présentation multimédia 2560A_09d005.wmv


! lire tous les documents de cours relatifs à ce module ; ! réaliser les trois applications pratiques, aucun atelier n'est associé à ce

module ; ! réviser la présentation multimédia de ce module.

Présentation et applications pratiques : 75 minutes Atelier : 0 minute

Documents de cours

Préparation

iv Module 9 : Amélioration de l'interface utilisateur


Leçon : Création de menus Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Pour exécuter cette présentation, cliquez sur l'icône située au centre de la diapositive. Si vous le souhaitez, vous pouvez vous référer aux informations destinées à l'instructeur concernant la présentation du fichier multimédia. Elles se trouvent dans la section Démonstrations des notes de l'instructeur.


L'objectif de cette section est de vérifier que les stagiaires sont familiarisés avec la terminologie relative aux menus : en-tête de menu, élément de menu et sous-menu. Pour illustrer chacun de ces termes, utilisez la capture d'écran sur la diapositive ou servez-vous d'un des menus de Microsoft Visual Basic® .NET. Notez que les menus contextuels sont évoqués dans le cours 2565, « Developing Microsoft .NET Applications for Windows (Visual Basic .NET) » (en anglais). Vous pouvez montrer ce qu'est un menu contextuel en cliquant avec le bouton droit de la souris.

Insistez sur le fait que les menus sont destinés à rendre une application plus simple à utiliser. Par conséquent, il est préférable de créer des menus qui sont cohérents avec les autres applications Microsoft Windows®. Pour montrer comment fonctionnent les touches d'accès rapide, ouvrez Microsoft Visual Studio® .NET, appuyez sur ALT+F pour ouvrir le menu Fichier, puis appuyez sur N pour ouvrir le sous-menu Nouveau du menu Fichier.

Pour enseigner les différentes sections de cette leçon, il est préférable d'utiliser l'environnement de développement de Visual Studio .NET lors de vos explications. Pour cette section, ouvrez un nouveau projet basé sur le modèle d'application Windows, puis faites glisser un contrôle MainMenu sur le formulaire. Créez quelques éléments de menu, créez un sous-menu, puis ajoutez une fonctionnalité à l'événement Click d'un des éléments de votre menu. Exécutez l'application.

Présentez chacune des cinq modifications expliquées dans cette section (déplacement, suppression, modification, désactivation et masquage) en les appliquant successivement au menu créé à la section précédente. Faites remarquer qu'il est important pour le développeur à la fois de masquer et de désactiver un menu, car le masquage seul du menu n'empêche pas d'accéder à une commande de ce menu par le biais d'une touche de raccourci.

Cette section présente les quatre types d'amélioration que les stagiaires peuvent ajouter à un menu : coches, touches de raccourci, touches d'accès rapide et barres séparatrices. Présentez chacun de ces éléments sur le menu créé lors des sections précédentes et expliquez quand utiliser ces différentes améliorations.

Présentation multimédia : Création de menus

Terminologie des menus

Principes de création des menus

Création d'un menu

Modification des éléments de menu

Amélioration de votre menu

Module 9 : Amélioration de l'interface utilisateur v

Ce module ne comporte pas d'atelier. Assurez-vous que les stagiaires réalisent l'application pratique et qu'ils en comprennent la matière. Au cours des trois applications pratiques de ce module, les stagiaires ajouteront diverses améliorations à l'interface utilisateur d'une application simple de type visionneuse de texte. Dans cette application pratique, les stagiaires ajouteront un menu simple à l'application, ils affecteront des touches d'accès rapide aux éléments de menu et ils écriront du code qui s'exécutera lorsqu'un utilisateur cliquera sur un élément de menu. La durée de cette application pratique est de 15 minutes environ.

Leçon : Création de barres d'état Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Pour enseigner les différentes sections de cette leçon, il est préférable d'utiliser l'environnement de développement de Visual Studio .NET lors de vos explications. Pour cette section, montrez comment utiliser les barres d'état en ouvrant un projet existant dans Visual Basic .NET et en observant la barre d'état lors de l'ouverture du projet. Pour illustrer l'utilisation de panneaux multiples, ouvrez l'éditeur de code pour un projet existant.

Ensuite, ouvrez un nouveau projet basé sur le modèle d'application Windows, puis faites glisser un contrôle StatusBar sur le formulaire. Expliquez les propriétés SizingGrip et Text. Dans la section suivante, vous aborderez plus en détail la création d'une barre d'état à panneaux multiples et vous pouvez par conséquent expliquer les propriétés Panels et ShowPanels en guise de transition vers cette section.

Effectuez les étapes nécessaires à l'ajout d'un panneau à la barre d'état créée à la section précédente. Attirez l'attention des stagiaires sur la fenêtre Propriétés des panneaux, qui apparaît dans le volet de droite de l'Éditeur de collections StatusBarPanel. Montrez l'effet des modifications apportées aux propriétés AutoSize et BorderStyle.

Les stagiaires définiront du texte de panneau au moment de l'exécution à l'occasion de l'application pratique « Création d'une barre d'état ». Mettez l'accent sur le fait que l'index des panneaux commence à 0 et non à 1.

Ce module ne comporte pas d'atelier. Assurez-vous que les stagiaires réalisent l'application pratique et qu'ils en comprennent la matière. Dans cette application pratique, les stagiaires vont ajouter une barre d'état à une application simple de type visionneuse de texte. Ils définiront les propriétés de panneau au moment du design, et ils écriront également du code permettant de définir la propriété Text du panneau au moment de l'exécution. La durée de cette application pratique est de 20 minutes environ.

Application pratique : Création d'un menu

Création d'une barre d'état

Ajout de panneaux à une barre d'état

Définition du texte des panneaux au moment de l'exécution

Application pratique : Création d'une barre d'état

vi Module 9 : Amélioration de l'interface utilisateur

Leçon : Création de barres d'outils Cette section décrit les méthodes pédagogiques à mettre en �uvre pour chaque point de cette leçon.

Pour enseigner les différentes sections de cette leçon, il est préférable d'utiliser l'environnement de développement de Visual Studio .NET lors de vos explications. Pour cette section, ouvrez un nouveau projet basé sur le modèle d'application Windows, puis faites glisser un contrôle ToolBar sur le formulaire. Expliquez les différentes étapes de création d'une barre d'outils, sans toutefois en faire la démonstration, chacune de ces étapes étant abordée dans les sections suivantes.

Effectuez les étapes nécessaires à l'ajout de boutons à la barre d'outils créée à la section précédente. Montrez les options de la propriété Style, puis montrez comment créer un texte d'info-bulle. Montrez comment la propriété Appearance du contrôle ToolBar affecte les boutons de la barre d'outils.

Pour montrer comment ajouter des icônes au composant ImageList afin de pouvoir les utiliser dans les boutons de la barre d'outils, vous pouvez utiliser les icônes fournies dans le dossier dossier_installation\Practices\Mod09\Toolbar\ Starter. Attirez l'attention des stagiaires sur la propriété ImageIndex du contrôle ToolBarButton après l'affectation de l'icône.

Dans l'application pratique « Création d'une barre d'outils », les stagiaires écriront du code qui s'exécutera lorsqu'un utilisateur cliquera sur un bouton de barre d'outils. Expliquez et montrez comment fonctionne le code qui accomplit cette tâche, et mettez l'accent sur le fait que l'index des boutons de barre d'outils commence à 0 pour le premier bouton et non à 1.

Ce module ne comporte pas d'atelier. Assurez-vous que les stagiaires réalisent l'application pratique et qu'ils en comprennent la matière. Dans cette application pratique, les stagiaires vont ajouter une barre d'outils à une application simple de type visionneuse de texte. Ils définiront les propriétés de la barre d'outils au moment du design, ils ajouteront deux boutons à la barre d'outils, ils affecteront des icônes aux boutons de la barre d'outils et ils écriront du code qui s'exécutera en cas de clic sur chacun des boutons. La durée de cette application pratique est de 20 minutes environ.

Contrôle des acquis Les questions posées à ce stade portent essentiellement sur les concepts de base et les procédures présentées dans le module. Choisissez la forme de la discussion pour répondre aux questions et faire ainsi bénéficier l'ensemble des stagiaires de vos réponses.

1. Outre la révision des définitions des éléments tels que les touches d'accès rapide, les touches de raccourci et les info-bulles, examinez comment les stagiaires peuvent implémenter chacun de ces éléments dans une application.

2. Assurez-vous que les stagiaires comprennent bien la raison de leurs réponses incorrectes.

3. L'objectif de cet exercice est d'insister sur le fait que les images utilisées dans une barre d'outils sont stockées dans un contrôle séparé et qu'elles ne sont pas accessibles par le biais du contrôle ToolBar.

Création d'une barre d'outils

Ajout de boutons à une barre d'outils

Ajout d'icônes aux boutons d'une barre d'outils

Écriture de code pour l'événement ButtonClick

Application pratique : Création d'une barre d'outils

Module 9 : Amélioration de l'interface utilisateur vii

Présentations Vous pouvez montrer la présentation multimédia en exécutant le fichier multimédia fourni avec ce module ou bien effectuer la présentation vous-même en suivant ces instructions.


Présentation multimédia : Création de menus Dans cette démonstration, vous ajouterez un contrôle MainMenu à un Windows Form dans Visual Basic .NET. Vous créerez également une hiérarchie de menus et écrirez du code pour les événements Click des éléments du menu.

! Démarrez Visual Studio .NET et créez un nouveau projet 1. Cliquez sur Démarrer, pointez sur Tous les programmes, puis sur

Microsoft Visual Studio .NET et cliquez sur Microsoft Visual Studio .NET.

2. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 3. Dans la boîte de dialogue Nouveau projet, dans le volet Modèles, cliquez

sur Application Windows. 4. Dans la zone Nom, tapez ApplicationWithMenus 5. À côté de la zone Emplacement, cliquez sur Parcourir, déplacez-vous vers

dossier_installation\Democode\Mod09\Demo1, cliquez sur Ouvrir, puis cliquez sur OK.

! Ajoutez le contrôle MainMenu au formulaire 1. Pointez sur la Boîte à outils, puis cliquez sur l'onglet Windows Forms. 2. Faites glisser un contrôle MainMenu vers Form1 à partir de la boîte à

outils. 3. Notez la présence de la barre de menus contenant le texte « Tapez ici » en

haut du formulaire. Notez également la présence de MainMenu1 dans la zone des contrôles masqués.

4. Cliquez sur Tapez ici, puis tapez Fichier 5. Appuyez sur la touche BAS du clavier, puis tapez Nouveau 6. Appuyez sur la touche BAS du clavier, puis tapez Ouvrir 7. Appuyez sur la touche BAS du clavier, puis tapez Fermer 8. Appuyez sur la touche BAS du clavier, puis tapez Quitter 9. Cliquez sur Tapez ici à droite de Ficher dans le menu, puis tapez Edition 10. Appuyez sur la touche BAS du clavier, puis tapez Copier 11. Appuyez sur la touche BAS du clavier, puis tapez Coller 12. Appuyez sur la touche BAS du clavier, puis tapez Police 13. Cliquez sur Tapez ici à droite de Police, puis tapez Taille 14. Appuyez sur la touche BAS du clavier, puis tapez Style

viii Module 9 : Amélioration de l'interface utilisateur

! Formatez le menu 1. Cliquez sur Fichier dans la barre de menus, cliquez avec le bouton droit sur

Quitter, puis cliquez sur Insérer un séparateur. 2. Cliquez sur Ouvrir dans la barre de menus. 3. Dans la fenêtre Propriétés, changez la propriété Shortcut en CtrlO. 4. Cliquez sur Fermer dans la barre de menus. 5. Dans la fenêtre Propriétés, changez la propriété Shortcut en CtrlShiftC.

! Ajoutez du code à l'élément de menu 1. Cliquez sur Fichier, puis sur Nouveau.

Le nom actuel de cet élément de menu est MenuItem2. Vous pouvez utiliser la propriété Name dans la fenêtre Propriétés pour modifier ce nom en un nom plus explicite.

2. Dans la fenêtre Propriétés, changez la propriété Name en NewItem. 3. Double-cliquez sur Nouveau.

L'éditeur de code Form1.vb s'ouvre. 4. Tapez le code suivant entre Private Sub NewItem_Click et End Sub :

MessageBox.Show("Nouveau")

5. Cliquez sur l'onglet Form1.vb[Design]* dans l'environnement de développement.

6. Cliquez sur Ouvrir. 7. Dans la fenêtre Propriétés, changez la propriété Name en OpenItem. 8. Double-cliquez sur Ouvrir.

L'éditeur de code Form1.vb s'ouvre. 9. Tapez le code suivant entre Private Sub OpenItem_Click et End

Sub : MessageBox.Show("Ouvrir")

10. Cliquez sur l'onglet Form1.vb[Design]* dans l'environnement de

développement. 11. Cliquez sur Quitter. 12. Dans la fenêtre Propriétés, changez la propriété Name en ExitItem. 13. Double-cliquez sur Quitter.

L'éditeur de code Form1.vb s'ouvre. 14. Tapez le code suivant entre Private Sub ExitItem_Click et End

Sub : Application.Exit

Module 9 : Amélioration de l'interface utilisateur ix

! Testez l'application

1. Dans la barre d'outils standard, cliquez sur le bouton Démarrer. 2. Dans Form1, cliquez sur Edition.

Le menu contient trois commandes : Copier, Coller et Police. Notez que la commande Police indique la présence de sous-menus.

3. Cliquez sur Police. Le sous-menu de la commande Police contient les commandes Taille et Style.

4. Dans le menu Fichier, cliquez sur Nouveau. Un message affiche le mot « Nouveau ». Ce message est déclenché par le code attaché à l'événement Click de cette commande. Notez également que les éléments de menu relatifs à Ouvrir et Fermer possèdent des touches de raccourci définies et affichées dans le menu.

5. Cliquez sur Quitter. L'application se ferme. En effet, l'événement Click de la commande Quitter possède un appel vers la méthode Application.Exit.

Module 9 : Amélioration de l'interface utilisateur 1

Vue d'ensemble

! Création de menus

! Création de barres d'état

! Création de barres d'outils


Studio .NET

Accèsaux données Débogage

et déploiement

Écriturede code

Création d'uneinterface


Les menus, les barres d'état et les barres d'outils permettent d'offrir des fonctionnalités aux utilisateurs ou de leur donner des informations importantes dans votre application. Les menus contiennent des commandes, regroupées selon un thème commun. Les barres d'état indiquent l'état de l'application ou fournissent des informations à propos de l'entité de l'application qui a le focus, comme une commande de menu. Les barres d'outils utilisent des boutons destinés à faciliter l'accès aux commandes fréquemment utilisées.

Dans ce module, vous apprendrez à créer des menus, des barres d'état et des barres d'outils afin d'améliorer la convivialité de votre application.


! Créer des menus personnalisés afin de grouper les commandes de votre application.

! Créer une barre d'état en vue de fournir des commentaires aux utilisateurs de votre application.

! Créer une barre d'outils afin de fournir une interface graphique grâce à laquelle les utilisateurs pourront accéder aux fonctions principales de votre application.

Introduction

Objectifs

2 Module 9 : Amélioration de l'interface utilisateur

Leçon : Création de menus

! Terminologie des menus

! Principes de création des menus

! Création d'un menu

! Modification des éléments de menu

! Amélioration de votre menu


Si vous voulez que votre application fournisse diverses commandes aux utilisateurs, les menus constituent un moyen pratique et cohérent de regroupement des commandes, permettant un accès facile. En outre, vous pouvez utiliser les touches d'accès rapide et les touches de raccourci afin de rendre la navigation dans les menus plus aisée pour les utilisateurs expérimentés de votre application.

Cette leçon décrit comment créer des menus en vue de fournir un ensemble groupé de commandes aux utilisateurs.

Cette leçon inclut les rubriques et activités ci-dessous :

! Présentation multimédia : Création de menus ! Terminologie des menus ! Principes de création des menus ! Création d'un menu ! Modification des éléments de menu ! Amélioration de votre menu ! Application pratique : Création d'un menu


! Créer et modifier des menus, des sous-menus et des éléments de menu. ! Améliorer un menu à l'aide de coches, de barres séparatrices, de touches

d'accès rapide et de touches de raccourci.

Introduction




Présentation multimédia : Création de menus


Dans cette démonstration, vous apprendrez à ajouter un contrôle MainMenu à un formulaire Microsoft® Windows® dans Microsoft Visual Basic® .NET. Vous apprendrez également à créer une hiérarchie de menus et à écrire du code pour les événements Click des éléments du menu.


Terminologie des menus

Sous-menuSous-menu

Éléments de menu

Éléments de menu

En-tête de menuEn-tête de menu


Un système de menu se compose généralement de plusieurs éléments. Le tableau ci-dessous décrit les éléments de menu d'une interface utilisateur classique, telle que celles utilisées par les applications Windows.

Élément Description

En-tête de menu L'en-tête de menu est le premier élément de menu dans une liste d'éléments. Dans la plupart des applications Windows, Fichier, Edition et ? (Aide) sont des exemples d'en-têtes de menu.

Élément de menu Un élément de menu, également appelé commande, se réfère à un des choix répertoriés dans le menu principal. Chaque élément de menu est un membre de la classe MenuItem.

Sous-menu Un sous-menu, ou menu en cascade, est un menu contenant les subdivisions d'un élément de menu. L'élément de menu associé aumenu en cascade possède une flèche qui indique qu'un nouveau menu va apparaître si l'utilisateur place le pointeur de sa souris sur l'élément de menu.

Un menu contextuel est un menu qui apparaît généralement lorsque vous cliquez avec le bouton droit sur un objet dans une application. Pour plus d'informations sur les menus contextuels, consultez le cours 2565, « Developing Microsoft .NET Applications for Windows (Visual Basic .NET) » (en anglais).

Définitions

Remarque



PrincipePrincipePrincipe ExempleExExeemplemple

Utilisez une lettre majuscule commepremière lettre du nom des éléments de menu

Utilisez une lettre majuscule commepremière lettre du nom des éléments de menu Fichier, Edition, ? (Aide)Fichier, Edition, ? (Aide)

Affectez une touche d'accès rapide uniqueà chaque élément de menu

Affectez une touche d'accès rapide uniqueà chaque élément de menu Fichier, Edition, ? (Aide)Fichier, Edition, ? (Aide)

Utilisez des conventions d'appellation cohérentesUtilisez des conventions d'appellation cohérentes FileItem, EditItem, HelpItem

FileItem, EditItem, HelpItem

Placez des points de suspension (. . .) derrière lescommandes de menu qui requièrent plusd'informations de la part de l'utilisateur

Placez des points de suspension (. . .) derrière lescommandes de menu qui requièrent plusd'informations de la part de l'utilisateur

Enregistrer sous�Enregistrer sous�


L'objectif d'un menu est de rendre l'utilisation de votre application simple et intuitive. Les principes standard ci-dessous relatifs à la création des éléments de menu vous aideront à rendre votre menu plus intuitif et plus utile.

Le tableau suivant indique les principes de création des menus.

Principe Exemple

Utilisez une lettre majuscule comme première lettre du nom des éléments de menu.

Fichier, Edition, ? (Aide) (au lieu de fichier, édition, aide).

Affectez une touche d'accès rapide unique à chaque élément de menu.

« ? » est la touche d'accès rapide standard pour ? (Aide) dans les applications Windows.

Utilisez des conventions d'affectation de noms cohérentes lorsque vous créez votre menu.

Nommez les éléments Fichier, Edition et ? (Aide) d'un menu à l'aide des noms FileItem, EditItem et HelpItem dans votre programme.

Placez des points de suspension (. . .) derrière les commandes de menu qui requièrent plus d'informations de la part de l'utilisateur.

L'élément de menu Enregistrer sous dans Microsoft Word est suivi par des points de suspension afin d'indiquer que des informations supplémentaires sont requises. En l'occurrence, il s'agit du nom, de l'emplacement et du type du document que l'utilisateur veut enregistrer.

Introduction



Création d'un menu

Ajoutez un contrôle MainMenu au formulaire

Créez la structure du menu en ajoutant des éléments de menu

Ajoutez des fonctionnalités aux éléments de menu


Vous pouvez créer un menu dans un Windows Form en ajoutant un contrôle MainMenu au formulaire, au moment du design, à partir de la boîte à outils. Vous pouvez ensuite créer les éléments de menu et sous-menus de votre menu à l'aide du Concepteur de menus. Lorsque la structure de votre menu a été créée, vous pouvez ajouter des fonctionnalités aux éléments de menu.

! Pour ajouter un menu et des éléments de menu à un formulaire 1. Dans le Concepteur Windows Forms, ouvrez le formulaire auquel vous

souhaitez ajouter un menu. 2. Dans la boîte à outils, double-cliquez sur le contrôle MainMenu.

Un menu est ajouté au formulaire. Le menu affiche le texte « Tapez ici. » 3. Cliquez sur le texte Tapez ici, puis tapez le nom de l'élément de menu

souhaité afin de l'ajouter au menu. 4. Le nom que vous tapez apparaît en tant que propriété Text de l'élément de

menu.

Par défaut, le contrôle MainMenu ne contient pas d'éléments de menu, de telle sorte que le premier élément de menu ajouté au menu devient l'en-tête du menu.

5. Pour ajouter un autre élément de menu, cliquez sur une autre zone Tapez ici dans le Concepteur de menus. a. Cliquez sur la zone à droite de l'élément de menu actuel pour ajouter un

sous-menu. Vous ne pouvez pas ajouter un sous-menu à un en-tête de menu.

b. Cliquez sur la zone en dessous de l'élément de menu actuel pour ajouter un autre élément au même menu.

Introduction

Création du menu, des éléments de menu et des sous-menus

Remarque


L'ajout de code à l'événement Click de l'élément de menu permet d'ajouter des fonctionnalités aux éléments de menu. L'événement Click se produit lorsqu'un utilisateur clique sur l'élément de menu, lorsqu'un utilisateur sélectionne l'élément à l'aide du clavier et appuie sur ENTRÉE, ou lorsqu'un utilisateur clique sur une touche d'accès rapide ou une touche de raccourci associée à l'élément de menu.

! Pour ajouter une fonctionnalité à l'élément de menu 1. Dans le Concepteur de menus, cliquez sur l'élément de menu auquel vous

voulez ajouter une fonctionnalité. 2. Dans la fenêtre Propriétés, modifiez la propriété Name de l'élément.

Renommez l'élément. Utilisez la même convention d'affectation de noms pour tous les éléments du menu. (Par exemple, affectez l'élément de menu Open du nom OpenItem.)

3. Double-cliquez sur l'élément de menu pour ouvrir l'événement Click d'un gestionnaire d'événements.

4. Écrivez le code pour le gestionnaire d'événements.

Ajout de fonctionnalités aux éléments de menu


Modification des éléments de menu

Modificationsouhaitée

ModificationModificationsouhaitéesouhaitée ÉtapesÉtapesÉtapes

DéplacerDéplacer Dans le Concepteur de menus, cliquez sur l'élément de menu et déplacez-le vers son nouvel emplacement

Dans le Concepteur de menus, cliquez sur l'élément de menu et déplacez-le vers son nouvel emplacement

SupprimerSupprimer Cliquez avec le bouton droit sur l'élément de menu, puis cliquez sur Supprimer

Cliquez avec le bouton droit sur l'élément de menu, puis cliquez sur Supprimer

ModifierModifier Utilisez la fenêtre Propriétés pour modifier la propriété Text, et utilisez l'Éditeur de noms pour modifier la propriété Name

Utilisez la fenêtre Propriétés pour modifier la propriété Text, et utilisez l'Éditeur de noms pour modifier la propriété Name

DésactiverDésactiver Définissez la propriété Enabled de l'élément de menu à la valeur False

Définissez la propriété Enabled de l'élément de menu à la valeur False

MasquerMasquer Définissez la propriété Visible de l'élément de menu à la valeur False

Définissez la propriété Visible de l'élément de menu à la valeur False


Après avoir créé votre menu, vous pouvez aisément le modifier en déplaçant, en supprimant, en éditant, en désactivant ou en masquant des éléments.

! Pour déplacer un élément de menu • Dans le Concepteur de menus, cliquez sur l'élément de menu et déplacez-le

vers son nouvel emplacement. Vous pouvez placer l'élément au sommet du menu ou entre d'autres éléments de menu, ou l'ajouter en tant que nouveau sous-menu d'un élément existant.

! Pour supprimer un élément de menu • Dans le Concepteur de menus, cliquez avec le bouton droit sur l'élément de

menu, puis cliquez sur Supprimer.

La propriété Text de l'élément de menu définit le nom qui sera visible par les utilisateurs. Lorsque vous utilisez le Concepteur de menus, vous définissez la propriété Text pour chaque élément à l'occasion de la création des éléments de menu.

! Pour modifier la propriété Text d'un élément de menu • Dans le Concepteur de menus, cliquez sur l'élément de menu pour

sélectionner le nom, puis tapez le nouveau nom.

La propriété Name de chaque élément est définie dynamiquement par le Concepteur de menus. Le Concepteur de menus utilise le système d'affectation de noms MenuItemX, où X est un nombre représentant l'ordre dans lequel l'élément de menu a été créé. Le Concepteur de menus de Microsoft Visual Studio® contient un Éditeur de noms permettant de modifier la propriété Name des éléments de menu que vous créez.

Introduction

Déplacement d'éléments de menu

Suppression d'éléments de menu

Modification d'éléments de menu


! Pour modifier la propriété Name des éléments de menu à l'aide de l'Éditeur de noms

1. Cliquez avec le bouton droit n'importe où dans le Concepteur de menus, puis cliquez sur Modifier les noms. Le Concepteur de menus passe en mode d'édition de noms, et le nom d'un élément de menu apparaît à côté du texte spécifié dans la propriété Text.

2. Modifiez la propriété Name à la valeur souhaitée. 3. Pour quitter le mode d'édition de noms, cliquez avec le bouton droit

n'importe où dans le Concepteur de menus, puis cliquez à nouveau sur Modifier les noms.

Les éléments de menu sont activés par défaut lors de leur création. La désactivation des éléments de menu en réponse à l'activité de l'utilisateur est un moyen de limiter le nombre de commandes accessibles. Pour désactiver un élément de menu, utilisez la propriété Enabled de l'élément de menu.

! Pour désactiver un élément de menu 1. Dans le Concepteur de menus, cliquez sur l'élément de menu que vous

voulez désactiver. 2. Dans la fenêtre Propriétés, définissez la propriété Enabled à la valeur False.

Vous pouvez désactiver un élément de menu au moment de l'exécution à l'aide du code suivant, où MenuItem1 est le nom de l'élément de menu que vous voulez désactiver :

MenuItem1.Enabled = False

Le masquage des éléments de menu est un moyen permettant de contrôler l'interface utilisateur de votre application et de limiter les commandes accessibles. Souvent, vous voudrez masquer la totalité d'un menu lorsque tous les éléments de ce menu sont inaccessibles. Cela a l'avantage de limiter au maximum les distractions des utilisateurs.

Notez qu'il est important à la fois de masquer et de désactiver le menu, car le masquage seul du menu n'empêche pas d'accéder à une commande de ce menu par le biais d'une touche de raccourci.

! Pour masquer un élément de menu 1. Dans le Concepteur de menus, cliquez sur l'élément de menu que vous

voulez masquer. 2. Dans la fenêtre Propriétés, définissez la propriété Visible à la valeur False.

Lorsque l'élément de niveau supérieur d'un menu donné est masqué ou désactivé, tous les éléments de ce menu sont masqués.

Désactivation d'éléments de menu

Masquage d'éléments de menu

Remarque


Amélioration de votre menu

Touche d'accès rapideTouche d'accès rapide

Barre séparatrice

Barre séparatrice

Touche de raccourci

Touche de raccourci

CocheCoche


Vous pouvez ajouter quatre types d'amélioration à un menu afin de fournir plus d'informations aux utilisateurs :

! Les coches indiquent si une fonctionnalité est activée ou désactivée (par exemple si une règle est affichée le long de la marge d'une application de traitement de texte) ou indiquent lequel des fichiers d'une liste est affiché (comme dans un menu Fenêtre).

! Les touches de raccourci sont des commandes clavier utilisées pour accéder aux éléments de menu au sein d'une application.

! Les touches d'accès rapide permettent de naviguer dans les menus à l'aide du clavier. Pour activer le menu ou l'élément de menu souhaité, appuyez sur ALT et sur la touche d'accès rapide soulignée.

! Les barres séparatrices permettent de grouper les commandes apparentées d'un menu et de rendre celui-ci plus lisible.

! Pour ajouter une coche à un élément de menu • Dans le Concepteur de menus, cliquez sur l'élément de menu, puis cliquez

sur la zone à gauche de l'élément de menu. Une coche apparaît, indiquant que la propriété Checked a été définie sur True. � Ou �

1. Dans le Concepteur de menus, cliquez sur l'élément de menu. 2. Dans la fenêtre Propriétés, définissez la propriété Checked à la valeur True.

La propriété RadioCheck fonctionne conjointement avec la propriété Checked. Lorsque la propriété RadioCheck a la valeur True, un petit point (�) est affiché à côté d'un élément de menu coché au lieu d'une coche (").

Introduction

Ajout d'une coche

Remarque


! Pour affecter une touche de raccourci à un élément de menu 1. Dans le Concepteur de menus, cliquez sur l'élément de menu. 2. Dans la fenêtre Propriétés, définissez la propriété Shortcut à l'une des

valeurs figurant dans la liste déroulante.

! Pour affecter une touche d'accès rapide à un élément de menu • Lorsque vous définissez la propriété Text de l'élément de menu (dans la

fenêtre Propriétés, dans le Concepteur de menus ou à l'aide de code), tapez une esperluette (&) devant la lettre que vous voulez désigner comme touche d'accès rapide. Par exemple, si vous tapez &Fichier pour la propriété Text d'un élément de menu, celui-ci apparaîtra comme suit : « Fichier ». De même, F&ormat provoquera l'apparition de l'élément de menu « Format ».

Pour accéder à un élément de menu, appuyez sur ALT pour placer le focus sur la barre de menus et appuyez sur la touche d'accès rapide du nom du menu. Lorsque le menu s'ouvre et affiche ses éléments ainsi que les touches d'accès rapide, appuyez sur la touche d'accès rapide de l'élément de menu souhaité pour l'activer.

! Pour ajouter une barre séparatrice à un élément de menu • Dans le Concepteur de menus, cliquez avec le bouton droit à l'endroit où

vous voulez placer la barre séparatrice, puis cliquez sur Insérer un séparateur. � Ou �

• Lorsque vous définissez la propriété Text de l'élément de menu (dans la fenêtre Propriétés, dans le Concepteur de menus ou à l'aide de code), tapez un tiret (�) pour faire de cet élément de menu une barre séparatrice.

Affectation d'une touche de raccourci

Affectation d'une touche d'accès rapide

Remarque

Ajout d'une barre séparatrice


Application pratique : Création d'un menu

Dans cette application pratique, vous allezDans cette application pratique, vous allez ::## créer un créer un menu menu pour une pour une applicationapplication existanteexistante## affecter des touches d'accès rapide aux éléments de menuaffecter des touches d'accès rapide aux éléments de menu## ajouter des fonctionnalités aux éléments de menuajouter des fonctionnalités aux éléments de menu


Dans cette application pratique, vous allez ajouter un menu principal à une application simple de type visionneuse de texte, affecter des touches d'accès rapide aux éléments de menu et écrire du code qui s'exécutera lorsqu'un utilisateur cliquera sur un élément de menu.

! Ouvrez l'application Simple Viewer • Les fichiers de démarrage sont situés dans le dossier

dossier_installation\Practices\Mod09\Menu\Starter. Ouvrez la solution UserInterfaceApplication.sln.

! Ajoutez un menu principal 1. Examinez le formulaire, les contrôles et le code de l'application. 2. Ajoutez un menu principal au formulaire SimpleViewer. 3. Ajoutez les éléments de menu suivants au menu principal, changez la

propriété Name de chaque élément et affectez les touches d'accès rapide appropriées.

En-têtes de menu

Éléments sous les en-têtes

Noms des éléments de menu

Touches d'accès rapide suggérées

Fichier Ouvrir MenuFile, MenuItemOpen Alt F, O

Quitter MenuItemExit Q

Affichage Barre d'outils MenuView, MenuItemToolbar

Alt A, u

Barre d'état MenuItemStatusBar t

? (Aide) À propos de MenuHelp, MenuItemAbout

Alt ?, p


! Ajoutez des gestionnaires d'événements aux éléments de menu 1. Créez un gestionnaire d'événements Click pour l'élément de menu Ouvrir.

Appelez la procédure loadFile pour charger le fichier sélectionné dans le contrôle RichTextBox. La procédure loadFile est fournie dans le code de l'application.

2. Créez un gestionnaire d'événements Click pour l'élément de menu Quitter. Appelez Application.Exit pour quitter l'application.

3. Créez un gestionnaire d'événements Click pour l'élément de menu À propos de. Dans le gestionnaire d'événements, utilisez un message pour afficher du texte. Votre code doit ressembler à ce qui suit : MessageBox.Show("Simple Viewer version 1.0", _ "À propos de Simple Viewer", MessageBoxButtons.OK, _ MessageBoxIcon.Information)

! Compilez et testez l'application 1. Exécutez l'application. 2. Utilisez le menu Fichier pour ouvrir un fichier texte. Un fichier texte

exemple nommé Test.txt se trouve dans le dossier dossier_installation\ Practices\Mod09\Menu\Starter.

3. Vérifiez qu'un message apparaît lorsque vous cliquez sur À propos de dans le menu ? (Aide).

4. Testez l'une de vos touches d'accès rapide en appuyant sur ALT et sur la touche d'accès rapide.

5. Quittez l'application en cliquant sur Quitter.

Les fichiers solution sont situés dans le dossier dossier_installation\Practices\ Mod09\Menu\Solution.

Code de solution


Leçon : Création de barres d'état

! Création d'une barre d'état

! Ajout de panneaux à une barre d'état

! Définition du texte des panneaux au moment de l'exécution

Barre d'étatBarre d'état

Panneaux debarre d'état

Panneaux debarre d'état


Il est possible d'ajouter un contrôle StatusBar à un formulaire et de le personnaliser de telle sorte qu'il fournisse des informations utiles, comme le nom d'un fichier ouvert, la date ou l'heure courante, ou le statut de certaines touches du clavier. Dans cette leçon, vous apprendrez à améliorer l'interface d'une application en utilisant le contrôle StatusBar.


! Création d'une barre d'état ! Ajout de panneaux à une barre d'état ! Définition du texte des panneaux au moment de l'exécution ! Application pratique : Création d'une barre d'état

À la fin de cette leçon, vous serez à même de créer une barre d'état dans un formulaire afin de fournir des commentaires aux utilisateurs.

Introduction


Objectif de la leçon


Création d'une barre d'état

ProcédureProcProcééduredure

Ouvrez le formulaire auquel vous souhaitezajouter la barre d'étatOuvrez le formulaire auquel vous souhaitezajouter la barre d'état

À partir de la boîte à outils, ajoutez uncontrôle StatusBar au formulaireÀ partir de la boîte à outils, ajoutez uncontrôle StatusBar au formulaire

Définissez les propriétés StatusBarDéfinissez les propriétés StatusBar

Ajoutez le nombre souhaité de panneauxà la barre d'étatAjoutez le nombre souhaité de panneauxà la barre d'état


Le contrôle StatusBar de Windows Forms est utilisé dans les formulaires en guise de zone, généralement représentée dans le bas d'une fenêtre, pouvant afficher différents types d'informations d'état.

! Pour ajouter une barre d'état à votre application 1. Ouvrez le formulaire auquel vous souhaitez ajouter la barre d'état. 2. À partir de la boîte à outils, ajoutez un contrôle StatusBar au formulaire. 3. Définissez les propriétés StatusBar adéquates, notamment ShowPanels.

a. Si vous ne voulez pas ajouter de panneaux à la barre d'état, attribuez la valeur False (valeur par défaut) à la propriété ShowPanels, puis attribuez le texte que vous souhaitez voir apparaître dans la barre d'état à la propriété Text.

b. Pour afficher plusieurs types d'informations dans la barre d'état, attribuez la valeur True à la propriété ShowPanels, puis ajoutez le nombre souhaité de panneaux à la barre d'état.

Introduction

Ajout d'une barre d'état


Le tableau ci-dessous présente les propriétés StatusBar que vous utiliserez fréquemment.


Panels Par défaut, une barre d'état ne possède pas de panneaux. Utilisez la propriété Panels pour ajouter des panneaux à la barre d'état ou en supprimer.

ShowPanels Si la valeur de cette propriété est False (valeur par défaut), seule la valeur de la propriété Text du contrôle s'affiche. Si la valeur de cette propriété est True, vous pouvez afficher des panneaux dans votre barre d'état.

SizingGrip Affiche une poignée de dimensionnement dans le coin inférieur droit du formulaire afin d'indiquer aux utilisateurs qu'ils peuvent redimensionner le formulaire. Utilisez cette propriété uniquement dans un formulaire qui peut être redimensionné.

Text Contient la chaîne de texte affichée dans la barre d'état.

Propriétés StatusBar




Ouvrez la fenêtre Propriétés pour le contrôleStatusBarOuvrez la fenêtre Propriétés pour le contrôleStatusBar

Définissez la propriété ShowPanels à lavaleur TrueDéfinissez la propriété ShowPanels à lavaleur True

Dans la propriété Panels, ouvrezl'Éditeur de collections StatusBarPanelDans la propriété Panels, ouvrezl'Éditeur de collections StatusBarPanel

Utilisez les boutons Ajouter et Supprimer pour ajouterà et supprimer des boutons du contrôle StatusBarUtilisez les boutons Ajouter et Supprimer pour ajouterà et supprimer des boutons du contrôle StatusBar

Définissez les propriétés des panneauxDéfinissez les propriétés des panneaux


La zone programmable d'un contrôle StatusBar consiste en instances de la classe StatusBarPanel. Pour afficher plusieurs types d'informations dans la barre d'état, attribuez la valeur True à la propriété ShowPanels, puis ajoutez le nombre souhaité de panneaux à la barre d'état.

Vous pouvez utiliser des panneaux de barre d'état pour afficher du texte ou des icônes d'information d'état, ou pour afficher une série d'icônes dans une animation indiquant qu'un processus fonctionne. Par exemple, un panneau de barre d'état dans Word affiche une petite icône indiquant l'enregistrement d'un document.

! Pour ajouter des panneaux à une barre d'état au moment du design 1. Dans la fenêtre Propriétés de la barre d'état, définissez la propriété

ShowPanels à la valeur True. 2. Cliquez sur la propriété Panels pour la sélectionner, puis cliquez sur les

points de suspension (bouton ) pour ouvrir l'Éditeur de collections StatusBarPanel.

3. Utilisez les boutons Ajouter et Supprimer pour ajouter à et supprimer des boutons du contrôle StatusBar.

4. Définissez les propriétés des panneaux individuels dans la fenêtre Propriétés qui apparaît dans le volet de droite de l'éditeur.

5. Cliquez sur OK pour fermer la boîte de dialogue et créer les panneaux définis.

Introduction



Le tableau ci-dessous présente les propriétés de panneau StatusBar que vous utiliserez fréquemment.


AutoSize Définit le comportement de redimensionnement du panneau. Les options suivantes sont disponibles :

• Contents : La largeur du panneau est déterminée par son contenu.

• None : La taille du panneau ne change pas lors du redimensionnement du contrôle de la barre d'état.

• Spring : Le panneau partage l'espace disponible sur la barre d'état avec les autres panneaux dont la propriété AutoSize possède la valeur Spring.

Alignment Définit l'alignement du panneau dans le contrôle StatusBar. Les options disponibles sont : Center, Left et Right.

BorderStyle Définit le type de bordure affiché sur les bords du panneau. Les options suivantes sont disponibles :

• None : Aucune bordure n'est affichée.

• Raised : Le panneau est affiché avec une bordure en relief à trois dimensions.

• Sunken : Le panneau est affiché avec une bordure enfoncée à trois dimensions.

Icon Définit l'icône (fichier .ico) affichée dans le panneau.

MinWidth Définit la largeur minimale du panneau lors de son affichage dans la barre d'état.

Style Définit le style du panneau. Les options suivantes sont disponibles :

• OwnerDraw : Prend en charge l'affichage des images ou l'utilisation d'une police différente de celle qui est utilisée par les autres objets de panneau dans une barre d'état.

• Text : Le panneau affiche le texte dans la police standard.

Text Définit la chaîne de texte affichée dans le panneau.

Width Définit la largeur du panneau, mesurée en pixels. Il se peut que cette propriété soit modifiée lors du redimensionnement du formulaire, selon la valeur de la propriété AutoSize.

Propriétés des panneaux


Définition du texte des panneaux au moment de l'exécution

! Référez-vous au panneau de la propriété que vous voulez définir à l'aide de l'index du panneau

StatusBar1.Panels(0).Text = Now( )

StatusBar1.Panels(1).Text = "Prêt"



StatusBar1.Panels(0).Alignment = _ HorizontalAlignment.Center

StatusBar1.Panels(0).Alignment = _ HorizontalAlignment.Center


La barre d'état étant fréquemment utilisée pour afficher l'état actuel d'un aspect donné de l'application, vous préférerez souvent définir le texte du panneau au moment de l'exécution plutôt que lors du design.

Pour définir le texte du panneau au moment de l'exécution, vous devez vous référer au panneau de la propriété que vous voulez définir. Pour cela, vous pouvez utiliser l'index du panneau. Les numéros d'index commencent à 0.

Par exemple, le code suivant définit la propriété Text du premier panneau à la date et l'heure en cours :


Pour définir la propriété Text du deuxième panneau à la chaîne « Prêt », utilisez le code suivant :


Le code ci-dessous définit la propriété Alignment du premier panneau de telle sorte que le panneau est centré sur la barre d'état :

StatusBar1.Panels(0).Alignment = HorizontalAlignment.Center

Introduction

Définition du texte du panneau au moment de l'exécution


Application pratique : Création d'une barre d'état

Dans cette application pratique, vous allez :# créer une barre d'état# définir le texte des panneaux de la barre d'état au

moment de l'exécution# ajouter des fonctionnalités à l'élément de menu de la

barre d'état


Dans cette application pratique, vous allez ajouter une barre d'état à une application simple de type visionneuse de texte. Vous définirez les propriétés de panneau au moment du design, et vous écrirez également du code permettant de définir la propriété Text du panneau au moment de l'exécution. Pour terminer, vous écrirez du code permettant de répondre à l'événement Click de l'élément de menu Barre d'état. Les fichiers de démarrage sont situés dans le dossier dossier_installation\Practices\Mod09\StatusBar\Starter.

! Ajoutez une barre d'état 1. Ouvrez UserInterfaceApplication.sln. Si vous n'avez pas réalisé l'application

pratique « Création d'un menu », familiarisez-vous avec le formulaire et le code de l'application.

2. Ajoutez un contrôle StatusBar au formulaire. 3. Définissez la propriété Text de la barre d'état à la valeur vide. 4. Utilisez la propriété Panels pour ajouter un panneau à la barre d'état. 5. Définissez la propriété AutoSize du panneau à la valeur Spring. 6. Définissez la propriété Text du panneau à la valeur vide, puis cliquez sur

OK pour fermer l'Éditeur de collections StatusBarPanel. 7. Définissez la propriété ShowPanels de la barre d'état à la valeur True.

! Modifiez le gestionnaire d'événements MenuItemOpen_Click 1. Ouvrez le gestionnaire d'événements MenuItemOpen_Click. 2. Après l'appel à la procédure loadFile, ajoutez le code suivant pour afficher

le chemin d'accès du fichier dans la barre d'état : openFileDialogBox.FileName. Votre code doit ressembler à ce qui suit : StatusBar1.Panels(0).Text = openFileDialogBox.FileName


! Définissez une propriété d'élément de menu • Cliquez sur l'élément de menu Barre d'état, puis définissez sa propriété

Checked a la valeur True.

! Ajoutez un gestionnaire d'événements 1. Ajoutez un gestionnaire d'événements Click pour l'élément de menu

StatusBar1. 2. Écrivez du code permettant d'afficher ou de masquer la barre d'état, selon

que l'élément de menu StatusBar1 est coché ou non. Pour cela, complétez le corps du gestionnaire d'événements en écrivant du code qui effectue les actions suivantes : a. Si la propriété Checked de l'élément de menu StatusBar1 a la valeur

True, masquer la barre d'état et définir la propriété Checked à la valeur False.

b. Si la propriété Checked de l'élément de menu StatusBar1 a la valeur False, afficher la barre d'état et définir la propriété Checked à la valeur True.

Votre code doit ressembler à ce qui suit : If MenuItemStatusBar.Checked Then StatusBar1.Hide( ) MenuItemStatusBar.Checked = False Else StatusBar1.Show( ) MenuItemStatusBar.Checked = True End If

! Testez l'application 1. Exécutez l'application et ouvrez un fichier texte. Un fichier texte exemple

nommé Test.txt se trouve dans le dossier dossier_installation\Practices\ Mod09\StatusBar\Starter.

2. Utilisez l'élément de menu Barre d'état pour afficher et masquer la barre d'état.


Les fichiers solution sont situés dans le dossier dossier_installation\Practices\ Mod09\StatusBar\Solution.

Code de solution


Leçon : Création de barres d'outils

! Création d'une barre d'outils

! Ajout de boutons à une barre d'outils

! Ajout d'icônes aux boutons d'une barre d'outils

! Écriture de code pour l'événement ButtonClick


La barre d'outils est une fonctionnalité standard présente dans de nombreuses applications Windows. Les barres d'outils affichent une rangée de boutons et de menus déroulants qui activent des commandes. En général, les boutons et les menus déroulants correspondent à des éléments de la structure de menu d'une application, offrant une interface graphique grâce à laquelle les utilisateurs peuvent rapidement accéder aux fonctions et commandes les plus fréquemment utilisées de l'application.


! Création d'une barre d'outils ! Ajout de boutons à une barre d'outils ! Ajout d'icônes aux boutons d'une barre d'outils ! Écriture de code pour l'événement ButtonClick ! Application pratique : Création d'une barre d'outils


! Créer une barre d'outils à l'aide du contrôle ToolBar. ! Ajouter des boutons à une barre d'outils. ! Affecter une icône à un bouton de barre d'outils. ! Ajouter du code déclenché par l'événement ButtonClick aux boutons d'une

barre d'outils.

Introduction






Ajoutez un contrôle ToolBar au formulaireà partir de la boîte à outilsAjoutez un contrôle ToolBar au formulaireà partir de la boîte à outils

Définissez les propriétés ToolBarDéfinissez les propriétés ToolBar

Ajoutez des boutons à la barre d'outilsAjoutez des boutons à la barre d'outils

Définissez les propriétés ToolBarButtonDéfinissez les propriétés ToolBarButton

Si vous le souhaitez, affectez des images à chacundes boutons de la barre d'outilsSi vous le souhaitez, affectez des images à chacundes boutons de la barre d'outils

Écrivez le code pour les boutons de la barre d'outilsÉcrivez le code pour les boutons de la barre d'outils


Le contrôle ToolBar de Windows Forms est utilisé dans les formulaires pour créer une barre d'outils pour une application.

! Pour créer une barre d'outils pour votre application 1. Ouvrez le formulaire auquel vous souhaitez ajouter la barre d'outils. 2. Ajoutez un contrôle ToolBar au formulaire à partir de la boîte à outils. 3. Définissez les propriétés ToolBar adéquates. 4. Ajoutez des boutons à la barre d'outils, puis définissez les propriétés

ToolBarButton adéquates. 5. Si vous le souhaitez, affectez des images à chacun des boutons de la barre

d'outils. 6. Écrivez le code pour les boutons de la barre d'outils.

Introduction



Le tableau ci-dessous présente les propriétés ToolBar que vous utiliserez fréquemment.


Appearance Affecte l'apparence des boutons affectés à la barre d'outils. Les options suivantes sont disponibles :

• Normal : Donne aux boutons de barre d'outils une apparence en relief à trois dimensions.

• Flat : Donne aux boutons de barre d'outils une apparence à deux dimensions. Lorsque le pointeur de la souris se place au-dessus de boutons à deux dimensions, ceux-ci apparaissent en relief et à trois dimensions.

Buttons Contient tous les contrôles ToolBarButton affectés à la barre d'outils. La propriété Buttons est une collection indexée à partir de zéro. Utilisez cette propriété pour ajouter des boutons à la barre d'outils ou en supprimer.

ButtonSize Définit la taille des contrôles ToolBarButton sur la barre d'outils. Si la propriété ButtonSize n'est pas définie par le développeur, elle sera soit définie à une taille par défaut soit suffisamment grande pour inclure l'image et le texte, selon la plus élevée de ces deux valeurs.

ImageList Si vous créez une instance de la classe ImageList et que vous l'affectez à la propriété ImageList, vous pourrez affecter une image de la liste aux contrôles ToolBarButton.

ShowToolTips Détermine si des info-bulles seront visibles aux utilisateurs. Les info-bulles fournissent de l'aide aux utilisateurs lorsque ceux-ci placent le pointeur de leur souris au-dessus d'un contrôle ToolBarButton. La valeur par défaut est True.

Propriétés ToolBar




Ouvrez la fenêtre Propriétés du contrôle ToolBarOuvrez la fenêtre Propriétés du contrôle ToolBar

Dans la propriété Buttons, ouvrezl'Éditeur de collections ToolBarButtonDans la propriété Buttons, ouvrezl'Éditeur de collections ToolBarButton

Utilisez les boutons Ajouter et Supprimer pour ajouterdes boutons de barre d'outils et en supprimerUtilisez les boutons Ajouter et Supprimer pour ajouterdes boutons de barre d'outils et en supprimer

Dans l'Éditeur de collections ToolBarButton,définissez les propriétés des boutonsDans l'Éditeur de collections ToolBarButton,définissez les propriétés des boutons


Les boutons que vous ajoutez au contrôle ToolBar font partie intégrante de celui-ci. Vous pouvez utiliser ces boutons pour accéder aux commandes de menu, ou les placer dans un autre endroit de l'interface utilisateur de votre application pour accéder aux commandes non disponibles dans la structure de menu.

! Pour ajouter des boutons à une barre d'outils 1. Ouvrez la fenêtre Propriétés du contrôle ToolBar. 2. Cliquez sur la propriété Buttons pour la sélectionner, puis cliquez sur les

points de suspension (bouton ) pour ouvrir l'Éditeur de collections ToolBarButton.

3. Utilisez les boutons Ajouter et Supprimer pour ajouter des boutons au contrôle ToolBar et supprimer des boutons de ce contrôle.

4. Définissez les propriétés des boutons individuels dans la fenêtre Propriétés qui apparaît dans le volet de droite de l'éditeur.

5. Cliquez sur OK pour fermer la boîte de dialogue et créer les boutons définis.

Introduction



Le tableau ci-dessous présente les propriétés de bouton de barre d'outils que vous utiliserez fréquemment.


DropDownMenu Définit le menu qui apparaît dans le bouton de barre d'outils déroulante. La propriété Style du bouton de barre d'outils doit être définie à la valeur DropDownButton.

Pushed Définit si un bouton de barre d'outils de type bascule est affiché dans l'état enfoncé. La propriété Style du bouton de barre d'outils doit être définie à la valeur ToggleButton ou PushButton.

Style Définit le style du bouton de barre d'outils. Les options suivantes sont disponibles :

• DropDownButton : Contrôle déroulant qui affiche un menu ou une autre fenêtre lorsque l'utilisateur clique dessus.

• PushButton : Bouton standard à trois dimensions.

• Separator : Espace ou ligne entre les boutons de barre d'outils.

• ToggleButton : Bouton bascule qui apparaît enfoncé lorsque l'utilisateur clique dessus et qui reste tel quel jusqu'à ce que l'utilisateur clique à nouveau sur le bouton.

Text Définit la chaîne de texte affichée par le bouton.

ToolTipText Définit le texte qui apparaît sous la forme d'une info-bulle pour le bouton. Les info-bulles fournissent de l'aide aux utilisateurs lorsque ceux-ci placent le pointeur de leur souris au-dessus d'un bouton de barre d'outils.

Propriétés des boutons


Ajout d'icônes aux boutons d'une barre d'outils


Ajoutez un composant ImageList au formulaireà partir de la boîte à outilsAjoutez un composant ImageList au formulaireà partir de la boîte à outils

Ajoutez des images au composant ImageListAjoutez des images au composant ImageList

Définissez la propriété ImageList du contrôle ToolBarDéfinissez la propriété ImageList du contrôle ToolBar

Ajoutez des boutons au contrôle ToolBarAjoutez des boutons au contrôle ToolBar

Dans l'Éditeur de collections ToolBarButton,définissez la propriété ImageIndex de chaque boutonDans l'Éditeur de collections ToolBarButton,définissez la propriété ImageIndex de chaque bouton


Les barres d'outils possèdent généralement des boutons qui utilisent des icônes pour représenter les fonctions de l'application. Les icônes sont aisément identifiables par les utilisateurs. Par exemple, une icône représentant une disquette est généralement utilisée pour représenter une fonction d'enregistrement de fichier. Vous devez affecter à chaque bouton soit du texte soit une image, ou les deux.

Pour afficher des images sur votre barre d'outils, commencez par ajouter les images au composant ImageList, puis associez le composant ImageList au contrôle ToolBar.

! Pour définir une icône pour un bouton de barre d'outils au moment du design

1. Ajoutez un composant ImageList au formulaire à partir de la boîte à outils. 2. Dans la fenêtre Propriétés du composant ImageList, cliquez sur la propriété

Images pour la sélectionner, puis cliquez sur les points de suspension (bouton ) pour ouvrir l'Éditeur de collections d'images.

3. Utilisez le bouton Ajouter pour ajouter des images au composant ImageList, puis cliquez sur OK pour fermer l'Éditeur de collections d'images.

4. Dans la fenêtre Propriétés du contrôle ToolBar, définissez la propriété ImageList à la valeur du composant ImageList ajouté précédemment.

5. Cliquez sur la propriété Buttons du contrôle ToolBar pour la sélectionner, puis cliquez sur les points de suspension (bouton ) pour ouvrir l'Éditeur de collections ToolBarButton.

Introduction


6. Utilisez le bouton Ajouter pour ajouter des boutons au contrôle ToolBar. 7. Dans la fenêtre Propriétés qui apparaît dans le volet de droite de l'Éditeur de

collections ToolBarButton, définissez la propriété ImageIndex de chaque bouton de barre d'outils à l'une des valeurs de la liste, à partir des images que vous avez ajoutées au composant ImageList. Cliquez sur OK pour fermer l'Éditeur de collections ToolBarButton.


Écriture de code pour l'événement ButtonClick

! Tous les boutons d'une barre d'outils partagent un seul événement Click

! Utilisez une commande Select Case ainsi que la classe ToolBarButtonClickEventArgs afin d'identifier le bouton sur lequel l'utilisateur a cliqué

Protected Sub ToolBar1_ButtonClick(ByVal sender _ As Object,ByVal e As ToolBarButtonClickEventArgs)

Select Case ToolBar1.Buttons.IndexOf(e.Button)

Case 0

MessageBox.Show("L'utilisateur a cliqué sur le premier bouton de la barre d'outils")

Case 1

MessageBox.Show("L'utilisateur a cliqué sur le deuxième bouton de la barre d'outils")

End SelectEnd Sub

Protected Sub ToolBar1_ButtonClick(ByVal sender _ As Object,ByVal e As ToolBarButtonClickEventArgs)

Select Case ToolBar1.Buttons.IndexOf(e.Button)

Case 0MessageBox.Show("L'utilisateur a cliqué sur le premier bouton de la barre d'outils")

Case 1MessageBox.Show("L'utilisateur a cliqué sur le deuxième bouton de la barre d'outils")

End SelectEnd Sub


Tous les boutons d'une barre d'outils partagent un seul événement Click. Pour ajouter une fonctionnalité à votre barre d'outils, vous devez écrire du code afin de déterminer sur quel bouton l'utilisateur a cliqué.

Pour écrire du code destiné à déterminer sur quel bouton l'utilisateur a cliqué, ajoutez un gestionnaire d'événements à l'événement ButtonClick du contrôle ToolBar. Utilisez une commande Select Case ainsi que la classe ToolBarButtonClickEventArgs afin d'identifier le numéro d'index du bouton sur lequel l'utilisateur a cliqué. Pour chaque cas, écrivez le code à exécuter pour le bouton correspondant.

Introduction

Détermination du bouton sur lequel l'utilisateur a cliqué


Dans l'exemple suivant, une commande Select Case est utilisée pour déterminer sur lequel des trois boutons l'utilisateur a cliqué, tandis qu'un message confirme le résultat. Dans une application réelle, le code exécutable pour le bouton doit être écrit à la place du code qui appelle la fonction MessageBox dans cet exemple.

Protected Sub ToolBar1_ButtonClick(ByVal sender As Object, _ ByVal e As ToolBarButtonClickEventArgs) Handles _ ToolBar1.ButtonClick ' Utilisez la propriété Button de la classe ' ToolBarButtonClickEventArgs pour déterminer sur quel bouton ' l'utilisateur a cliqué Select Case ToolBar1.Buttons.IndexOf(e.Button) Case 0 MessageBox.Show("L'utilisateur a cliqué sur le premier bouton de la barre d'outils") Case 1 MessageBox.Show("L'utilisateur a cliqué sur le deuxième bouton de la barre d'outils") Case 2 MessageBox.Show("L'utilisateur a cliqué sur le troisième bouton de la barre d'outils") End Select End Sub

Exemple


Application pratique : Création d'une barre d'outils

Dans cette application pratique, vous allez :Dans cette application pratique, vous allez :## créer une barre d'outilscréer une barre d'outils## affecter des icônes affecter des icônes aux boutons de la barre d'outilsaux boutons de la barre d'outils## ajouter des fonctionnalités aux boutons ajouter des fonctionnalités aux boutons de la barre d'outilsde la barre d'outils## ajouter des fonctionnalités à un élément de menu de la ajouter des fonctionnalités à un élément de menu de la

barre d'outilsbarre d'outils


Dans cette application pratique, vous allez ajouter une barre d'outils à une application simple de type visionneuse de texte. Vous définirez les propriétés de la barre d'outils au moment du design, vous ajouterez deux boutons à la barre d'outils, vous affecterez des icônes aux boutons de la barre d'outils et vous écrirez du code qui s'exécutera en cas de clic sur chacun des boutons. Les fichiers de démarrage sont situés dans le dossier dossier_installation\Practices\Mod09\Toolbar\Starter.

! Ajoutez une barre d'outils 1. Ouvrez UserInterfaceApplication.sln. Si vous n'avez pas réalisé l'application

pratique « Création d'une barre d'état », familiarisez-vous avec le formulaire et le code de l'application.

2. Ajoutez un contrôle ImageList au formulaire. 3. Ajoutez deux images à l'aide de la propriété Images. Les images

OpenFold.ico et Font02.ico sont situées dans le dossier dossier_installation\Practices\Mod09\Toolbar\Starter. Assurez-vous que OpenFold.ico possède le numéro d'index 0 et que Font02.ico possède le numéro d'index 1.

4. Ajoutez un contrôle ToolBar au formulaire. 5. Définissez la propriété ImageList de la barre d'outils afin d'utiliser le

contrôle ImageList ajouté précédemment. 6. Ajoutez un bouton à la barre d'outils à l'aide de la propriété Buttons.

Définissez la propriété ImageIndex du bouton à la valeur 0. 7. Ajoutez un autre bouton et définissez la propriété ImageIndex du bouton à

la valeur 1. 8. Cliquez sur OK dans l'Éditeur de collections ToolBarButton.


! Définissez une propriété d'élément de menu • Dans le menu Affichage de l'application Simple Viewer, cliquez sur

l'élément de menu Barre d'outils et attribuez la valeur True à la propriété Checked.

! Ajoutez un gestionnaire d'événements pour l'élément de menu Barre d'outils

1. Ajoutez un gestionnaire d'événements Click pour l'élément de menu Barre d'outils.

2. Complétez le corps du gestionnaire d'événements en écrivant du code qui effectue les actions suivantes : a. Si la propriété Checked de l'élément de menu Barre d'outils a la valeur

False, afficher la barre d'outils et définir la propriété Checked à la valeur True.

b. Si la propriété Checked de l'élément de menu Barre d'outils a la valeur True, masquer la barre d'outils et définir la propriété Checked à la valeur False.

Votre code doit ressembler à ce qui suit : If Not MenuItemToolbar.Checked Then ToolBar1.Show( ) MenuItemToolbar.Checked = True Else ToolBar1.Hide( ) MenuItemToolbar.Checked = False End If


! Ajoutez un gestionnaire d'événements pour la barre d'outils 1. Ajoutez un gestionnaire d'événements Click pour la barre d'outils. 2. Complétez le corps du gestionnaire d'événements.

a. Utilisez une instruction Select Case pour déterminer sur quel bouton l'utilisateur a cliqué.

b. Pour le bouton associé à l'icône OpenFold, appelez le gestionnaire d'événements Click existant de l'élément de menu Ouvrir et transmettez sender et e en guise de paramètres.

c. Pour le bouton associé à l'icône Font02, définissez la propriété Font du contrôle RichTextBox en créant une nouvelle police.

Votre code doit ressembler à ce qui suit. (Dans ce code, 0 est le numéro d'index du bouton Ouvrir et 1 est le numéro d'index du bouton Police.) Select Case ToolBar1.Buttons.IndexOf(e.Button) Case 0 MenuItemOpen_Click(sender, e) Case 1 RichTextBox1.Font = New System.Drawing.Font _ ("Comic Sans MS", 12.0!, _ System.Drawing.FontStyle.Regular, _ System.Drawing.GraphicsUnit.Point, CType(0, Byte)) End Select

! Testez l'application 1. Exécutez l'application. 2. Cliquez sur le bouton Ouvrir et ouvrez un fichier texte. Un fichier texte

exemple nommé Test.txt se trouve dans le dossier dossier_installation\ Practices\Mod09\Toolbar\Starter.

3. Cliquez sur le bouton Police et vérifiez que la police du fichier texte change. 4. Quittez l'application.

Les fichiers solution sont situés dans le dossier dossier_installation\Practices\ Mod09\Toolbar\Solution.

Code de solution



! Création de menus

! Création de barres d'état

! Création de barres d'outils


Studio .NET

Accèsaux données Débogage

et déploiement

Écriturede code

Création d'uneinterface


1. Expliquez la finalité des éléments suivants : a. Touches d'accès rapide b. Touches de raccourci c. Info-bulles a. Les touches d'accès rapide permettent de naviguer dans les menus à

l'aide du clavier. Pour activer le menu ou l'élément de menu souhaité, appuyez sur ALT et sur la touche d'accès rapide soulignée.

b. Les touches de raccourci sont des commandes clavier utilisées pour accéder aux éléments de menu au sein d'une application.

c. Les info-bulles fournissent de l'aide à l'utilisateur lorsque celui-ci place le pointeur de sa souris au-dessus d'un contrôle.

2. Déterminez lequel des exemples de code ci-dessous modifie le contenu du premier panneau d'une barre d'état nommée StatusBar1 et affiche le message « Appuyez sur F1 pour obtenir de l'aide ».

a. "Appuyez sur F1 pour obtenir de l'aide." = StatusBar1.Panels(1).Text

b. StatusBar1.Panels(1).Text = "Appuyez sur F1 pour obtenir de l'aide."

c. StatusBar1.Panel1.Text = "Appuyez sur F1 pour obtenir de l'aide."

d. StatusBar1.Panels(0).Text = "Appuyez sur F1 pour obtenir de l'aide."

d. StatusBar1.Panels(0).Text = "Appuyez sur F1 pour obtenir de l'aide." L'index des panneaux commençant à 0, le premier panneau de StatusBar1 est indiqué par StatusBar1.Panels(0).


3. Quelle(s) proposition(s) ci-dessous complète(nt) correctement la phrase suivante ? Les images pour les boutons d'une barre d'outils sont : a. affectées d'un numéro d'index dans l'Éditeur de collections d'images. b. automatiquement attachées au bouton de la barre d'outils relatif à la

fonction. c. maintenues dans l'Éditeur de collections d'images ToolBarButton. d. maintenues dans un contrôle ImageList séparé. Les propositions a et d complètent correctement la phrase.

This page is blank

Table des matières

Vue d'ensemble 1

Leçon : Utilisation des formulaires Web 2

Leçon : Utilisation des services Web XML 18


Atelier 10.1 : Création d'une application Web 31

Module 10 : Formulaires Web et services Web XML


Module 10 : Formulaires Web et services Web XML iii

Notes de l'instructeur Ce module explique comment utiliser les formulaires Web pour créer une application Web et invoquer un service Web XML simple à partir d'une application Web.


! créer, générer et exécuter une application qui utilise les formulaires Web ; ! expliquer le processus de recherche et d'appel des services Web XML ; ! utiliser un proxy pour appeler un service Web XML à partir d'un formulaire

Web.


• Fichier Microsoft PowerPoint® 2560A_10.ppt


! lire tous les documents de cours relatifs à ce module ; ! réaliser les applications pratiques et l'atelier ; ! réaliser les étapes des deux démonstrations dirigées.

Présentation et application pratique : 105 minutes Atelier : 30 minutes

Documents de cours

Préparation

iv Module 10 : Formulaires Web et services Web XML


Leçon : Utilisation des formulaires Web Cette section présente les méthodes pédagogiques d'enseignement de chaque section de cette leçon.

Expliquez que Microsoft ASP.NET est composé de formulaires Web et de services Web XML. Si les stagiaires ne sont pas familiarisés avec la terminologie client/serveur, expliquez que les applications serveur permettent à un ordinateur de fournir des services aux applications installées sur d'autres ordinateurs et ce, à la demande de l'utilisateur. Expliquez également que l'application qui demande un service est une application cliente.

Si les stagiaires sont familiarisés avec Active Server Pages (ASP), expliquez que, même si la syntaxe d'ASP.NET est en général compatible avec la syntaxe ASP, ASP.NET fournit un nouveau modèle de programmation et une nouvelle infrastructure qui permet de créer une nouvelle catégorie d'applications. Insistez sur le fait que ASP.NET fait partie de Microsoft .NET Framework, ce qui permet aux développeurs d'exploiter pleinement les fonctionnalités du Common Language Runtime, notamment la sécurité des types, l�héritage, l'interopérabilité des langages et la gestion des versions.

Dans cette démonstration, vous utiliserez un formulaire Web pour créer une application Web simple qui prend deux nombres en tant qu'entrées de l'utilisateur, les additionne et affiche le résultat. Au cours de cette démonstration, insistez sur les similitudes au niveau de l'utilisation des formulaires Web et des formulaires Microsoft Windows® dans l'environnement de développement.

Les étapes concernant l'exécution de cette démonstration sont décrites dans la section Démonstrations des notes de l'instructeur.

La meilleure manière d'animer cette section consiste à expliquer la création d'un nouveau projet d'application Web ASP.NET dans l'environnement de développement Microsoft Visual Studio® .NET. Analysez les fichiers créés par Visual Studio .NET et montrez aux stagiaires qu'ils peuvent tous les visualiser en cliquant sur Afficher tous les fichiers dans la barre d'outils de l'Explorateur de solutions. Faites remarquer aux stagiaires le fichier aspx.vb qui apparaît dans la structure des fichiers lorsque vous cliquez sur Afficher tous les fichiers.

Cette rubrique explique comment les formulaires Web divisent les composants visuels et la logique d'une application entre un fichier .aspx et un fichier code-behind aspx.vb. Expliquez comment ouvrir le fichier aspx.vb. Montrez les vues Création et HTML du fichier .aspx, et assurez-vous que les stagiaires qui n'ont aucune expérience du Web comprennent que le langage HTML (Hypertext Markup Language) est le langage de balisage utilisé pour créer des documents sur le Web. Montrez comment passer du mode présentation de la grille au mode mise en page fluide lorsque le mode Design est activé. Montrez également comment entrer du texte directement dans la page et le mettre en page à l'aide de la barre d'outils Mise en forme, en mode mise en page fluide.

Présentation des formulaires Web

Démonstration dirigée : Utilisation des formulaires Web

Création d'un projet d'application Web

Composants d'un formulaire Web

Module 10 : Formulaires Web et services Web XML v

Montrez comment ajouter des contrôles à partir des onglets Formulaires Web et HTML dans la boîte à outils. Expliquez également comment convertir les contrôles HTML pour les exécuter côté serveur. Activez le mode HTML du fichier .aspx pour montrer l'attribut runat = "server" qui indique au serveur que cet élément est un contrôle serveur.

Cette section explique comment créer un gestionnaire d'événements pour un formulaire Web. Expliquez aux stagiaires qu'ils peuvent ajouter des événements aux contrôles individuels, à une page, à une application ou à une session.

La meilleure manière d'animer cette section consiste à montrer les étapes qui permettent de générer et d'exécuter une page Formulaires Web dans l'environnement de développement.

Au cours de cette application pratique, les stagiaires créeront un nouveau projet d'application Web, ajouteront des contrôles serveur Web au formulaire Web et ajouteront un gestionnaire d'événements. Puis ils compileront et exécuteront l'application à l'aide de la commande Générer et parcourir. Cette application pratique est conçue pour durer approximativement 10 minutes.

Leçon : Utilisation des services Web XML Cette section présente les méthodes pédagogiques d'enseignement de chaque section de cette leçon.

Faites remarquer aux stagiaires que les services Web XML permettent aux applications clientes d'accéder à la logique de gestion à l'aide des protocoles Internet. Décrivez certains des avantages qu'offrent les services Web XML au fournisseur et au consommateur de services Web XML. Le site Web GotDotNet (http://www.gotdotnet.com) vous renvoie vers plusieurs sites Web qui fournissent des exemples de services Web XML.

L'objectif de cette section est d'initier les stagiaires aux protocoles SOAP, WSDL (Web Services Description Language) et UDDI (Universal Discovery Description and Integration). La démonstration fournie à la suite de cette section vous permet d'expliquer plus en détail WSDL et UDDI.

Dans cette démonstration, vous montrerez comment visualiser le document WSDL pour un service Web XML. Vous appellerez un service Web XML à partir d'une application simple et utiliserez les méthodes du service Web XML pour calculer un amortissement.

Les étapes concernant l'exécution de cette démonstration sont décrites dans la section Démonstrations des notes de l'instructeur.

Cette section explique que, pour utiliser un service Web XML, les stagiaires doivent découvrir les services proposés par une société ou un fournisseur particulier. En utilisant la diapositive, revoyez les étapes de la démonstration dirigée précédente. Vous pouvez également décrire les risques d'utilisation d'un service Web XML dans une application lorsque le fournisseur de service n'est pas connu.

Utilisez le projet que vous avez créé pour la démonstration dirigée précédente pour montrer que, lorsqu'une référence Web est ajoutée au projet, les fichiers correspondants sont affichés dans un sous-dossier du dossier Références Web de l'Explorateur de solutions.

Ajout de contrôles


Génération et exécution d'une page de formulaires Web

Application pratique : Création d'une page de formulaires Web

Qu'est-ce qu'un service Web XML ?

Fonctionnement des services Web XML

Démonstration dirigée : Utilisation des services Web XML

Découverte et utilisation des services Web XML

Appel d'un service Web XML à l'aide d'un proxy

vi Module 10 : Formulaires Web et services Web XML

Contrôle des acquis Les questions du contrôle des acquis reposent essentiellement sur la compréhension des concepts et sur les procédures, présentées de manière exhaustive dans le module. Vous pouvez diriger une discussion pour répondre aux questions afin que chaque stagiaire puisse connaître les réponses correctes.

1. Si les stagiaires ont des difficultés à répondre à cette question, revoyez la section Composants d'un formulaire Web.

2. Si les stagiaires ont des difficultés à répondre à cette question, revoyez la section Création d'un projet d'application Web.

3. Si les stagiaires ont des difficultés à répondre à cette question, revoyez la section Ajout de contrôles.

4. Si les stagiaires ont des difficultés à répondre à cette question, revoyez la section Création d'un projet d'application Web.

5. Si les stagiaires ont des difficultés à répondre à cette question, revoyez la section Fonctionnement des services Web XML.

6. Si les stagiaires ont des difficultés à répondre à cette question, revoyez la section Appel d'un service Web XML à l'aide d'un proxy.

Atelier 10.1 : Création d'une application Web Avant de commencer l'atelier, les stagiaires doivent terminer toutes les applications pratiques et répondre à toutes les questions du contrôle des acquis. Ils devront pouvoir effectuer la plupart des tâches qu'ils ont apprises dans les leçons et l'application pratique. Cet atelier guide les stagiaires tout au long du processus de création de l'interface utilisateur et d'appel d'un service Web XML, tel que décrit dans les deux leçons de ce module.

Démonstrations Cette section présente pas à pas les instructions détaillées pour les démonstrations, y compris les étapes d'exécution des démonstrations multimédias sous la forme de démonstrations dirigées.

Pour pouvoir afficher la page dans la fenêtre d'un navigateur, n'oubliez pas de compiler votre projet d'application Web après toute modification du code. Vous pouvez compiler et exécuter la page .aspx rapidement en cliquant sur la commande Générer et parcourir du menu contextuel.

Module 10 : Formulaires Web et services Web XML vii

Démonstration dirigée : Utilisation des formulaires Web Dans cette démonstration, vous utiliserez un formulaire Web pour créer une application Web simple qui prend deux nombres en tant qu'entrées de l'utilisateur, les additionne et affiche le résultat.

! Ouverture d'un nouveau projet d'application Web ASP.NET • Créez un nouveau projet Application Web ASP.NET et enregistrez-le à

l'emplacement suivant : http://localhost/WebForm

! Ajout de contrôles au formulaire Web 1. Ajoutez deux zones de texte, trois étiquettes et un bouton au formulaire

Web. Votre formulaire Web doit ressembler à la capture d'écran suivante :

2. Définissez les propriétés des contrôles répertoriés dans le tableau suivant.


Textbox1 Text Vide

Textbox2 Text Vide

Label1 Text +

Font.Bold True

Font.Size Large

Label2 Text =

Font.Bold True

Font.Size Large

Label3 Text Vide

Font.Bold True

Font.Size Large

Button1 Text Ajouter

! Ajout de code à l'événement Button1_Click 1. Créez un gestionnaire d'événements pour l'événement Button1_Click. 2. Ajoutez le code suivant au gestionnaire d'événements :

Label3.Text = Cint(Textbox1.Text) + Cint(Textbox2.Text)

viii Module 10 : Formulaires Web et services Web XML

! Compilation et exécution du projet 1. Générez le projet. 2. Exécutez le projet dans un navigateur. 3. Tapez 30 dans TextBox1, puis 40 dans Textbox2. 4. Cliquez sur le bouton Ajouter.

Vérifiez que Label3 affiche la valeur 70. 5. Quittez Visual Studio .NET.

Les fichiers de solution de cette démonstration se trouvent dans le dossier dossier_installation\Democode\Mod10\WebForm\Solution.

Démonstration dirigée : Utilisation des services Web XML Dans cette démonstration, vous montrerez comment visualiser le document WSDL pour un service Web XML. Vous appellerez un service Web XML et utiliserez ses méthodes pour calculer un amortissement.

! Affichage du document WSDL pour un service Web XML 1. Démarrez Microsoft Internet Explorer. 2. Consultez le service Web XML de calcul en tapant http://localhost/2560/

Labfiles/Lab101/Ex02/Webservice/CalculationService.asmx dans la barre Adresse. Lorsque la page Web s'ouvre, expliquez aux stagiaires qu'ils visualisent une vue conviviale du document de découverte. Cette vue facilite et simplifie la mise en �uvre des méthodes et informations sur les espaces de noms. Sur ce site, vous pouvez tester les méthodes de services Web XML sans créer un proxy. Remarquez l'instruction sur le site Web qui explique que tempuri.org est un espace de noms par défaut.

3. Cliquez sur le lien TotalPaid. Tapez 250000 dans la zone loanAmount, tapez 7,0 dans la zone rate, tapez 30 dans la zone loanLength, puis cliquez sur Appeler. Le résultat de cette procédure apparaît dans une seconde fenêtre du navigateur et ressemble aux informations suivantes :

<?xml version="1.0" encoding="utf-8" ?> <double xmlns="http://tempuri.org/">598772.2456612641</double>

Faites remarquer aux stagiaires que l'URL de cette page inclut les paramètres qui ont été transmis à la méthode TotalPaid. Expliquez que l'espace de noms temporaire http://tempuri.org est utilisé à des fins de développement.

4. Fermez la page Web qui affiche les résultats de l'opération. 5. Dans Internet Explorer, cliquez sur le bouton Précédent pour revenir aux

informations de découverte du service de Calcul. 6. Cliquez sur le lien MonthlyPayment. Tapez 250000 dans la zone

loanAmount, tapez 7,0 dans la zone rate, tapez 30 dans la zone loanLength, puis cliquez sur Appeler.

7. Visualisez la page Web qui affiche les résultats de cette procédure, puis fermez la page de résultats.


Module 10 : Formulaires Web et services Web XML ix

8. Dans Internet Explorer, cliquez sur le bouton Précédent pour revenir aux informations de découverte du service de Calcul.

9. Interrogez de nouveau le service Calcul en tapant ?WSDL à la fin de l'URL suivante dans la barre Adresse : http://localhost/2560/Labfiles/Lab101/ Ex02/Webservice/CalculationService.asmx Expliquez que l'ajout du paramètre ?WSDL à l'URL du service Web XML vous permet d'accéder au code XML qui constitue votre document de découverte.

10. Fermez le document WSDL.

! Ajout d'une référence Web à un nouveau projet d'application Web ASP.NET.

1. Créez un nouveau projet Application Web ASP.NET et enregistrez-le à l'emplacement suivant : http://localhost/UseCalcService

2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis cliquez sur Ajouter une référence Web pour ouvrir la boîte de dialogue correspondante. Expliquez que les répertoires UDDI facilitent la recherche de services Web XML au fur et à mesure que le nombre d'entreprises qui créent des services Web XML augmente.

3. Tapez http://localhost/2560/labfiles/lab101/ex02/Webservice/ CalculationService.asmx dans la barre Adresse, puis cliquez sur le bouton Atteindre.

4. Cliquez sur le bouton Ajouter la référence situé au bas de la boîte de dialogue Ajouter une référence Web.

5. Dans le menu Affichage, cliquez sur Affichage de classes. 6. Dans l'affichage de classes, développez le projet UseCalcService, puis les

espaces de noms UseCalcService et localhost, ainsi que la classe CalculationService.

7. Insistez sur les méthodes du service Calcul, maintenez le pointeur de la souris sur les méthodes TotalPaid et MonthlyPayment pour afficher les définitions des méthodes à l'aide de Microsoft IntelliSense®.

! Ajout de contrôles au formulaire Web 1. Cliquez sur l'onglet WebForm1.aspx pour ouvrir WebForm1.aspx en mode

Design. 2. Ajoutez une étiquette et un bouton au formulaire Web. 3. Définissez les propriétés des contrôles répertoriés dans le tableau suivant.


Label1 Text vide

Font.Bold True

Font.Size Large

Button1 ID CalculatePaymentButton

Text Calculate Payment

x Module 10 : Formulaires Web et services Web XML

! Appel de la méthode MonthlyPayment à l'aide d'un proxy 1. Créez un gestionnaire d'événements pour l'événement

CalculatePaymentButton_Click. 2. Déclarez et instanciez une variable localhost.CalculationService appelée

payment. Votre code doit se présenter comme suit : Dim payment As New localhost.CalculationService( )

3. Utilisez le code suivant pour appeler la méthode MonthlyPayment de

payment, transmettre des paramètres littéraux et attribuer la valeur de retour à la propriété Label1.Text : Label1.Text = FormatCurrency _ (Payment.MonthlyPayment(CDbl(250000), _ CDbl(7.0), CDbl(30)))

! Compilation et exécution du projet 1. Appuyez sur CTRL+F8 pour exécuter la commande Générer et parcourir. 2. Cliquez sur Calculer le paiement.

L'étiquette affiche 1.663,26 �. 3. Fermez le navigateur.

Les fichiers de solution de cette démonstration se trouvent dans le dossier dossier_installation\Democode\Mod10\UseCalcService\Solution.


Module 10 : Formulaires Web et services Web XML 1

Vue d'ensemble

! Utilisation des formulaires Web

! Utilisation des services Web XML

Accèsaux données


Studio .NET


Écriturede code

Créationd'une

interface


Microsoft® Visual Studio® .NET vous permet de créer des applications qui tirent parti du World Wide Web, notamment les sites Web traditionnels qui utilisent des pages HTML (Hypertext Markup Language), les applications commerciales dotées de toutes les fonctionnalités d'un intranet ou d'Internet, et les applications inter-entreprises sophistiquées qui fournissent des composants basés sur le Web capables d'échanger des données à l'aide de XML.

Les formulaires Web permettent de créer des applications dans lesquelles l'interface utilisateur principale est un navigateur. Il s'agit des applications destinées à être publiées par l'intermédiaire du World Wide Web, notamment les applications e-commerce.

Les services Web XML fournissent la logique d'application programmable qui peut être appelée à l'aide de protocoles Internet standard. Les services Web XML allient les meilleures fonctionnalités du Web et celles du développement basé sur les composants.

Ce module explique comment créer une application qui utilise un formulaire Web et appeler un service Web XML simple.


! créer, générer et exécuter une application qui utilise les formulaires Web ; ! expliquer le processus de recherche et d'appel des services Web XML ; ! utiliser un proxy pour appeler un service Web XML à partir d'un formulaire

Web.

Introduction

Objectifs

2 Module 10 : Formulaires Web et services Web XML

Leçon : Utilisation des formulaires Web

! Présentation des formulaires Web

! Création d'un projet d'application Web

! Composants d'un formulaire Web

! Ajout de contrôles

! Ajout d'un gestionnaire d'événements

! Génération et exécution d'une page de formulaires Web


Cette leçon explique comment créer un formulaire Web, ajouter des contrôles, gérer des événements, générer et exécuter une page de formulaires Web.

Cette leçon contient les activités et les sujets suivants :

! Présentation des formulaires Web ! Démonstration : Utilisation des formulaires Web ! Création d'un projet d'application Web ! Composants d'un formulaire Web ! Ajout de contrôles ! Ajout d'un gestionnaire d'événements ! Génération et exécution d'une page de formulaires Web ! Application pratique : Création d'une page de formulaires Web


! définir les composants d'un formulaire Web ; ! créer un nouveau projet d'application Web ; ! ajouter des contrôles serveur Web aux formulaires Web ; ! programmer des événements pour gérer les interactions avec l'utilisateur ; ! générer et exécuter une page de formulaire Web.

Introduction




Présentation des formulaires Web

InternetInternet

Serveur WebServeur WebOrdinateur clientOrdinateur client

Formulaire WebFormulaire Web

Pages Web programmables reposant sur la technologieASP.NET

Fichier.aspx

.aspx.vb

www.name.com

! Le code HTML est envoyé vers le navigateur de l'ordinateur ou dupériphérique client

! Le code et les contrôles qui exécutent l'interface utilisateur restentsur le serveur Web


Les formulaires Microsoft Windows® vous permettent de créer des applications Windows, et les formulaires Web vous permettent de générer des applications Web. Les formulaires Web sont des pages Web programmables qui servent d'interface utilisateur (UI) pour un projet d'application Web Microsoft ASP.NET. Les formulaires Web sont composés d'éléments HTML, de code et de contrôles exécutés sur un serveur Web équipé de IIS (Internet Information Services). Un formulaire Web présente les informations à l'utilisateur dans n'importe quel type de navigateur. Il met en oeuvre la logique de l'application en utilisant le code côté serveur.

Les formulaires Web affichent une interface utilisateur en générant du code HTML qui est transmis au navigateur, tandis que le code et les contrôles associés qui exécutent l'interface utilisateur (UI) restent sur le serveur Web. L'une des différences essentielles entre un formulaire Web et une page Web traditionnelle est la séparation de l'interface côté client et du code côté serveur. Dans une page Web traditionnelle, tout le code doit être envoyé au navigateur et traité par celui-ci. Dans un formulaire Web, seuls les contrôles de l'interface doivent être transmis au navigateur. Le traitement de la page est maintenu sur le serveur. La séparation de l'interface utilisateur et du code augmente la plage de navigateurs pris en charge par un jeu de code unique. Cette approche améliore également la sécurité et la fonctionnalité de la page Web.

Les formulaires Web sont souvent évoqués en tant que pages ASP.NET ou ASPX. Ces formulaires portent l'extension .aspx et font office de conteneurs à l'usage du texte et des contrôles que vous souhaitez afficher dans le navigateur.

Les formulaires Web sont souvent composés de deux fichiers distincts : le fichier .aspx contient l'interface utilisateur du formulaire Web, tandis que le fichier .aspx.vb, appelé code-behind (page de code sous-jacent), contient le code de prise en charge Microsoft Visual Basic® .NET.

Introduction

Fonctionnement des formulaires Web

Fichiers .aspx


Les formulaires Web offrent les fonctionnalités suivantes :

! Exécution sur n'importe quel navigateur Les formulaires Web retournent automatiquement le code HTML correct, conforme au navigateur pour les fonctionnalités telles que les styles et la présentation.

! Programmation dans tout type de langage Les formulaires Web sont programmables dans tout type de langage pris en charge par le Common Language Runtime, y compris Visual Basic, C# et Microsoft JScript® .NET.

! Gestion d'état La gestion d'état fait référence aux informations qu'une application doit conserver sur une page Web. Les formulaires Web fournissent un ensemble de fonctionnalités de gestion d'état qui préservent automatiquement l'état d'affichage d'une page entre les requêtes.

! Prise en charge WYSIWYG et RAD Les formulaires Web prennent en charge les outils d'édition WYSIWYG (what you see is what you get) et les outils de développement d'application (RAD) rapides et puissants, tel que Visual Studio .NET, pour la conception et la programmation de vos formulaires.

! Contrôles Les formulaires Web fournissent un ensemble de contrôles étendu qui vous permettent d'encapsuler la logique des pages dans des composants réutilisables et de gérer les événements de page de manière déclarative.

Fonctionnalités


Démonstration : Utilisation des formulaires Web

! Dans cette démonstration, vousapprendrez à utiliser un formulaire Web pour créer une application Web simple


Dans cette démonstration, vous apprendrez à créer une application Web simple en ajoutant des contrôles à un formulaire Web et en écrivant le code qui répond aux événements.


Création d'un projet d'application Web

! Utilisez le modèle d'application Web ASP.NET

Fichiers dansl'Explorateurde solutions

Propriétés

Contrôles

FormulaireWeb


Pour créer une page de formulaire Web, la première étape consiste à créer un projet d'application Web ASP.NET.

! Création du projet d'application Web ASP.NET 1. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 2. Dans la boîte de dialogue Nouveau projet, effectuez les opérations

suivantes : a. Dans le volet Types de projets, cliquez sur Projets Visual Basic. b. Dans le volet Modèles, cliquez sur Application Web ASP.NET. c. Dans la zone Emplacement, entrez l'URL (Uniform Resource Locator)

complète de votre application (http://, nom du serveur et nom du projet). Le nom du serveur par défaut est http://localhost ce qui suppose que votre ordinateur local est le serveur Web.

d. Cliquez sur OK. Lorsque vous cliquez sur OK, un nouveau projet est créé à la racine du serveur Web que vous avez spécifié. En outre, une nouvelle page de formulaire Web appelée WebForm1.aspx s'affiche en mode Design dans le Concepteur de formulaires Web.

Introduction

Création du projet


Le tableau suivant décrit certains des fichiers qui sont créés sur votre ordinateur local lorsque vous concevez un projet d'application Web ASP.NET.

Fichier créé Description

WebForm1.aspx et WebForm1.aspx.vb

Ces deux fichiers composent une seule page de formulaire Web.

Le fichier .aspx contient les éléments visuels (interface utilisateur) de la page de formulaire Web, par exemple les éléments HTML et les contrôles de formulaires Web.

Le fichier de classe aspx.vb contient le code de la page de formulaire Web, y compris le code du gestionnaire d'événements.

AssemblyInfo.vb Fichier d'informations sur le projet (AssemblyInfo.vb ou AssemblyInfo.cs) qui contient les métadonnées relatives aux assemblys d'un projet, notamment son nom, sa version et sa culture.

Web.config Fichier XML qui contient les données de configuration de chaque ressource URL unique utilisée dans le projet.

Global.asax et Global.asax.vb

Le fichier optionnel Global.asax permet de gérer les événements au niveau de l'application. Il réside dans le répertoire racine d'une application ASP.NET. Le fichier de classe Global.asax.vb est masqué et dépend de Global.asax. Il contient le code de gestion des événements de l'application, notamment l'événement Application_OnError. Ce fichier est analysé et compilé au moment de l'exécution.

Styles.css Fichier permettant l'utilisation d'une feuille de style en cascade dans le projet.

.vsdisco (découverte d'un projet)

Fichier XML contenant les liens (URL) d'accès aux ressources qui fournissent les informations de découverte d'un service Web XML.

! Affichage de tous les fichiers dans un projet • Cliquez sur le bouton Afficher tous les fichiers dans la barre d'outils de

l'Explorateur de solutions.

Fichiers de projet créés

Affichage des fichiers


Composants d'un formulaire Web

Logique de l'application(Fichier code-behind

(page de code sous-jacent))

Logique de l'application(Fichier code-behind

(page de code sous-jacent))

Mode CréationMode

CréationModeHTML ModeHTML

Composants visuelsComposants visuels


Les formulaires Web divisent l'interface utilisateur d'une application Web en deux parties : les composants visuels et la logique d'application. Lorsque vous travaillez avec les composants visuels de la page, vous pouvez utiliser le mode Design ou le mode HTML.

Une page de formulaire Web est composée de deux fichiers :

! Fichier .aspx ou page Ce fichier contient du texte HTML statique et les contrôles serveur qui constituent les composants visuels de la page.

! Fichier .aspx.vb ou fichier code-behind Lorsque Visual Studio .NET crée un formulaire Web, tel que WebForm1.aspx, il crée également le fichier de code sous-jacent WebForm1.aspx.vb. Ce fichier contient la logique de l'application, c'est-à-dire le code que vous créez pour interagir avec le formulaire. Lorsque vous exécutez le formulaire, le fichier de classe code-behind est exécuté et génère dynamiquement la sortie de votre page.

Vous pouvez travailler avec le fichier .aspx dans deux modes différents, le mode Design ou le mode HTML. Lorsque vous changez de mode, les modifications que vous avez effectuées dans un mode sont répercutées dans l'autre.

Introduction

Modèle de code d'un formulaire Web

Modes de visualisation du fichier .aspx


Le mode Design affiche le fichier .aspx sur lequel vous travaillez dans une vue WYSIWYG. En mode Design, vous pouvez faire glisser les contrôles de la boîte à outils et les configurer à l'aide de la fenêtre Propriétés pour avoir une représentation approximative de leur apparence lorsqu'ils s'afficheront à l'utilisateur par l'intermédiaire d'un navigateur Web.

En mode Design, vous pouvez disposer les éléments de l'interface utilisateur dans deux modes que vous sélectionnez à l'aide de la propriété pageLayout de la page.

! Présentation de la grille : Vous pouvez disposer les objets sur la page selon une position absolue (coordonnées x et y). Il s'agit du mode par défaut.

! Mise en page fluide : Vous pouvez disposer les éléments du haut vers le bas, de la même manière que dans un document de traitement de texte. Comme dans un document de traitement de texte, vous pouvez également ajouter le texte que vous souhaitez afficher directement dans le formulaire Web et le mettre en forme à l'aide de la barre d'outils Mise en forme.

L'onglet Design (Création) se trouve au bas du Concepteur de formulaires Web.

Mode Design


Le mode HTML affiche au format HTML le fichier .aspx sur lequel vous travaillez. Ce mode vous permet d'afficher et de modifier le code HTML des éléments de votre formulaire Web. Comme dans les autres modes d'édition du code, le Concepteur de formulaires Web prend en charge Microsoft IntelliSense® pour les éléments en mode HTML.

L'onglet HTML se trouve au bas du Concepteur de formulaires Web.

Pour afficher le document HTML actuel dans le navigateur Web interne et intégré, cliquez sur l'option Afficher dans le navigateur du menu Fichier, ou cliquez avec le bouton droit sur le fichier .aspx en mode Design ou HTML, puis cliquez sur Afficher dans le navigateur.

Mode HTML

Remarque


Ajout de contrôles

Contrôles serveur : composants exécutés sur le serveur

! Contrôles serveur Web :

" Conçus spécifiquement pour ASP.NET

" Disponibles sous l'onglet Formulaires Web de la boîte àoutils

! Contrôles serveur HTML :

" Contrôles clients HTML que vous convertissez pour les exécuter en tant que contrôles serveur

" Disponibles sous l'onglet HTML de la boîte à outils


Après avoir créé un formulaire Web, vous pouvez y ajouter des contrôles pour élaborer l'interface utilisateur. Les contrôles serveur ASP.NET sont des composants exécutés sur le serveur qui incluent l'interface utilisateur et d'autres fonctionnalités associées. Lorsque vous créez une page ASP.NET, vous avez la possibilité d'utiliser des contrôles serveur Web ou HTML. Vous pouvez utiliser ces types de contrôle sur la même page afin de mettre à jour rapidement une page HTML. Toutefois, vous obtiendrez de meilleurs résultats sans les contrôles serveur HTML. En effet, les contrôles serveur Web utilisent un modèle d'objet plus complet que les contrôles serveur HTML.

Les contrôles serveur Web sont conçus spécifiquement pour ASP.NET. Les contrôles ASP.NET sont appelés « contrôles serveur » parce qu'ils sont instanciés dans le code du serveur comme faisant partie de la classe Page lorsque la page est exécutée. Lorsqu'un utilisateur interagit avec un contrôle, le code correspondant est exécuté sur le serveur lorsque la page est publiée. Par exemple, lorsqu'un utilisateur clique sur un contrôle Button dans ASP.NET, le code associé à ce bouton est exécuté sur le serveur lorsque la page est publiée.

! Ajout de contrôles serveur Web à un formulaire Web 1. Ouvrez le fichier .aspx en mode Design. 2. Si la boîte à outils n'est pas ouverte, cliquez sur Boîte à outils dans le menu

Affichage. 3. Sous l'onglet Web Forms de la boîte à outils, cliquez sur le contrôle que

vous souhaitez ajouter au formulaire et faites-le glisser vers la position souhaitée dans le formulaire.

Introduction

Contrôles serveur Web


Les contrôles serveur HTML représentent des éléments HTML modifiés qui sont exécutés sur le serveur et non pas dans le navigateur du client. Par défaut, les éléments HTML d'un formulaire Web sont exécutés sur l'ordinateur client. Vous pouvez toutefois ajouter l'attribut runat="server" pour convertir les éléments HTML en contrôles serveur HTML.

! Ajout d'un contrôle HTML dans un formulaire Web et conversion en un contrôle serveur

1. Ouvrez le fichier .aspx en mode Design. 2. Si la boîte à outils n'est pas ouverte, cliquez sur Boîte à outils dans le menu

Affichage. 3. Sous l'onglet HTML de la boîte à outils, faites glisser un élément HTML

sur la page. 4. Cliquez avec le bouton droit sur l'élément, puis cliquez sur Exécuter en

tant que contrôle serveur. Le Concepteur de formulaires Web ajoute l'attribut runat="server" à l'élément pour prévenir le serveur qu'il doit traiter les éléments sous la forme d'un contrôle serveur. En mode Design, une icône apparaît sur le contrôle pour signaler qu'il s'agit d'un contrôle serveur.

Contrôles serveur HTML



! De nombreux événements sont déclenchés par uneaction de l'utilisateur dans le navigateur

! Le code de gestion de l'événement généré est exécuté sur le serveur

! Lorsque l'exécution de votre code est terminée, la page est renvoyée au navigateur et inclut toutes les modifications effectuées par le code du gestionnaire d'événements

Public Sub Button1_Click(...)

End Sub

Public Sub Button1_Click(...)

End Sub


Les formulaires Web fournissent aux applications Web le modèle d'écriture du code dans les gestionnaires d'événements qui se produisent côté client ou côté serveur. Les formulaires Web rendent ce modèle abstrait afin que le mécanisme sous-jacent de capture d'un événement sur le client, sa transmission au serveur et l'appel du gestionnaire approprié soient automatiques et invisibles. Ceci produit une structure de code claire dont l'écriture est facile.

L'un des principaux objectifs de la création de formulaires Web ASP.NET concerne l'interaction avec les utilisateurs. Pour gérer ces interactions, vous programmez différents événements. La page Web et les nombreux événements déclenchés par différents objets (dont ses contrôles serveur) peuvent exécuter du code.

Vous pouvez créer des gestionnaires d'événements pour gérer les événements associés à des contrôles individuels avec une page, une application ou une session.

Les contrôles serveur sur une page de formulaire Web peuvent générer différents événements. De nombreux événements sont déclenchés par une action de l'utilisateur dans le navigateur. Par exemple, un contrôle serveur Web Button peut générer un événement Click lorsqu'un utilisateur clique sur un bouton de votre page.

Le code de gestion de l'événement généré est exécuté sur le serveur. Lorsqu'un utilisateur clique sur un bouton, la page est publiée de nouveau sur le serveur. La structure de la page ASP.NET analyse les informations relatives à cet événement et, si vous disposez du gestionnaire d'événements approprié, votre code est appelé automatiquement. Lorsque l'exécution de votre code est terminée, la page est renvoyée au navigateur et inclut toutes les modifications effectuées par le code du gestionnaire d'événements.

Introduction

Programmation des événements

Exemple


! Ouverture d'un gestionnaire d'événements de page ou de contrôle 1. Dans le menu Affichage, cliquez sur Code pour ouvrir l'éditeur de code du

formulaire Web avec lequel vous travaillez. 2. Dans la liste Nom de la classe, cliquez sur le contrôle à propos duquel vous

souhaitez écrire du code. Pour écrire le code d'un événement de page tel que Page_Load, cliquez sur (Événements de classe de base) dans la liste. Dans l'illustration suivante, la liste Nom de la classe apparaît avec le Button1 sélectionné.

3. Ouvrez la liste Nom de la méthode pour afficher les événements disponibles pour le contrôle. L'illustration suivante affiche la liste des événements de contrôle de Button1. L'événement Click est sélectionné.

4. Cliquez sur l'événement pour ouvrir le gestionnaire d'événements correspondant.

Pour plus d'informations sur les contrôles serveur ASP.NET, reportez-vous à la documentation de Visual Studio .NET.

Ouverture d'un gestionnaire d'événements

Remarque


Génération et exécution d'une page de formulaires Web

! Dans l'Explorateur de solutions, cliquez avec le bouton droit sur les formulaires Web, puis sélectionnez Générer et parcourir

! Raccourci clavier : Appuyez sur CTRL+F8 pour exécuter la commande Générer et parcourir


Après avoir créé un projet, ajouté des contrôles et des gestionnaires d'événements pour ces contrôles, vous pouvez compiler le fichier de classe de la page. Vous pouvez ensuite afficher la page dans n'importe quel navigateur.

! Génération et exécution de votre page de formulaire Web 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

WebForm1.aspx, puis sélectionnez Générer et parcourir. Raccourci clavier : Appuyez sur CTRL+F8 pour exécuter la commande Générer et parcourir. Visual Studio .NET compile la page et l'affiche dans l'onglet Parcourir.

2. Pour interrompre l'exécution du formulaire et revenir au mode Design, fermez l'onglet Parcourir.

Introduction

Génération et exécution de la page de formulaire Web


Application pratique : Création d'une page de formulaires Web

Créez le projet et le formulaire

Ajoutez des contrôles

Générez et parcourez la page de formulaires Web

Créez un gestionnaire d'événements


Dans cette application pratique, vous allez créer une page de formulaire Web.

! Création d'un projet d'application Web ASP.NET 1. Démarrez Visual Studio .NET. 2. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 3. Dans la boîte de dialogue Nouveau projet, effectuez les opérations

suivantes : a. Dans le volet Types de projets, cliquez sur Projets Visual Basic. b. Dans le volet Modèles, cliquez sur Application Web ASP.NET. c. Dans la zone Emplacement, entrez l'URL complète de votre

application : http://localhost/MyWebFormsPage d. Cliquez sur OK. Lorsque vous cliquez sur OK, un nouveau projet est créé à la racine du serveur Web que vous avez spécifié. En outre, une nouvelle page de formulaire Web appelée WebForm1.aspx s'affiche en mode Design dans le Concepteur de formulaires Web.

! Ajout de contrôles serveur ASP.NET à une page de formulaire Web 1. Sous l'onglet WebForms de la boîte à outils, faites glisser un contrôle

Button sur la page. 2. Sous l'onglet WebForms de la boîte à outils, faites glisser un contrôle

TextBox sur la page.

Introduction


! Création d'un gestionnaire d'événements pour le contrôle Button 1. Créez un gestionnaire d'événements pour l'événement Click du contrôle

Button. 2. Dans le gestionnaire d'événement Button1_Click, tapez le code suivant

pour afficher la date et l'heure actuelles dans le contrôle TextBox, en définissant sa propriété Text. TextBox1.Text = Now

! Génération et exécution de votre page de formulaire Web 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

WebForm1.aspx, puis cliquez sur Générer et parcourir. Raccourci clavier : En mode Design, appuyez sur CTRL+F8 pour exécuter la commande Générer et parcourir. Visual Studio .NET compile la page et l'affiche dans l'onglet Parcourir � WebForm1.

2. Cliquez sur le bouton dans votre page de formulaire Web. La date et l'heure actuelles s'affichent dans la zone de texte.

3. Pour interrompre l'exécution du formulaire et revenir à l'éditeur de code, fermez l'onglet Parcourir - WebForm.

Les fichiers de solutions de cette application pratique se trouvent dans le dossier dossier_installation\Practices\Mod10\MyWebFormsPage\Solution.



Leçon : Utilisation des services Web XML

! Qu'est-ce qu'un service Web XML ?

! Fonctionnement des services Web XML

! Découverte et utilisation des services Web XML

! Appel d'un service Web XML à l'aide d'un proxy


Les services Web XML sont des applications hébergées sur un serveur Web auxquelles les clients accèdent par l'intermédiaire du Web. Les services Web XML constituent l'élément de base de l'évolution vers l'informatique distribuée sur Internet. Une application peut être élaborée à l'aide de plusieurs services Web XML provenant de sources différentes qui travaillent ensemble, indépendamment de leur emplacement ou de leur mode d'implémentation.

Cette leçon contient les activités et les sujets suivants :

! Qu'est-ce qu'un service Web XML ? ! Fonctionnement des services Web XML ! Démonstration : Utilisation des services Web XML ! Découverte et utilisation des services Web XML ! Appel d'un service Web XML à l'aide d'un proxy


! expliquer ce qu'est un service Web XML ; ! décrire le mode de recherche d'un service Web XML existant ; ! créer un proxy pour appeler un service Web XML ; ! invoquer les méthodes des services Web XML dans une application simple.

Introduction




Qu'est-ce qu'un service Web XML ?

! Un composant programmable qui fournit une fonctionnalité particulière à une application

! Interagit avec les applications via Internet! Indépendant du langage, du protocole et de la plate-forme

InternetInternet Service Web XML des taux de changeService Web XML

des taux de changeSélectionnez votre destination:

Taux de change:

Tarif le moins élevé disponible:

Londres

1,00 $ = 1,00 �

1 999,98 �Base de donnéesdes tarifs

Base de donnéesdes tarifs

Service Web XML des tarifs

Service Web XML des tarifs

Site de voyage Northwind TradersSite de voyage Northwind Traders


Les services Web XML sont semblables aux composants dans la mesure où ils représentent des fonctionnalités de boîte noire que les développeurs peuvent utiliser pour ajouter des fonctionnalités aux formulaires Web, aux applications Windows ou même aux autres services Web XML, sans se préoccuper des modalités d'implémentation du service de prise en charge.

Un service Web XML est un composant programmable qui fournit une fonctionnalité particulière à une application, telle que la logique de l'application. Un service Web peut être utilisé en interne par une seule application ou en externe par de nombreuses applications qui y accèdent via Internet.

Microsoft Passport est un exemple de service Web XML qui vérifie l'identité des utilisateurs. Une entreprise peut s'abonner à Microsoft Passport et utiliser ce service pour vérifier l'identité d'un utilisateur avant de l'autoriser à accéder à une application, au lieu d'écrire son propre code à cet effet.

Grâce à l'architecture des services Web XML, les programmes écrits dans des langages différents sur des plates-formes disparates peuvent communiquer entre eux selon des normes établies. Les services Web XML vous permettent de fournir rapidement l'accès à la logique d'une application ou de rechercher un service Web XML et de l'utiliser dans votre application, grâce aux fonctionnalités suivantes :

! Indépendance vis-à-vis du langage de programmation Une connexion à un service Web XML peut être écrite dans n'importe quel langage compatible avec Microsoft .NET. Ainsi, vous n'avez pas besoin d'apprendre un nouveau langage de programmation pour utiliser un service Web XML. Un composant écrit dans un langage compatible avec l'environnement .NET et exporté sous la forme d'un service Web XML peut être utilisé par toute application Visual Basic .NET capable de transmettre et de lire le format XML à l'aide du protocole de transport approprié.

Introduction

Définition

Exemple de service Web XML

Avantages des services Web XML ?


! Indépendance vis-à-vis du protocole Contrairement aux autres technologies de composants, les services Web XML n'utilisent pas un protocole spécifique à certains modèles d'objets, par exemple DCOM (Distributed Component Object Model) ou CORBA (Common Object Request Broker Architecture). Les services Web XML communiquent par l'intermédiaire de protocoles Web et de formats de données standard, notamment HTTP (Hypertext Transfer Protocol) et XML. Un serveur qui prend en charge ces normes Web peut accéder aux services Web XML ou les héberger.

! Indépendance vis-à-vis d'une plate-forme Les services Web XML sont conçus pour interagir directement avec d'autres applications par l'intermédiaire d'Internet. En conséquence, ils ne disposent pas d'une interface utilisateur et fournissent au contraire des interfaces standard prédéfinies (appelées contrats) qui décrivent les services offerts. Ils sont accessibles par l'intermédiaire d'une interface standard et permettent à des systèmes disparates de travailler ensemble. Les serveurs capables de prendre en charge les formulaires Web peuvent également prendre en charge les services Web XML.

L'illustration précédente illustre un site Web fictif de voyage qui offre plusieurs fonctionnalités basées sur des services Web XML. Dans ce scénario, l'utilisateur entre le nom d'une ville de destination que le code de l'application utilise sous la forme d'un paramètre lorsqu'il appelle deux services Web XML. Du point de vue de l'utilisateur, ce site Web de voyage est très complet. Au niveau du code, il représente plutôt une interface graphique qui combine les services Web XML de sociétés non apparentées.

Grâce aux services Web XML, ce site Web de voyage offre plusieurs avantages au site Web de consommation et aux différents fournisseurs de services Web XML.

Les fournisseurs de site Web bénéficient des avantages suivants :

! L'application agence de voyage est en mesure d'offrir des fonctionnalités supérieures à celles que pourraient créer le développeur employé par l'agence, en raison de ses capacités, disponibilités ou connaissances insuffisantes.

! L'agence de voyage ne supporte pas les frais de mise à jour des données, par exemple l'actualisation des prix des voyages ou des taux de change.

! Le développeur employé par l'agence de voyage n'a pas besoin de savoir comment le service Web XML a été élaboré et déployé pour pouvoir l'utiliser.

! Le site Web peut également facturer les fournisseurs de services Web XML qui proposent leurs services à la base de données des clients du site Web.

Exemple de service Web XML


Les fournisseurs de services Web XML bénéficient des avantages suivants :

! Le fournisseur de services Web XML ne supporte pas le coût de développement et de commercialisation d'un site Web pour la clientèle intéressée par les voyages.

! En proposant une application sous la forme d'un service Web XML, le fournisseur de service Web peut accéder à la base de données des clients de plusieurs agences de voyage.

! Le service Web XML peut être utilisé par un grand nombre d'applications. ! Le fournisseur du service Web XML peut facturer le site Web pour son

utilisation de ce service.

Pour plus d'informations sur l'utilisation des services Web XML par les entreprises, reportez-vous au site Web consacré aux études de cas sur les services Web XML de Microsoft à l'adresse suivante : http://www.microsoft.com/net/use/casestudies.asp

Remarque


Fonctionnement des services Web XML

! SOAP

Les services Web XML offrent des fonctionnalitésavancées par l'intermédiaire du protocole SOAP

! WSDL

Les services Web XML décrivent leurs interfaces dans un document WSDL

! UDDI

Les développeurs enregistrent les services Web XML par l'intermédiaire d'UDDI


Les services Web XML qui offrent des fonctionnalités sur le Web par l'intermédiaire du protocole SOAP sont décrits à l'aide d'un fichier WSDL (Web Services Description Language) et sont enregistrés par l'intermédiaire de la norme UDDI (Universal Description, Discovery and Integration).

Les services Web XML offrent des fonctionnalités avancées par l'intermédiaire d'un protocole Web standard. Le protocole SOAP est utilisé dans la plupart des cas. Ce protocole XML léger est destiné à l'échange des informations. SOAP définit le format XML des messages.

Les services Web XML fournissent une méthode de description détaillée de leurs interfaces qui permet à un utilisateur de générer une application cliente pour communiquer avec eux. Cette description est généralement fournie dans un document XML appelé document WSDL.

Le fichier WSDL définit tous les éléments nécessaires pour écrire un programme avec un service Web XML, y compris les informations suivantes :

! Emplacement de l'URL ! Services et propriétés Web XML ! Types de données utilisés ! Protocoles de communication

Visual Studio .NET utilise le fichier WSDL pour créer des objets de proxy pour communiquer avec un service Web XML.

Pour plus d'informations sur les fichiers WSDL, reportez-vous à la section « découvrir des services Web : Découverte des services Web XML (ATL Server) » dans la documentation Visual Studio .NET.

Introduction

SOAP

WSDL

Remarque


Les services Web XML sont enregistrés à l'aide de UDDI afin que les utilisateurs potentiels puissent les trouver facilement. La norme UDDI est utilisée de manière générale dans l'industrie et elle permet aux entreprises de :

! définir leur activité, ! découvrir d'autres entreprises, ! partager les informations sur leur mode d'interaction dans un registre global.

La norme UDDI ressemble à un annuaire téléphonique des services Web XML. Comme dans un annuaire téléphonique traditionnel, la norme UDDI vous permet de rechercher une société qui offre les services dont vous avez besoin, de lire des informations sur les services proposés et de contacter un utilisateur pour obtenir plus d'informations à leur sujet.

Les développeurs de services Web XML publient les descriptions et les emplacements de leurs services Web XML sur un site Web UDDI. Après que les données ont été enregistrées, elles sont accessibles à toute personne souhaitant découvrir les services Web proposés par une entreprise donnée.

Pour plus d'informations sur UDDI, consultez le site Web UDDI (en anglais) à l'adresse http://www.uddi.org et le site Web UDDI Microsoft (en anglais) à l'adresse http://uddi.microsoft.com.

UDDI

Remarque


Démonstration : Utilisation des services Web XML

! Dans cette démonstration, vous apprendrez à visualiser le document WSDL pour un service Web XML, à appeler un service Web XML et à utiliser les méthodes du service Web dans une applicationsimple


Dans cette démonstration, vous apprendrez à visualiser le document WSDL pour un service Web XML, appeler un service Web XML à partir d'une application simple et utiliser les méthodes du service Web XML pour calculer un amortissement.


Découverte et utilisation des services Web XML

.disco

.wsdl

Service WebService WebProxyProxy

FormulaireWeb

UDDI

222

333

444 555

111

222

333

444

555

Interrogation du site Web UDDI

Lecture de la description du fichier .wsdl

Liaison du service Web XML au proxyAppel du service Web XML à partirde l'application via le proxy 111

Localisation de l'URL du service Web XML dans le fichier .disco


Si vous développez une application qui utilise un service Web XML d'un partenaire commercial, celui-ci vous fournira très vraisemblablement l'URL appropriée. Vous pouvez toutefois souhaiter que votre application utilise d'autres services Web XML pour lesquels vous ne disposez pas des URL correspondantes.

Le processus de localisation d'un service Web XML et de ses descriptions, ainsi que le mode d'interaction avec celui-ci est appelé découverte. Vous pouvez trouver des services Web XML existants à ajouter à votre application en utilisant un ou plusieurs services de découverte. Ces services de recherche évoluent et changent rapidement au fur et à mesure que le développement et l'utilisation des services Web XML se généralisent dans la communauté Internet.

La découverte et l'appel d'un service Web XML s'effectuent selon le processus suivant :

1. Interrogation du site Web UDDI pour découvrir les services Web XML disponibles qui correspondent à vos attentes. Le site Web UDDI fournit la liste des services Web XML qui incluent les URL du document de découverte (fichier .disco) de ces services Web XML.

2. Sélection d'un service Web XML et accès au document de découverte pour localiser l'URL du service Web XML et les URL du document WSDL correspondant.

3. Génération d'un objet de proxy à partir du document WSDL. Un objet de proxy définit le code qui se comporte exactement comme la classe qu'il est censé représenter. Toutefois, un proxy ne contient aucun élément de la logique de l'application. En fait, il comprend plutôt la logique du transport et le marshalling. Un proxy permet à un client d'accéder à un service Web XML comme s'il s'agissait d'un objet local.

Introduction

Processus de découverte d'un service Web XML


4. Utilisation du proxy pour lier le service Web XML. 5. Appel du service Web XML à l'aide du proxy.

Vous pouvez utiliser Visual Studio .NET pour vous connecter à UDDI et rechercher et analyser les services Web XML disponibles.

! Utilisation de Visual Studio .NET pour localiser les informations sur les services Web XML

1. Dans la page de démarrage de Visual Studio .NET, cliquez sur Services Web XML. Si cette page n'est pas visible, cliquez sur Aide, puis sur Afficher la page de démarrage.

2. Sous l'onglet Rechercher un service, cliquez sur Environnement de production UDDI ou sur Environnement de test UDDI.

L'option Environnement de production UDDI est sélectionnée par défaut. Si vous développez une application, cliquez sur Environnement de test UDDI.

3. Dans la zone Rechercher, entrez le mot clé du service Web XML que vous souhaitez localiser.

4. Cliquez sur Aller à pour lancer la recherche. Le résultat de la recherche s'affiche sous les critères de recherche. Il vous permet d'afficher plus d'informations sur un service Web XML.

Cette procédure ne fonctionne pas dans un environnement qui n'est pas connecté à Internet.

Visual Studio .NET et UDDI

Remarque

Remarque


Appel d'un service Web XML à l'aide d'un proxy

1. Créez une référence Web pour le service Web XML

2. Créez une instance du service Web XML

3. Appelez les méthodes Web du service Web XML

Sub GetRatingButton_Click (...)Dim ProxyGetStocks As New localhost.GetStocks( )ResultsLabel.Text = _

ProxyGetStocks.GetRating("Contoso, Ltd.")End Sub

Sub GetRatingButton_Click (...)Dim ProxyGetStocks As New localhost.GetStocks( )ResultsLabel.Text = _

ProxyGetStocks.GetRating("Contoso, Ltd.")End Sub

111

222

333

Dim WebServiceName As New localhost.service1( ) Dim WebServiceName As New localhost.service1( )

Label1.Text = WebServiceName.WebMethod( )Label1.Text = WebServiceName.WebMethod( )

Exemple :


Pour appeler un service Web XML à partir de votre projet d'application, vous devez lui ajouter une référence Web. Visual Studio .NET crée automatiquement l'objet de proxy qui permet de communiquer avec le service Web XML. Ce scénario utilise une application Web. Le processus est identique pour une application Windows.

! Appel d'un service Web XML à partir d'un formulaire Web 1. Ouvrez l'application à partir de laquelle vous appellerez le service Web

XML. 2. Dans le menu Projet, cliquez sur Ajouter une référence Web. 3. Dans le champ Adresse de la boîte de dialogue Ajouter une référence

Web, tapez l'URL du service Web XML auquel vous souhaitez accéder, appuyez sur ENTRÉE, puis cliquez sur Ajouter la référence. Après avoir ajouté une référence Web à votre projet, Visual Studio .NET affiche les fichiers qui lui sont associés dans un sous-dossier du dossier Références Web de l'Explorateur de solutions. Par défaut, le nom de la référence Web correspond au nom du serveur qui héberge le service Web XML. Par exemple, si vous créez une référence Web vers http://localhost/ Stocks/Service1.asmx, Visual Studio .NET lui attribue le nom localhost par défaut.

Visual Studio .NET est optimisé pour les services Web XML qui sont créés par Visual Studio .NET. ASP.NET peut dans certains cas ne pas lire les fichiers WSDL créés à l'aide d'autres programmes.

Introduction

Appel d'un service Web XML

Remarque


4. Dans le code du formulaire Web, créez une instance du proxy du service Web XML. Dans l'exemple suivant, WebServiceName désigne l'instance du service Web XML que vous avez choisie, localhost correspond au nom de la référence Web et service1 identifie le service Web. Dim WebServiceName As New localhost.service1( )

5. Appelez les méthodes Web du service Web XML.

Dans l'exemple suivant, la méthode WebMethod est appelée et la valeur de retour est affectée à la propriété de texte d'une étiquette sur le formulaire Web. Label1.Text = WebServiceName.WebMethod( )

L'exemple suivant est basé sur un formulaire Web doté d'un bouton GetRating et d'une étiquette appelée ResultsLabel. Lorsque l'utilisateur clique sur le bouton GetRating, une instance du proxy du service Web XML GetStocks est créée. La deuxième ligne de code appelle la méthode GetRating du service Web XML, transmet le nom « Contoso, Ltd. » sous la forme d'un paramètre et affiche la valeur de retour à l'utilisateur à l'aide de la propriété Text de l'étiquette ResultsLabel.

Sub GetRatingButton_Click (...) Dim ProxyGetStocks As New localhost.GetStocks( ) ResultsLabel.Text = _ ProxyGetStocks.GetRating("Contoso, Ltd.") End Sub

Exemple d'appel d'un service Web XML



! Utilisation des formulaires Web

! Utilisation des services Web XML

Accèsaux données



Écriturede code

Créationd'une

interface


1. Comment afficher un texte à l'utilisateur sur une page de formulaire Web ? a. En mode Design, ajoutez un contrôle Label au formulaire Web, puis

tapez le texte dans la propriété Text. b. En mode Design ou Mise en page fluide, tapez le texte directement dans

le formulaire Web. c. En mode Design ou Présentation de la grille, tapez le texte directement

dans le formulaire Web. d. En mode HTML, ajoutez le texte à l'aide des balises HTML appropriées. Les réponses a, b et d sont correctes.

2. Laquelle des extensions suivantes correspond au fichier qui contient le code de gestion des événements d'un formulaire Web ? a. asmx b. Web.config c. webform1.vb d. aspx.vb La réponse d est correcte.

3. Quel attribut force le serveur à reconnaître qu'un élément est un contrôle serveur ? runat = "server"


4. Quel est le nom par défaut d'un serveur Web exécuté sur un ordinateur local ? a. aspx b. localhost c. localserver d. aspx.vb La réponse b est correcte.

5. Quel est le protocole utilisé pour communiquer entre un proxy et un service Web XML ? a. HTML b. WSDL c. SOAP d. UDDI La réponse c est correcte.

6. Comment accédez-vous à un service Web XML à partir d'un formulaire Web ? Vous créez une référence Web au service Web XML. La création de cette référence engendre la création d'un proxy par Visual Studio. Dans une procédure d'événement sur le formulaire Web, instanciez le proxy et appelez les méthodes Web du service Web XML.


Atelier 10.1 : Création d'une application Web

! Exercice 1 : Création de l'interface utilisateur

! Exercice 2 : Utilisation des services Web XML



! créer un formulaire Web et utiliser les contrôles serveur ASP.NET ; ! découvrir un service Web XML et l'utiliser à partir d'un formulaire Web ; ! écrire les gestionnaires d'événements des contrôles ; ! appeler les méthodes fournies par le service Web XML.

Cet atelier est axé sur les concepts expliqués dans ce module et peut ne pas être conforme aux recommandations de sécurité préconisées par Microsoft.


! savoir écrire des gestionnaires d'événements dans Visual Basic .NET ; ! être familiarisé avec les formulaires Web et les contrôles serveur

ASP.NET ; ! connaître le processus de découverte d'un service Web XML.

Dans cet atelier, vous utiliserez des formulaires Web pour créer une interface utilisateur semblable à celle de l'application de calcul de prêt. Vous utiliserez également un service Web XML pour calculer le montant des remboursements dans le formulaire Web.

Les fichiers de solution correspondant à cet atelier se trouvent dans les dossiers dossier_installation\Labfiles\Lab101\Ex01\Solution et dossier_installation\ Labfiles\Lab101\Ex02\Solution.

Objectifs

Remarque


Scénario




Exercice 1 Création de l'interface utilisateur

Dans cet exercice, vous allez créer l'interface utilisateur de la version Web de l'application de calcul de prêt.

! Création d'un nouveau projet 1. Démarrez Visual Studio .NET. 2. Créez une nouvelle application Web Visual Basic ASP.NET. Définissez

son emplacement sur http://localhost/2560/Labfiles/Lab101/Ex01/ WebFormApplication puis cliquez sur OK.

3. Modifiez la propriété Nom de fichier de WebForm1.aspx en WebForm.aspx.

! Ajout de contrôles au formulaire principal • Ajoutez les contrôles suivants au formulaire Web :


Label1 Text Calcul de prêt

Font.Bold True

Font.Size X-Large

Label2 ID LoanAmountLabel

Text Montant du prêt

Label3 ID InterestRateLabel

Text Taux d'intérêt

Label4 ID LoanTermLabel

Text Durée du prêt

Label5 ID PaymentLabel

Text Paiement

Label6 ID AmountLabel

Text Vide

TextBox1 ID LoanAmountTextBox

DropDownList1 ID InterestRateDropDownList

Items 4.5, 5.0, 6.0, 6.5, 7.0, 7.5, 8.0, 9.0, 10.0

DropDownList2 ID LoanTermDropDownList

Items 10, 15, 30

Button1 ID MonthlyPaymentButton

Text Mensualité

Button2 ID TotalPaidButton

Text Total remboursé


Votre formulaire doit ressembler à ce qui suit :

! Compilation et exécution du projet 1. Générez le projet. 2. Exécutez le projet dans un navigateur. 3. Fermez le navigateur.


Exercice 2 Utilisation des services Web XML

Dans cet exercice, vous appellerez les méthodes d'un service Web XML à l'aide d'un proxy, puis utiliserez ces méthodes pour calculer le montant des remboursements de prêt.

! Ajout d'une référence Web 1. Continuez à utiliser le projet que vous avez créé au cours de l'exercice 1.

Si vous n'avez pas terminé cet exercice, utilisez le projet WebFormApplication.sln dans le dossier dossier_installation\Labfiles\ Lab101\Ex02\Starter.

2. Dans le menu Projet, cliquez sur Ajouter une référence Web, puis tapez l'URL suivante : http://localhost/2560/Labfiles/Lab101/Ex02/WebService/ CalculationService.asmx?wsdl

3. Cliquez sur le bouton Atteindre , puis sur Ajouter la référence.

! Appel de la méthode MonthlyPayment dans le gestionnaire d'événements du contrôle MonthlyPaymentButton

1. Ajoutez un gestionnaire d'événements pour l'événement MonthlyPaymentButton_Click.

2. Déclarez et instanciez une variable localhost.CalculationService appelée payment. Votre code doit se présenter comme suit : Dim payment As New localhost.CalculationService( )

3. Appelez la méthode MonthlyPayment de payment.

a. Utilisez les paramètres suivants lors de l'appel de MonthlyPayment. Paramètre Valeur

loanAmount CDbl(LoanAmountTextBox.Text)

rate CDbl(InterestRateDropDownList.SelectedItem.Text)

loanLength CInt(LoanTermDropDownList.SelectedItem.Text)

b. Utilisez la fonction FormatCurrency pour mettre en forme la valeur de retour de la méthode MonthlyPayment et attribuez la valeur de retour mise en forme à la propriété AmountLabel.Text.

Votre code doit se présenter comme suit : AmountLabel.Text = FormatCurrency(payment.MonthlyPayment _ (CDbl(LoanAmountTextBox.Text), _ CDbl(InterestRateDropDownList.SelectedItem.Text), _ CInt(LoanTermDropDownList.SelectedItem.Text)


! Appel de la méthode TotalPaid dans le gestionnaire d'événements du contrôle TotalPaidButton

1. Ajoutez un gestionnaire d'événements pour l'événement TotalPaidButton_Click.

2. Déclarez et instanciez une variable localhost.CalculationService appelée payment.

3. Appelez la méthode TotalPaid de payment. a. Utilisez les paramètres suivants lors de l'appel de la méthode TotalPaid.

Paramètre Valeur

loanAmount CDbl(LoanAmountTextBox.Text)

rate CDbl(InterestRateDropDownList.SelectedItem.Text)

loanLength CInt(LoanTermDropDownList.SelectedItem.Text)

b. Utilisez la fonction FormatCurrency pour mettre en forme la valeur de retour de la méthode TotalPaid et attribuez la valeur de retour mise en forme à la propriété AmountLabel.Text.

Votre code doit ressembler au texte suivant : AmountLabel.Text = FormatCurrency(payment.TotalPaid _ (CDbl(LoanAmountTextBox.Text), _ CDbl(InterestRateDropDownList.SelectedItem.Text), _ CInt(LoanTermDropDownList.SelectedItem.Text)

! Compilation, exécution et test de l'application 1. Cliquez avec le bouton droit sur WebForm.aspx. 2. Cliquez sur Générer et parcourir.

La page WebForm.aspx s'affiche dans une fenêtre de navigateur à l'intérieur de Visual Studio .NET.

3. Entrez le montant du prêt, le taux d'intérêt et la durée du prêt. 4. Cliquez sur Mensualité pour calculer le montant du remboursement

mensuel. 5. Cliquez sur Total remboursé pour calculer le montant total des paiements. 6. Quittez Visual Studio .NET.

2 Error! No text of specified style in document.

PAGE INTENTIONNELLEMENT VIDE

Table des matières

Vue d'ensemble 1

Leçon : Concepts des bases de données 2

Leçon : Présentation d'ADO.NET 14

Leçon : Utilisation des données 27


Atelier 11.1 : Accès aux données à l'aide d'ADO.NET 44

Module 11 : Utilisation d'ADO.NET

Les informations contenues dans ce document, y compris les adresses URL et les références à des sites Web Internet, pourront faire l�objet de modifications sans préavis. Sauf mention contraire, les sociétés, les produits, les noms de domaines, les adresses de messagerie, les logos, les personnes, les lieux et les événements utilisés dans les exemples sont fictifs, et toute ressemblance avec des sociétés, produits, noms de domaines, adresses de messagerie, logos, personnes, lieux et événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique, mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de Microsoft Corporation. Les produits mentionnés dans ce document peuvent faire l'objet de brevets, de dépôts de brevets en cours, de marques, de droits d'auteur ou d'autres droits de propriété intellectuelle et industrielle de Microsoft. Sauf stipulation expresse contraire d�un contrat de licence écrit de Microsoft, la fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets, marques, droits d'auteur ou autres droits de propriété intellectuelle. 2002 Microsoft Corporation. Tous droits réservés. Microsoft, MS-DOS, Windows, Active Directory, ActiveX, bCentral, BizTalk, FrontPage, IntelliSense, JScript, Microsoft Press, MSDN, MSN, Outlook, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans d'autres pays. Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs propriétaires respectifs.

Module 11 : Utilisation d'ADO.NET iii

Notes de l'instructeur Ce module explique comment utiliser Microsoft® ADO.NET avec une application Microsoft Windows® Forms pour créer, lire, mettre à jour et supprimer des enregistrements dans une base de données Microsoft SQL Server� 2000 Desktop Engine (MSDE).


! définir la terminologie élémentaire des bases de données, notamment les termes base de données, table, enregistrement, champ et clé ;

! décrire certains objets ADO.NET fréquemment utilisés ; ! créer et établir une connexion à une base de données ; ! créer, lire, mettre à jour et supprimer des enregistrements dans une base de

données ; ! utiliser l'Assistant Formulaire de données pour créer une application simple

d'accès aux données ; ! afficher et modifier les données extraites d'une base de données.

Pour animer ce module, vous devez disposer du fichier suivant :

•••• Fichier Microsoft PowerPoint® 2560A_11.ppt


! lire tous les documents de cours relatifs à ce module ; ! réaliser les applications pratiques et l'atelier.


Documents de cours

Préparation

iv Module 11 : Utilisation d'ADO.NET

Comment animer ce module Cette section contient des informations destinées à vous permettre d'animer ce module.

Leçon : Concepts des bases de données Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon.

Ouvrez Microsoft Visual Studio® .NET et expliquez comment effectuer chacune des tâches que les stagiaires devront réaliser dans les applications pratiques et dans l'atelier. Les stagiaires auront la possibilité de mettre en pratique les connaissances qu'ils auront acquises sur les environnements connectés et déconnectés dans l'application pratique.

Lorsque les stagiaires utilisent des bases de données, il est important qu'ils comprennent la terminologie élémentaire. Pour réaliser ce module, les stagiaires doivent maîtriser les termes suivants : table, enregistrement, champ, clé et relation. Expliquez chacun de ces termes, si possible en donnant en exemple une table d'une base de données. Pour illustrer ces concepts, vous pouvez ouvrir la base de données Northwind dans l'Explorateur de serveurs.

L'objectif de cette rubrique consiste à expliquer aux stagiaires comment travailler par programme avec des bases de données. Passez en revue toutes les étapes, notamment les procédures pour établir une connexion, spécifier les données à extraire, générer les données demandées et retransmettre les mises à jour à la base de données. Chacune de ces étapes sera traitée ultérieurement dans le module, dans le contexte de l'utilisation d'un objet ADO.NET ou d'un outil Visual Studio .NET pour effectuer cette tâche.

Cette rubrique définit SQL (Structured Query Language) et explique aux stagiaires la syntaxe de base de l'instruction SELECT. Il est important que les stagiaires sachent comment utiliser l'instruction SELECT car ils recourront souvent à SQL et à l'instruction SELECT pour préciser les enregistrements devant être extraits d'une base de données. SQL est un langage qui est progressivement devenu la norme en matière d'interrogation et de modification des données dans une base de données.

Depuis l'apparition de l'informatique, le seul environnement disponible était l'environnement connecté. Un environnement connecté signifie qu'une application ou un utilisateur est constamment connecté à une source de données. Décrivez les avantages et les inconvénients d'un environnement connecté. Soulignez qu'une application maintient rarement la connexion à la base de données durant l'édition et la mise à jour des enregistrements, bien qu'il s'agissait là de l'architecture courante dans les applications de données client-serveur types.

Terminologie des bases de données

Programmation pour l'accès aux bases de données

Présentation de SQL

Présentation d'un environnement connecté

Module 11 : Utilisation d'ADO.NET v

Lorsque l'Internet est apparu, les scénarios de travail déconnecté sont devenus monnaie courante, puis l'essor des périphériques portables a entraîné l'adoption quasi universelle des scénarios déconnectés. Les différents types d'ordinateurs portables vous permettent d'utiliser des applications lorsque vous êtes déconnecté des serveurs ou des bases de données. Dans de nombreux cas, les personnes ne travaillent pas exclusivement dans un environnement connecté ou déconnecté, mais plutôt dans un environnement qui associe les deux approches.

Décrivez les avantages et les inconvénients des environnements déconnectés. Dans l'application pratique de cette leçon, les stagiaires doivent choisir des environnements connectés ou déconnectés. Par conséquent, vous pouvez mentionner des situations réelles dans lesquelles chaque type d'environnement est le plus adapté.

Dans cette application pratique, les stagiaires devront examiner cinq scénarios avec un partenaire puis déterminer si les scénarios conviendraient mieux dans un environnement connecté ou dans un environnement déconnecté. Ils devront également indiquer si un accès en lecture seule ou en lecture/écriture est nécessaire. 30 minutes environ doivent être consacrées à cette application pratique (discussions avec les partenaires et la discussion avec la classe).

Ces scénarios ne sont pas destinés à fournir tous les détails nécessaires pour permettre de prendre des décisions en termes d'architecture. Leur rôle consiste à familiariser les stagiaires avec des situations réelles dans lesquelles ils pourraient utiliser les environnements connectés ou déconnectés. Si les stagiaires estiment que les détails des scénarios ne sont pas adaptés, incitez-les à définir les détails manquants avec leur partenaire puis à prendre une décision.

Dans ce contexte, déconnecté signifie que les données peuvent être téléchargées et manipulées sur l'ordinateur client puis échangées pour soumettre des transactions. La connexion doit simplement être active suffisamment longtemps pour permettre de télécharger un groupe de données ou de vérifier le compte d'une carte de crédit par le biais de la logique applicative standard. Prenez en compte les éléments suivants lorsque vous mentionnez les réponses correctes des scénarios.

! Scénario 1 La logique de lecture seule côté client permet aux clients de recevoir les données requises et fournit toutes les fonctionnalités nécessaires.

! Scénario 2 Les personnes qui effectuent des expériences doivent recevoir des données en temps réel, de manière continue, pour arrêter manuellement les stimuli lorsque le système indique que les mesures déterminées ont été atteintes.

! Scénario 3 Il s'agit d'un système de transactions Internet courant et simple. Une fois les données téléchargées, l'ensemble du traitement peut être effectué sur le client, mais la fonctionnalité lecture/écriture est nécessaire.

Présentation d'un environnement déconnecté

Application pratique : Identification des scénarios d'environnements connectés ou déconnectés

Remarque

vi Module 11 : Utilisation d'ADO.NET

! Scénario 4 La force de vente sera connectée de temps en temps (pas constamment). L'application est donc conçue pour un traitement déconnecté, lequel est possible lorsque la force de vente est en ligne ou hors ligne. Il n'est pas nécessaire de pouvoir écrire dans les données du compte créditeur du client, mais il est nécessaire de pouvoir écrire dans toutes les autres données.

! Scénario 5 Les opérateurs doivent avoir accès uniquement aux données de leurs clients, et bien que ces transactions aient lieu rapidement, elles peuvent survenir en mode déconnecté pour permettre la meilleure utilisation possible des ressources de la base de données sur site.

Une fois que les stagiaires ont terminé cette application pratique, présentez chaque scénario à l'ensemble de la classe et laissez les stagiaires justifier leur réponse.

Leçon : Présentation d'ADO.NET Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon.

Cette introduction est une présentation générale des composants clés de ADO.NET. Cette rubrique ne fournit aucun détail complexe ; elle explique simplement aux stagiaires les concepts liés à l'intégration des données dans ADO.NET. La rubrique met l'accent sur le fait qu'ADO.NET inclut tous les composants nécessaires pour établir une connexion à des sources de données et pour manipuler les données dans les applications.

Les composants d'ADO.NET permettent de séparer l'accès aux données et la manipulation des données. ADO.NET comprend deux composants essentiels : le composant DataSet, et les fournisseurs de données Microsoft .NET, lesquels incluent un ensemble de composants, notamment les objets Connection, Command, DataReader et DataAdapter. Les composants du fournisseur de données .NET sont explicitement destinés à la manipulation des données dans un environnement déconnecté.

Cette rubrique traite des objets ADO.NET que les développeurs utilisent le plus souvent pour travailler avec des bases de données. Veillez à bien expliquer le rôle des objets Connection, DataAdapter et DataSet, car il est important que les stagiaires connaissent ces objets pour réaliser l'atelier. Les stagiaires n'utiliseront pas explicitement les objets Command et DataReader, cependant, veillez à présenter brièvement leur fonction dans un environnement de bases de données.

Dans cette démonstration, vous expliquerez aux stagiaires comment utiliser l'Explorateur de serveurs pour ajouter des connexions de base de données et pour afficher des éléments de base de données tels que les tables. À la fin de cette leçon, une application pratique permet d'utiliser l'Explorateur de serveurs pour afficher uniquement les données en lecture seule.

Les différentes étapes de cette démonstration figurent dans la section Démonstrations des notes de l'instructeur.

Présentation d'ADO.NET

Objets ADO.NET courants

Démonstration dirigée : Utilisation de l'Explorateur de serveurs

Module 11 : Utilisation d'ADO.NET vii

L'Explorateur de serveurs est un nouvel outil de Visual Studio .NET que les développeurs peuvent utiliser pour visualiser et manipuler les liaisons de données, les connexions de base de données et les ressources système sur un serveur doté d'un accès réseau. Cette rubrique présente le déroulement des tâches les plus courantes liées aux bases de données que les stagiaires doivent effectuer dans l'Explorateur de serveurs.

Dans l'application pratique figurant à la fin de cette leçon, les stagiaires utiliseront l'Explorateur de serveurs pour accéder aux données en lecture seule et pour les visualiser.

ADO.NET est étroitement intégré à XML, contrairement à ADO (ActiveX® Data Objects) version 2 x. ADO.NET facilite la conversion des données relationnelles au format XML. Vous pouvez également convertir des données XML dans une collection de tables et de relations.

Examinez l'exemple présenté dans la rubrique pour expliquer comment ADO.NET et XML sont associés, et mentionnez les supports de référence répertoriés à la fin de la rubrique.

Dans cette application pratique, les stagiaires ouvriront un nouveau projet et utiliseront la fonctionnalité « glisser-déplacer » de l'Explorateur de serveurs pour créer un groupe de données et charger des données en lecture seule dans une grille de données. La durée de cette application pratique ne doit pas dépasser 20 minutes.

Leçon : Utilisation des données Cette section décrit les méthodes pédagogiques employées pour l'étude de chaque rubrique de cette leçon. Les stagiaires réaliseront l'atelier afin de mettre en application les procédures et les concepts traités dans cette leçon.

Dans cette leçon, les stagiaires apprendront à utiliser les objets ADO.NET pour établir une connexion à une base de données, extraire des données, modifier des données et retransmettre les données mises à jour à la base de données. Ils apprendront également à utiliser le contrôle DataGrid afin d'afficher des données sur un formulaire Windows.

Avant de manipuler des données, vous devez établir une connexion à une source de données. Pour ce faire, vous devez choisir le type de connexion, spécifier la source de données et ouvrir la connexion à la source de données. Lorsque vous avez fini de manipuler les données, vous devez arrêter la connexion. Toutes ces tâches seront accomplies dans le code à l'aide de l'objet Connection.

Utilisation des bases de données dans l'Explorateur de serveurs

ADO.NET et XML

Application pratique : Accès aux données en lecture seule

Utilisation d'un objet Connection

viii Module 11 : Utilisation d'ADO.NET

Une fois que vous avez établi une connexion à une source de données, vous pouvez utiliser un adaptateur de données pour échanger des données entre la source de données et un groupe de données. Dans de nombreuses applications, l'échange des données implique la lecture des données d'une base de données dans un groupe de données par le biais de l'adaptateur de données, puis la lecture des données modifiées du groupe de données dans l'adaptateur de données, puis de nouveau dans la base de données. Un adaptateur de données peut toutefois déplacer les données entre n'importe quelle source et un groupe de données. Par exemple, un adaptateur peut déplacer les données entre un serveur exécutant Microsoft Exchange et un groupe de données.

Expliquez que vous pouvez instancier un objet DataAdapter en utilisant le mot clé Dim et en transmettant une chaîne de requête ainsi qu'un objet Connection en tant que paramètres. ADO.NET inclut deux types d'adaptateurs de données : OleDbDataAdapter et SqlDataAdapter. Ces deux types sont illustrés sous forme d'exemples dans cette leçon.

Une fois que vous avez spécifié les données que vous voulez extraire, l'étape suivante consiste à remplir un groupe de données avec les données de la base de données. Les groupes de données stockent les données dans un cache déconnecté. La structure d'un groupe de données est identique à celle d'une base de données relationnelle. Grâce au groupe de données, un modèle objet hiérarchique de tables, de lignes et de colonnes est disponible. Qui plus est, le groupe contient les contraintes et les relations qui sont définies pour le groupe de données.

Expliquez que la méthode Fill de DataAdapter charge un groupe de données, et que la méthode Update de DataAdapter transmet les modifications à la base de données.

Une fois que vous avez chargé un groupe de données, vous pouvez visualiser et modifier les données à l'aide du contrôle Windows Forms DataGrid. Le contrôle DataGrid affiche les données sous forme d'une série de lignes et de colonnes. Le cas le plus simple intervient lorsque la grille est liée à une source de données avec une seule table qui ne contient aucune relation. Dans ce cas, les données apparaissent dans des lignes et des colonnes simples, comme dans une feuille de calcul.

Montrez comme il est facile d'ajouter un contrôle DataGrid dans un formulaire, à partir de la section Windows Forms de la boîte à outils. Expliquez comment définir les propriétés DataSource et DataMember lors de l'exécution pour charger la grille de données.

Dans cette rubrique, les stagiaires apprendront à utiliser l'Assistant Formulaire de données pour automatiser la procédure d'utilisation des données. Grâce à l'Assistant, la tâche d'ajout de contrôles et de définition des propriétés se résume à quelques opérations très simples. Pour décrire comment utiliser l'Assistant et expliquer son rôle, la meilleure méthode consiste à procéder dans l'environnement de développement. Les stagiaires utiliseront également l'Assistant pour effectuer l'atelier 11.1, intitulé Accès aux données à l'aide d'ADO.NET.

Utilisation d'un objet DataAdapter

Utilisation d'un objet DataSet

Utilisation d'un contrôle DataGrid

Utilisation de l'Assistant Formulaire de données

Module 11 : Utilisation d'ADO.NET ix

Contrôle des acquis Les questions du contrôle des acquis sont principalement basées sur la compréhension des concepts et sur les procédures qui ont été traitées de manière approfondie dans le module. Vous pouvez utiliser un format de discussion pour répondre aux questions afin que chaque personne puisse connaître les réponses correctes.

1. Cette question permet de vérifier si les stagiaires ont compris les concepts d'environnement connecté et déconnecté. Lorsque vous traitez cette question, mentionnez de nouveau les avantages et les inconvénients de chaque type d'environnement, puis expliquez que les environnements déconnectés représentent la méthode principale pour travailler avec des données dans l'environnement .NET.

2. Les stagiaires n'écrivent aucune instruction SQL dans les applications pratiques ou l'atelier, mais plusieurs exemples dans le module utilisent des instructions SELECT. Vous pouvez attirer l'attention sur l'instruction SQL générée par l'Assistant Formulaire de données dans les commandes Update ou Insert pour l'objet DataAdapter.

3. Cette question est tout à fait adaptée pour aborder le recoupement entre les fonctionnalités d'un objet DataAdapter et d'un objet DataSet. Par exemple, vous pouvez utiliser la méthode Fill d'un objet DataAdapter pour charger un objet DataSet une fois qu'il a été instancié.

4. Cette question permet de vérifier si les stagiaires sont en mesure de reconnaître le code qui crée une connexion et spécifie le fournisseur ainsi que la base de données à laquelle ils accèdent. Si les stagiaires semblent avoir des difficultés à répondre, passez en revue le code ligne par ligne et expliquez ce qui se produit.

5. Si les stagiaires ont réalisé l'application pratique dans la seconde leçon (« Utilisation de données »), ils doivent savoir comment utiliser la méthode Fill de l'objet DataAdapter pour générer un DataSet. Cette question doit permettre de vérifier les acquis sur la syntaxe générale et les paramètres.

6. Il s'agit d'une simple question de rappel. 7. Lorsque vous traitez cette question, expliquez qu'il est très simple de

procéder à la liaison des données en définissant les propriétés du contrôle DataGrid lors de l'exécution.

Atelier 11.1 : Accès aux données à l'aide d'ADO.NET Avant de commencer cet atelier, les stagiaires doivent avoir réalisé les applications pratiques et répondu aux questions du contrôle des acquis. Dans la mesure où les stagiaires sont guidés par un Assistant dans cet atelier, ils peuvent terminer l'atelier sans nécessairement comprendre vraiment les concepts enseignés durant la leçon. Toutefois, chacune des étapes de l'Assistant correspond au contenu du module ; cet atelier devrait aider les stagiaires à associer mentalement les concepts d'ADO.NET aux tâches qu'ils doivent effectuer lorsqu'ils utilisent des bases de données.

x Module 11 : Utilisation d'ADO.NET

Démonstrations Cette section inclut des instructions détaillées concernant les démonstrations, notamment les étapes que vous devez effectuer dans toutes les démonstrations multimédias dirigées.

Démonstration dirigée: Utilisation de l'Explorateur de serveurs Dans cette démonstration, vous expliquerez aux stagiaires comment utiliser l'Explorateur de serveurs pour ajouter des connexions de base de données et afficher des éléments de base de données tels que les tables.

! Pour créer un projet 1. Démarrez un nouveau projet Microsoft Visual Basic® .NET basé sur le

modèle Application Windows. 2. Nommez le projet TitlesDataGrid, choisissez l'emplacement

dossier_installation\Democode\Mod11, puis cliquez sur OK.

! Pour présenter les fonctionnalités de l'Explorateur de serveurs à l'aide de la table Titles

1. Dans l'Explorateur de serveurs, sous Serveurs, développez le n�ud nom_ordinateur (London pour l'instructeur), développez le n�ud Serveurs SQL, puis développez le n�ud nom_ordinateur/NETSDK afin que toutes les bases de données SQL figurant sur votre ordinateur s'affichent.

2. Développez le n�ud de la base de données Pubs, le n�ud Tables sous Pubs, puis développez les champs sous la table Titles.

3. Cliquez avec le bouton droit sur la table Titles et expliquez les options qui s'affichent.

4. Cliquez sur Extraire les données de table, puis présentez les données des champs de la table dans la fenêtre de résultats. Expliquez que les données peuvent être mises à jour ici et que les contraintes imposées par la conception de la table SQL s'appliqueront. Fermez la fenêtre de résultats.

5. Cliquez sur plusieurs champs de la table Titles dans l'Explorateur de serveurs et expliquez dans quelle mesure les informations de type de données et de longueur affichées dans la fenêtre Propriétés peuvent être utiles pour créer une application.

Module 11 : Utilisation d'ADO.NET xi

! Pour ajouter les objets Connection et DataAdapter dans le formulaire 1. Dans l'Explorateur de serveurs, faites glisser la table Titles vers Form1.

Lorsque vous faites glisser la table vers le formulaire, SqlConnection1 et SqlDataAdapter1 seront créés puis ajoutés dans la barre d'état des composants .

2. Dans la fenêtre Propriétés, remplacez la propriété Name de SqlConnection1 par PubsConn, puis remplacez la propriété Name de SqlDataAdapter1 par PubsSqlDataAdapter.

3. Développez la propriété InsertCommand de PubsSqlDataAdapter. Vérifiez que la valeur de la propriété Connection correspond à PubsConn. Expliquez que l'objet Connection est la source de données de DataAdapter. Vous pouvez également expliquer que l'objet DataAdapter gère les commandes SQL Select, Insert, Delete et Update.

! Pour générer le groupe de données pour la table Titles 1. Dans la fenêtre Propriétés, dans la zone de description figurant au bas de la

liste des propriétés, cliquez sur Générer le groupe de données. 2. Dans la boîte de dialogue Générer le groupe de données, entrez

PubsDataSet dans la zone de texte Nouveau. 3. Conservez les valeurs par défaut dans les autres zones de texte.

Cliquez sur OK. PubsDataSet1 doit apparaître dans la barre d'état des composants.

! Pour ajouter un contrôle DataGrid au formulaire et pour définir ses propriétés

1. À partir de l'onglet Windows Forms de la boîte à outils, ajoutez un contrôle DataGrid au formulaire.

2. Dans la fenêtre Propriétés, attribuez au contrôle DataGrid le nom TitlesDataGrid.

3. Dans la fenêtre Propriétés, affectez la valeur PubsDataSet1 à la propriété DataSource du contrôle DataGrid, puis affectez la valeur titles à la propriété DataMember.

4. Dimensionnez le formulaire et le contrôle DataGrid afin que toutes les lignes et les colonnes soient visibles. La grille de données doit afficher le nom des champs de la table Titles.

! Pour remplir le DataSet avec les données de la table Titles •••• Ouvrez un gestionnaire d'événements pour l'événement Form1_Load. Dans

le gestionnaire d'événements Form1_Load, appelez la méthode Fill de l'adaptateur de données pour charger les données dans la table Titles. Votre code doit se présenter comme suit : PubsSqlDataAdapter.Fill(PubsDataSet1)

xii Module 11 : Utilisation d'ADO.NET

! Pour tester l'application 1. Exécutez l'application.

Les données de la table Titles doivent être chargées dans la grille de données.

2. Expliquez la fonctionnalité de la grille de données en utilisant les barres de défilement et en modifiant la largeur des colonnes.

Expliquez que le développement de cette application n'est pas terminé. Il convient à présent d'ajouter d'autres fonctionnalités de navigation, de personnaliser le formulaire pour qu'il soit conforme aux spécifications de conception professionnelle et d'ajouter un accès aux données propre à l'entreprise, ainsi que des fonctionnalités de mise à jour.

Le code de solution correspondant à cette démonstration est situé dans le dossier dossier_installation\Democode\Mod11\Solution.

Remarque

Code de solution

Module 11 : Utilisation d'ADO.NET 1

Vue d'ensemble

! Concepts des bases de données

! Présentationd'ADO.NET

! Utilisation des données

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


Ce module explique comment utiliser Microsoft® ADO.NET avec une application Microsoft Windows® Forms pour créer, lire, mettre à jour et supprimer des enregistrements dans des bases de données Microsoft SQL Server� et Microsoft Access (Jet 4.0).


! définir la terminologie élémentaire des bases de données, notamment les termes base de données, table, enregistrement, champ et clé ;

! décrire certains objets ADO.NET fréquemment utilisés ; ! créer et établir une connexion à une base de données ; ! créer, lire, mettre à jour et supprimer des enregistrements dans une base de

données ; ! utiliser l'Assistant Formulaire de données pour créer une application simple

d'accès aux données ; ! afficher et modifier les données extraites d'une base de données.

Introduction

Objectifs

2 Module 11 : Utilisation d'ADO.NET

Leçon : Concepts des bases de données

! Terminologie des bases de données

! Programmation pour l'accès aux bases de données

! Présentation de SQL

! Présentation d'un environnement connecté

! Présentation d'un environnement déconnecté


Cette leçon présente les concepts élémentaires des bases de données. Elle aborde le langage SQL (Structured Query Language) et explique la différence entre les environnements de données connectés et déconnectés.


! décrire les principaux éléments des bases de données, notamment une base de données, une table, un enregistrement, un champ et une clé ;

! expliquer la procédure globale d'accès aux données ; ! utiliser des instructions SQL simples ; ! expliquer la différence entre un environnement connecté et un

environnement déconnecté ; ! utiliser l'Explorateur de solutions pour afficher les éléments des bases de

données.


! Terminologie des bases de données ! Programmation pour l'accès aux bases de données ! Présentation de SQL ! Présentation d'un environnement connecté ! Présentation d'un environnement déconnecté ! Application pratique : Identification des scénarios d'environnements

connectés ou déconnectés

Introduction




Terminologie des bases de données

Employee IDEmployee IDEmployee ID

33Last nameLast nameLast name

SmallSmallFirst nameFirst nameFirst name

TonyTony

55 SmithSmith JamesJames

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.Products

Customers

Orders

Employees

Relations

Table Employees

Lignes(enregistrements)

Colonnes (champs)


Lorsque vous manipulez des bases de données, il est important de comprendre la terminologie élémentaire.

Les termes suivants sont définis dans le contexte des bases de données relationnelles.

! Base de données relationnelle Une base de données relationnelle est un type de base de données qui stocke les informations dans des tables. Les bases de données relationnelles utilisent les valeurs correspondantes issues de deux tables pour associer les données d'une table aux données de l'autre table. En général, dans une base de données relationnelle, vous stockez un type de données spécifique une seule fois.

! Table Une table est un objet de base de données qui stocke les données dans des enregistrements (lignes) et des champs (colonnes). Les données sont en principe liées à une catégorie spécifique ; par exemple, des employés ou des commandes.

! Enregistrement Un enregistrement est un ensemble de données relatives à une personne, un lieu, un événement ou un autre élément. Les enregistrements constituent les équivalents logiques des lignes dans une table. Par exemple, un enregistrement dans la table Employees contient des informations sur un type d'employés spécifique.

! Champ Un enregistrement est composé de plusieurs champs. Chaque champ d'un enregistrement contient une seule information sur l'enregistrement. Par exemple, un enregistrement Employee comprend des champs pour Employee ID, Last Name, First Name, etc.

Introduction

Définitions


! Clé primaire Une clé primaire identifie de manière unique chaque ligne dans une table. La clé primaire est un champ ou une combinaison de champs dont la valeur est unique pour chaque ligne (ou enregistrement) dans la table. Par exemple, le champ Employee ID est la clé primaire de la table Employees. Aucun employé n'a le même ID.

! Clé étrangère Une clé étrangère représente un ou plusieurs champs (colonnes) de la table qui font référence au(x) champ(s) de la clé primaire dans une autre table. Une clé étrangère indique la manière dont les tables sont liées.

! Relation Une relation est une association établie entre des champs (colonnes) communs dans deux tables. Une relation peut être de type un-à-un, un-à-plusieurs, ou plusieurs-à-plusieurs. Grâce aux relations, les résultats des requêtes peuvent inclure des données issues de plusieurs tables. Une relation un-à-plusieurs entre une table Customers et une table Orders permet à une requête de renvoyer toutes les commandes correspondant à un client donné.

! Accès en lecture seule Un accès en lecture seule à une base de données signifie que vous pouvez extraire (lire) les données mais que vous ne pouvez pas modifier (écrire dans) les données. Vous pouvez consulter et imprimer un fichier ou un document en lecture seule, mais vous ne pouvez pas le modifier.

! Accès en lecture/écriture Un accès en lecture/écriture à une base de données signifie que vous pouvez extraire (lire) les données et modifier (écrire dans) les données.


Programmation pour l'accès aux bases de données

Connexion à une base de données

Demande de données spécifiques

Retour des données

Transmission des mises à jour Base de données

Arrêt de la connexion

Dans de nombreuses applications, la connexion est arrêtée une foisque l'utilisateur a accédé aux données, puis elle est rétablie lorsquel'utilisateur transmet des mises à jour ou effectue d'autres demandes

Dans de nombreuses applications, la connexion est arrêtée une foisque l'utilisateur a accédé aux données, puis elle est rétablie lorsquel'utilisateur transmet des mises à jour ou effectue d'autres demandes

Tâches clés de la programmation pour l'accès aux bases de données

Affiche et modifie les données


Lorsque vous développez des applications, vos besoins en matière de données peuvent varier. Dans certains cas, vous souhaiterez simplement afficher des données sur un formulaire. Dans d'autres cas, vous aurez peut-être besoin de concevoir une méthode de partage des informations avec une autre société.

Lorsque vous manipulez des données, vous utilisez différents objets pour extraire et modifier les informations dans une base de données. En règle générale, vous effectuez les tâches suivantes lorsque vous travaillez avec des bases de données dans ADO.NET :

1. Connexion à une base de données. 2. Demande de données spécifiques.

Spécifiez les données que vous voulez extraire et indiquez si l'accès aux données doit être en lecture seule ou en lecture/écriture.

3. Extraction et affichage des données. 4. Arrêt de la connexion (dans certaines applications). 5. Modification des données extraites (si vous disposez d'un accès en

lecture/écriture). 6. Rétablissement de la connexion (dans certaines applications). 7. Retransmission à la base de données des modifications apportées aux

données. 8. Arrêt de la connexion.

Dans les leçons ultérieures de ce module, vous en apprendrez plus sur les outils et les objets que vous pouvez utiliser dans ADO.NET pour manipuler des données.

Introduction

Tâches clé de la programmation pour l'accès aux bases de données


Présentation de SQL

! Syntaxe des instructions SQL courantes" Pour spécifier les enregistrements spécifiques que vous souhaitez

extraire, utilisez la syntaxe suivante :SELECT Champ FROM Table

" Pour limiter la sélection des enregistrements, utilisez la syntaxesuivante :

SELECT * FROM Table WHERE Champ = "Chaîne"" Pour retourner des enregistrements dans l'ordre croissant, utilisez la

syntaxe suivante : SELECT * FROM Table ORDER BY Champ ASC

! Exemple

Définition : SQL est un langage qui est progressivementdevenu la norme en matière d'interrogation et de modification des données d'une base de données

Définition : SQL est un langage qui est progressivementdevenu la norme en matière d'interrogation et de modification des données d'une base de données

SELECT FirstName FROM EmployeesSELECT FirstName FROM Employees


Avant de pouvoir écrire une application qui utilise des données, vous devez vous familiariser avec le langage SQL (Structured Query Language). Ce langage vous permet de spécifier les enregistrements à extraire d'une base de données.

SQL est un langage qui est progressivement devenu la norme en matière d'interrogation et de modification des données d'une base de données.

SQL est défini par la norme ANSI (American National Standards Institute). Il existe diverses implémentations de SQL pour les différents moteurs de base de données. Par exemple, il existe une version de SQL pour les bases de données Microsoft Access (Jet 4.0) et une version pour SQL Server.

Le langage SQL vous permet de spécifier les enregistrements à extraire ainsi que l'ordre dans lequel vous souhaitez les extraire. Vous pouvez créer une instruction SQL qui extrait des informations de plusieurs tables simultanément, ou vous pouvez créer une instruction qui extrait uniquement un enregistrement donné.

L'instruction SELECT renvoie des champs spécifiques d'une ou de plusieurs tables dans une base de données. L'instruction suivante extrait le champ Prénom de tous les enregistrements dans la table Employees :

SELECT FirstName FROM Employees

Pour sélectionner tous les champs de la table, utilisez un astérisque (*), comme suit :

SELECT * FROM Employees

Introduction

Définition

Remarque

Instruction SELECT


Lorsque vous utilisez des instructions SQL dans Microsoft Visual Basic® .NET, vous devez insérer les instructions entre guillemets, comme l'illustre le code suivant :

Dim sqlString As String sqlString = "SELECT * FROM Employees"

Vous pouvez utiliser la clause WHERE pour limiter la sélection d'enregistrements en utilisant plusieurs champs pour filtrer les requêtes. Le code suivant indique comment utiliser la clause WHERE pour extraire tous les champs de tous les enregistrements pour lesquels le nom correspond à « Danseglio » dans la table Employees :

SELECT * FROM Employees WHERE LastName = 'Danseglio'

Il existe d'autres variantes de la clause WHERE, que vous pouvez utiliser pour affiner vos requêtes :

! Clause WHERE IN Vous pouvez utiliser la clause WHERE IN pour renvoyer tous les enregistrements qui répondent à certains critères. Par exemple, vous pouvez renvoyer les noms des employés à partir d'états sélectionnés, comme l'indique le code suivant : SELECT LastName FROM Employees WHERE Employees.State IN ('NY','WA')

! Clause WHERE BETWEEN

Vous pouvez également renvoyer une sélection d'enregistrements qui se situent entre deux critères spécifiés. Notez l'utilisation des signes # qui délimitent les dates dans le code suivant : SELECT OrderID FROM Orders WHERE OrderDate BETWEEN #01/01/93# AND #01/31/93#

! Clause WHERE LIKE

Vous pouvez utiliser la clause WHERE LIKE pour renvoyer tous les enregistrements pour lesquels il existe une condition particulière dans un champ donné. Par exemple, le code suivant indique comment renvoyer tous les enregistrements dans lesquels le nom commence par la lettre « D ». SELECT LastName FROM Employees WHERE LastName LIKE 'D%'

Vous pouvez utiliser la clause ORDER BY pour renvoyer les enregistrements dans un ordre particulier. L'option ASC indique un ordre croissant. Quant à l'option DESC, elle indique un ordre décroissant. Le code suivant renvoie tous les champs de la table Employees et les trie en fonction du nom :

SELECT * FROM Employees ORDER BY LastName ASC

Exemple dans Visual Basic .NET

Clause WHERE

Clause ORDER BY


Présentation d'un environnement connecté

! Un environnement connecté signifie qu'une application ou un utilisateur est constamment connecté à une source de données

! Avantages :

" Un environnement connecté est plus facile à gérer

" L'accès concurrentiel est plus facile à contrôler

" Les données sont plus à jour que dans les scénarios déconnectés

! Inconvénients :

" La connexion réseau doit être constamment maintenue

" Un scénario connecté offre une évolutivité limitée


Un environnement connecté signifie qu'une application ou un utilisateur est constamment connecté à une source de données. Depuis l'apparition de l'informatique, le seul environnement disponible était l'environnement connecté.

Les avantages d'un scénario connecté sont les suivants :

! Un environnement connecté est plus facile à gérer. ! L'accès concurrentiel est plus facile à contrôler. ! Les données sont plus à jour que dans les scénarios déconnectés.

Les inconvénients d'un scénario connecté sont les suivants :

! La connexion réseau doit être constamment maintenue. ! Un scénario connecté offre une évolutivité limitée.

Les exemples suivants présentent des scénarios dans lesquels une connexion constante peut être utilisée :

! Service de fabrication qui requiert une connexion en temps réel pour contrôler la production générée et le stockage.

! Maison de courtage qui requiert une connexion constante pour stocker les valeurs cotées.

Introduction

Avantages

Inconvénients

Exemples


Présentation d'un environnement déconnecté

! Un environnement déconnecté signifie que les données peuventêtre modifiées indépendamment et que les modifications sontécrites dans la base de données ultérieurement

! Avantages :

" Les connexions sont utilisées pour la plus courte durée possible. Ainsi, un plus petit nombre de connexions peut être utilisé pour un plus grand nombre d'utilisateurs

" Un environnement déconnecté améliore l'évolutivité et les performances des applications

! Inconvénients :

" Les données ne sont pas toujours à jour

" Des conflits de modification peuvent survenir et doivent être résolus


Lorsque l'Internet est apparu, les environnements déconnectés sont devenus monnaie courante, puis l'essor des périphériques portables a entraîné l'adoption quasi universelle des scénarios déconnectés. Les différents types d'ordinateurs portables vous permettent d'utiliser des applications lorsque vous êtes déconnecté des serveurs ou des bases de données.

Dans de nombreux cas, les personnes ne travaillent pas exclusivement dans un environnement connecté ou déconnecté, mais plutôt dans un environnement qui associe les deux approches.

Un environnement déconnecté signifie qu'une application ou un utilisateur n'est pas constamment connecté à une source de données. Les applications Internet utilisent souvent des architectures déconnectées. La connexion aux données est ouverte, les données sont extraites, puis la connexion est coupée. L'utilisateur travaille avec les données dans le navigateur et la connexion est ouverte de nouveau pour les mises à jour ou d'autres requêtes.

Les utilisateurs mobiles qui travaillent avec des ordinateurs portables sont également les principaux utilisateurs dans les environnements déconnectés. Les utilisateurs peuvent transférer un sous-ensemble de données sur un ordinateur déconnecté puis fusionner ultérieurement les modifications dans la banque de données centrale.

Les avantages d'un environnement déconnecté sont les suivants :

! Les connexions sont utilisées pour la plus courte durée possible. Ainsi, un plus petit nombre de connexions peut être utilisé pour un plus grand nombre d'utilisateurs.

! Un environnement déconnecté améliore l'évolutivité et les performances des applications en optimisant la disponibilité des connexions.

Introduction

Définition

Avantages


Les inconvénients d'un environnement déconnecté sont les suivants :

! Les données ne sont pas toujours à jour. ! Des conflits de modification peuvent survenir et doivent être résolus. ! La transmission des données peut être perçue comme étant plus lente que

dans les environnements connectés.

Les exemples suivants présentent des scénarios dans lesquels un environnement déconnecté peut être utilisé :

! Application qui gère les données des clients sur l'ordinateur portable d'un représentant commercial.

! Application qui effectue un suivi de la hauteur des précipitations. ! Application qu'un fermier utilise pour compter son bétail. L'application

figure sur le périphérique Windows CE qui exécute Microsoft SQL Server 2000 Édition Windows CE.

Dans la mesure où plusieurs utilisateurs peuvent modifier simultanément les données dans un environnement déconnecté, votre application doit gérer les conflits en termes de mise à jour des données. Il existe différentes méthodes pour gérer ces conflits :

! Autoriser la prédominance des mises à jour les plus récentes. ! Autoriser la prédominance des mises à jour les plus anciennes. ! Écrire du code qui autorise les utilisateurs à déterminer les modifications qui

doivent être conservées. Les solutions varieront en fonction des besoins de l'entreprise concernant une application donnée.

Pour plus d'informations sur la gestion des conflits, reportez-vous à la section « Contrôle d'accès concurrentiel dans ADO.NET » dans la documentation de Microsoft Visual Studio® .NET.

Inconvénients

Exemples

Gestion des mises à jour dans une application déconnectée

Remarque


Application pratique : Identification des scénarios d'environnements connectés ou déconnectés

! Dans cette application pratique, vous allezeffectuer les tâches suivantes :

" Examiner par groupe de deux cinq scénarios dans lesquels l'accès aux données est requis

" Choisir un environnement connecté ou déconnecté, en fonction des besoins de l'application

" Déterminer si l'accès aux données doit être en lecture seule ou en lecture/écriture


Dans cette application pratique, vous examinerez cinq scénarios avec un partenaire et vous indiquerez si les scénarios conviendraient mieux dans un environnement connecté ou dans un environnement déconnecté. Vous déterminerez également si le scénario requiert un accès en lecture seule ou en lecture/écriture.

1. Analysez chaque scénario. 2. Choisissez un environnement connecté ou déconnecté, en fonction des

besoins de l'application. 3. Déterminez si l'accès aux données doit être en lecture seule ou en

lecture/écriture.

Une société de placements a besoin d'un système qui autorisera les utilisateurs à recourir à Internet pour suivre leur portefeuille. La société doit fournir des services tels que des graphiques d'historique, des historiques de comptes, des informations de transactions individuelles et une analyse de placements.

Déconnecté, Lecture seule. Les clients accèderont uniquement aux données d'historique et n'effectueront pas les transactions actuelles sur Internet. _______________________________________________________________

_______________________________________________________________

Introduction

Instructions

Scénario 1


Un groupe de scientifiques mène une expérience qui implique un système devant stocker et afficher les données de 50 participants. L'application doit mesurer continuellement les réponses physiologiques aux stimuli qui sont coordonnés par chercheurs. L'expérience impose la contrainte suivante : les chercheurs doivent arrêter manuellement les stimuli pour une heure lorsque le système les avertit que 60 % des participants ont atteint un niveau 8 dans quatre des 10 mesures.

Connecté, lecture/écriture. Les totaux doivent intégrer les mises à jour continues des données, ce qui implique un environnement connecté. Le calcul des données issues des périodes récentes doit être intégré dans les niveaux actuels, ce qui implique l'écriture dans les données en plus de la lecture des données. ________________________________________________________________

________________________________________________________________

Un système doit être créé pour un service de retouche photo qui permet à ses utilisateurs de soumettre des photos scannées ou envoyées, d'effectuer le règlement sur Internet et de vérifier le statut de leurs commandes.

Déconnecté, lecture/écriture. La consultation des commandes est en lecture seule. La création des nouvelles commandes, notamment la soumission des photos est en lecture/écriture. ________________________________________________________________

________________________________________________________________

Un système doit être créé pour une équipe commerciale mobile. Chaque vendeur doit être en mesure de se connecter au réseau étendu du bureau (l'intranet de la société) et à Internet par le biais de périphériques de communication mobiles. Le vendeur est chargé de créer et de soumettre les commandes des clients dans le champ, après avoir vérifié la disponibilité du stock et la disponibilité de crédit appropriée. Il doit également suivre les livraisons aux clients et le statut des commandes, et envoyer des rapports quotidiens, qu'il puisse ou non établir une connexion à Internet. Le système indique que les crédits au stock, les déductions appropriées et les livraisons doivent avoir lieu deux fois par jour. Le vendeur doit pouvoir vérifier (mais pas modifier) le solde des comptes créditeurs des clients.

Déconnecté, accès en lecture/écriture pour le traitement des commandes, des livraisons et des données des stocks, même lors des connexions d'accès à distance sur des modems de téléphones portables. Accès en lecture seule aux informations de crédit des clients. ________________________________________________________________

________________________________________________________________

Scénario 2

Scénario 3

Scénario 4


Une société d'opérateurs financiers doit avoir accès aux données de trois différentes places boursières et à une base de données interne distincte qui suit les transactions des opérateurs pour le compte de leurs clients. La base de données interne reçoit continuellement des téléchargements des flux de données des places boursières. Les données des clients de chaque opérateur sont répliquées localement sur le disque dur de l'ordinateur personnel de l'opérateur. L'opérateur utilise ces données pour mettre à jour les comptes de deux ou trois clients, planifier les transactions prévisionnelles et effectuer ces transactions tous les jours. Quel environnement de données et quelles autorisations d'accès sont nécessaires entre les ordinateurs personnels des différents opérateurs et la base de données interne ?

Déconnecté, lecture/écriture. Les différents opérateurs peuvent obtenir des mises à jour instantanées des données des places boursières. Ce scénario nécessite un environnement déconnecté doté d'un accès en lecture seule. Les différents opérateurs et la base de données interne opèrent également dans un environnement déconnecté bénéficiant de mises à jour rapides, ce qui implique une fonctionnalité de lecture/écriture. _______________________________________________________________

_______________________________________________________________

Scénario 5


Leçon : Présentation d'ADO.NET

! Présentation d'ADO.NET

! Objets ADO.NET courants

! Utilisation des bases de données dans l'Explorateur de serveurs

! ADO.NET et XML


Cette leçon présente ADO.NET et décrit son rôle principal dans les applications qui utilisent des bases de données.


! décrire les composants clé de l'architecture ADO.NET ; ! expliquer comment manipuler des données en utilisant des objets dans le

modèle objet d'ADO.NET ; ! décrire la prise en charge de XML dans ADO.NET.


! Présentation d'ADO.NET ! Objets ADO.NET courants ! Démonstration : Utilisation de l'Explorateur de serveurs ! Utilisation des bases de données dans l'Explorateur de serveurs ! ADO.NET et XML ! Application pratique : Accès aux données en lecture seule

Introduction




Présentation d'ADO.NET


Quelles que soient les fins auxquelles sont destinées vos données, vous devez comprendre certains concepts fondamentaux concernant l'approche des données dans ADO.NET. Bien qu'il ne soit pas nécessaire de maîtriser tous les détails de la gestion des données, il est utile de comprendre l'architecture des données dans ADO.NET, la définition des principaux composants de données et l'intégration des différents éléments. Cette rubrique ne propose aucun détail complexe ; elle présente simplement les concepts liés à l'intégration des données dans ADO.NET.

Pour plus d'informations sur l'utilisation d'ADO.NET, reportez-vous au cours 2389 « Programming with ADO.NET » (en anglais).

ADO.NET est un ensemble de classes permettant la manipulation des données. Le modèle ADO.NET propose :

! un système conçu pour les environnements déconnectés ; ! un modèle de programmation qui inclut une prise en charge évoluée de

XML ; ! un ensemble de classes, d'interfaces, de structures et d'énumérations qui

gèrent l'accès aux données à partir de Microsoft .NET Framework.

Introduction

Remarque

Définition


Les composants d'ADO.NET permettent de séparer l'accès aux données et la manipulation des données. ADO.NET comprend deux composants principaux : le composant DataSet et les fournisseurs de données .NET. Les fournisseurs de données .NET disposent d'un ensemble de composants qui inclut les objets Connection, DataReader et DataAdapter. Les composants du fournisseur de données .NET sont conçus pour permettre la manipulation des données déconnectées.

ADO.NET et Windows Forms fournissent des composants de données que vous pouvez utiliser pour afficher vos données. Il s'agit des contrôles tels que DataGrid, qui peuvent être liés aux données, et des propriétés de liaison des données sur la plupart des contrôles Windows standard, tels que les contrôles TextBox, Label, ComboBox et ListBox.

.NET Framework inclut de nombreux fournisseurs de données .NET, notamment le fournisseur de données SQL Server .NET, le fournisseur de données OLE DB .NET pour SQL et le fournisseur de données OLE DB pour Microsoft Jet. Si vous avez besoin d'un fournisseur personnalisé, vous pouvez écrire les fournisseurs de données .NET pour n'importe quelle source de données. Ce module traite du fournisseur de données OLE DB .NET pour SQL.

Pour plus d'informations sur les fournisseurs de données inclus dans .NET, reportez-vous à la section « Utilisation de fournisseurs de données .NET pour l�accès aux données » dans la documentation de Visual Studio .NET. Pour plus d'informations sur la création de fournisseurs personnalisés, reportez-vous à la section « Fournisseurs de données .NET » dans la documentation de Microsoft Visual Studio® .NET.

Composants d'ADO.NET

Remarque


Objets ADO.NET courants

Base de données

ConnectionConnection

CommandCommand

DataSetDataSet DataReaderDataReader

DataAdapterDataAdapter

Gère la connexion à unebase de données

Exécute une commande de requête dans une base de données

Stocke les données dans un cache distinct de la base de données

Fournit un accès efficace à un flux de données en lecture seule

Échange des données entre le DataSet et la base de données


Les fournisseurs de données .NET et l'espace de noms System.Data fournissent les objets ADO.NET que vous utiliserez dans un scénario déconnecté.

ADO.NET offre un modèle objet commun pour les fournisseurs de données .NET. Le tableau suivant décrit les principaux objets ADO.NET que vous utiliserez dans un scénario déconnecté.

Objet Description

Connection Établit et gère une connexion à une source de données. Par exemple, la classe OleDbConnection établit une connexion aux sources de données OLE DB.

Command Exécute une commande à partir d'une source de données. Par exemple, la classe OleDbCommand peut exécuter des instructions SQL dans une source de données OLE DB.

DataSet Conçu pour un accès aux données indépendant de toute source de données. Par conséquent, vous pouvez l'utiliser avec différentes sources de données, avec des données XML, ou pour gérer des données locales à l'application. L'objet DataSet contient un ou plusieurs objets DataTable constitués de lignes et de colonnes de données, en plus des informations de clé primaire, de clé étrangère, de contrainte et de relations sur les données dans les objets DataTable.

DataReader Fournit un flux de données efficace, en avant et en lecture seule seulement issu d'une source de données.

DataAdapter Utilise les objets Connection, Command et DataReader implicitement pour charger un objet DataSet et pour mettre à jour la source de données centrale en intégrant les modifications apportées à l'objet DataSet. Par exemple, OleDbDataAdapter peut gérer l'interaction entre un objet DataSet et une base de données Access.

Introduction

Objets ADO.NET


Démonstration : Utilisation de l'Explorateur de serveurs

! Dans cette démonstration, vous apprendrez à utiliser l'Explorateur de serveurs pour ajouter des connexions de bases de données et pour afficher des éléments de bases de données tels que des tables


Dans cette démonstration, vous apprendrez à utiliser l'Explorateur de serveurs pour ajouter des connexions de bases de données et pour afficher des éléments de bases de données tels que des tables.


Utilisation des bases de données dans l'Explorateur de serveurs


Vous pouvez utiliser l'Explorateur de serveurs pour visualiser et manipuler des liaisons de données, des connexions de base de données et des ressources système sur n'importe quel serveur offrant un accès réseau. L'Explorateur de serveurs vous permet d'effectuer les opérations suivantes :

! créer et ouvrir des connexions de données à Access et à des serveurs exécutant SQL Server et d'autres bases de données ;

! se connecter à des serveurs et afficher leurs bases de données, leurs tables, leurs champs et leurs données sans quitter l'environnement de développement ou utiliser le logiciel de base de données ;

! afficher les services système, notamment les journaux d'événements, les files d'attente de messages, les compteurs de performance et les services système ;

! afficher les informations disponibles sur les services Web XML et les méthodes et les schémas qu'ils fournissent ;

! stocker les projets et les références de base de données ; ! créer des composants de données qui référencient la ressource de données

ou contrôlent son activité en déplaçant les n�uds de l'Explorateur de serveurs vers vos projets Visual Studio .NET ;

! interagir avec les ressources de données en programmant les composants de données que vous avez créés dans vos projets Visual Studio .NET.

Introduction


Vous pouvez ouvrir l'Explorateur de serveurs à tout moment du processus de développement, tout en travaillant avec n'importe quel type de projet ou d'élément.

! Pour ouvrir l'Explorateur de serveurs •••• Dans le menu Affichage, cliquez sur Explorateur de serveurs.

� Ou � •••• Si l'onglet Explorateur de serveurs s'affiche sur le côté gauche de l'écran,

sélectionnez-le.

L'Explorateur de serveurs affiche les connexions de base de données en dessous du n�ud Connexions de données. Une fois votre première connexion établie, vous pouvez concevoir des programmes pour ouvrir d'autres connexions, puis extraire et manipuler les données fournies. Par défaut, l'Explorateur de serveurs affiche les connexions et les liaisons de données aux serveurs précédemment utilisés.

! Pour ajouter une connexion de données dans l'Explorateur de serveurs 1. Dans le menu Outils, cliquez sur Se connecter à une base de données.

La boîte de dialogue Propriétés des liaisons de données apparaît. 2. Dans l'onglet Fournisseur de la boîte de dialogue Propriétés des liaisons

de données, sélectionnez un fournisseur. 3. Dans l'onglet Connexion de la boîte de dialogue Propriétés des liaisons de

données, fournissez les informations requises. Les champs d'entrée qui s'affichent varient selon le fournisseur choisi dans l'onglet Fournisseur. Par exemple, si vous sélectionnez le Fournisseur OLE DB de SQL Server, l'onglet Connexion affiche des champs relatifs au nom du serveur, au type d'authentification et à la base de données.

4. Cliquez sur OK pour établir la connexion de données. La boîte de dialogue Propriétés des liaisons de données se ferme et les nouvelles connexions de données s'affichent en dessous du n�ud Connexions de données renommé en fonction du serveur et de la base de données auxquels vous avez accédé. Par exemple, si vous créez une connexion de données à une base de données appelée Nwind sur un serveur appelé Serveur1, une nouvelle connexion intitulée Serveur1.NWind.dbo apparaît en dessous du n�ud Connexions de données.

! Pour supprimer une connexion de données dans l'Explorateur de serveurs

1. À partir de l'Explorateur de serveurs, développez le n�ud Connexions de données.

2. Sélectionnez la connexion à la base de données souhaitée. 3. Appuyez sur SUPPR.

Cette opération n'a aucune conséquence sur la base de données. Vous supprimez simplement sa référence dans votre affichage.

Ouverture de l'Explorateur de serveurs

Ajout et suppression de connexions de données


Vous pouvez faire glisser des éléments de l'Explorateur de serveurs et les déplacer vers le Concepteur Windows Forms. Ce déplacement permet de créer de nouvelles ressources de données préconfigurées en vue d'extraire des informations de la source de données sélectionnée.

! Pour créer un nouveau composant de données avec l'Explorateur de serveurs

Vous pouvez créer un composant de données préconfiguré pour référencer une ressource particulière. 1. En mode Design, ouvrez le formulaire auquel vous souhaitez ajouter un

composant de données. 2. Dans l'Explorateur de serveurs, sélectionnez l'élément de données à

utiliser. Il peut s'agir, par exemple, d'un champ ou d'une table. 3. Faites glisser l'élément de l'Explorateur de serveurs vers la surface du

concepteur.

Vous pouvez faire appel à l'Explorateur de serveurs pour afficher et extraire des informations de toutes les bases de données installées sur le serveur. Vous pouvez y répertorier des tables de bases de données, des vues, des procédures stockées et des fonctions, développer des tables individuelles pour répertorier leurs colonnes et leurs déclencheurs, et cliquer avec le bouton droit sur une table pour sélectionner le Concepteur de tables à partir du menu contextuel.

Glissement-déplacement des ressources de données

Affichage des éléments de la base de données


ADO.NET et XML

! ADO.NET est intégré étroitement à XML

Exemple d'utilisation de XML dans une application ADO.NET déconnectée

Services Web XML

DataSetDataSet

Demande de données111

Requête SQL222

Résultats333XML444

XML mis à jour555Mises à jour SQL

666

Source de donnésClient

DataSetDataSet


ADO.NET collabore étroitement avec XML. Il vous permet ainsi de facilement convertir des données relationnelles au format XML. Vous pouvez également convertir des données XML en tables et en relations.

XML propose un format de représentation utile et portable des données dans un environnement ouvert et indépendant de toute plate-forme. Une des caractéristiques essentielles des données XML est qu'elles sont fondées sur du texte. L'utilisation des données texte, par opposition au transfert de données binaires telles que les jeux d'enregistrements (RecordSet) ADO, facilite le transfert de données XML entre des applications et des services, même s'ils fonctionnent sur différentes plates-formes. XML permet également à des organisations d'échanger des données sans avoir à personnaliser davantage chacun de leur logiciel propriétaire.

Le modèle objet ADO.NET permet une prise en charge optimale du format XML. Tenez compte des remarques et des instructions suivantes lors de l'utilisation de XML dans ADO.NET :

! Vous pouvez lire les données d'un DataSet (groupe de données) au format XML. Ce format peut s'avérer utile si vous souhaitez transmettre des données entre diverses applications ou services dans un environnement distribué.

! Vous pouvez remplir un DataSet avec des données XML. Cette option peut être utile si vous recevez des données XML d'une autre application ou d'un autre service et souhaitez mettre à jour une base de données à l'aide de ces données.

! Vous pouvez créer un schéma XML illustrant la représentation XML des données dans un DataSet. Ce même schéma XML peut également servir pour la réalisation de diverses tâches telles que la sérialisation des données XML dans un flux ou un fichier.

Introduction

Utilisation primordiale de XML

Prise en charge XML


! Vous pouvez charger les données XML d'un flux ou d'un fichier dans une arborescence DOM (Document Object Model). Vous pouvez ensuite manipuler les données sous forme de données XML ou de DataSet. Pour cela, vous devez disposer d'un schéma XML décrivant la structure des données du DataSet.

! Vous pouvez créer des DataSet (groupes de données) typés. Un DataSet typé constitue la sous-classe d'un DataSet. Des propriétés et des méthodes y ont été ajoutées pour rendre les fonctionnalités du DataSet disponibles. Pour décrire une représentation XML du DataSet typé, Visual Studio génère une définition de schéma XML équivalente pour ce DataSet.

Cet exemple explique comment utiliser XML dans une application ADO.NET déconnectée. Vous pouvez utiliser XML pour transmettre des données entre diverses parties du système en suivant la procédure suivante :

1. L'application cliente appelle un service Web XML pour demander les données d'une base de données.

2. Le service Web XML interroge une source de données pour obtenir les données demandées.

3. Le service Web XML charge les résultats dans un DataSet. 4. Le service Web XML convertit les données au format XML et renvoie les

données XML à l'application cliente. 5. L'application cliente traite les données XML d'une manière ou d'une autre.

Par exemple, le client peut charger les données XML dans un DataSet et les lier à un contrôle de l'interface utilisateur, tel que DataGrid. Dès que l'application cliente est prête, elle appelle un service Web XML pour mettre à jour la source de données avec les modifications apportées aux données.

6. Le service Web XML charge les nouvelles données XML dans un DataSet et les utilise pour mettre à jour la source de données.

Pour plus d'informations sur la manière de remplir un DataSet avec un flux XML, reportez-vous à la section « XML et le DataSet » dans la documentation Visual Studio .NET. Pour plus d'informations sur la manière d'obtenir des données au format XML à partir d'un serveur SQL, reportez-vous à la section « Obtention de données au format XML à partir de SQL Server » dans la documentation Visual Studio .NET.

Exemple d'utilisation de XML dans une application déconnectée

Remarque


Application pratique : Accès aux données en lecture seule

! Dans cette application pratique vous allezeffectuer les tâches suivantes :1. Démarrer une nouvelle application Windows Forms2. Choisir le type de connexion et la base de données3. Ajouter les objets Connection et DataAdapter au

formulaire4. Générer le DataSet5. Ajouter un contrôle DataGrid au formulaire et

définir ses propriétés6. Utiliser la méthode Fill pour remplir le DataSet7. Exécuter l'application pour afficher des données en

lecture seule


Au cours de cette application pratique, vous ouvrirez un nouveau projet et utiliserez la fonctionnalité glisser-déplacer de l'Explorateur de serveurs pour créer un groupe de données et remplir une grille de données avec des données en lecture seule.

Cette application pratique porte sur les concepts évoqués dans cette leçon. Elle risque, en conséquence, de ne pas être conforme aux recommandations de sécurité énoncées par Microsoft. Par exemple, cette application pratique, contrairement aux recommandations officielles, ne conseille pas l'utilisation de comptes d'utilisateurs individuels (plutôt que des comptes d'administrateurs) ni celle de mots de passe sécurisés pour tous les comptes.

! Pour créer un nouveau projet 1. Démarrez un nouveau projet Visual Basic .NET à partir du modèle

d'application Windows. 2. Nommez le projet PubsDataGrid, définissez l'emplacement du dossier à

dossier_installation\Practices\Mod11, puis cliquez sur OK.

! Pour ajouter les objets Connection et DataAdapter au formulaire 1. Dans l'Explorateur de serveurs, sous Serveurs, développez successivement

le n�ud nom_ordinateur (London pour l'instructeur), le n�ud Serveurs SQL, puis le n�ud nom_ordinateur/NetSDK afin que toutes les bases de données SQL disponibles sur votre ordinateur s'affichent.

2. Développez le n�ud de la base de données Pubs, puis le n�ud Tables sous Pubs.

Introduction

Remarque

Instructions


3. Faites glisser la table Authors vers Form1. Lorsque vous faites glisser la table vers le formulaire, les objets SqlConnection1 et SqlDataAdapter1 sont créés, puis ajoutés à la barre d'état des composants.

4. Dans la fenêtre Propriétés, modifiez la propriété Name de l'objet SqlConnection1 à PubsConn, puis la propriété Name de l'objet SqlDataAdapter1 à PubsSqlDataAdapter.

5. Développez la propriété InsertCommand de PubsSqlDataAdapter. Assurez-vous que la propriété Connection est définie à PubsConn. Notez que les objets DataAdapter et Connection que vous venez d'ajouter sont déjà connectés l'un à l'autre.

! Pour générer le DataSet de la table Authors 1. À partir de la fenêtre Propriétés, dans la zone de description en bas de la

liste des propriétés, cliquez sur Générer le groupe de données. 2. Dans la boîte de dialogue Générer le groupe de données, tapez

PubsDataSet dans la zone de texte Nouveau. 3. Conservez les valeurs par défaut dans toutes les autres zones de texte.

Cliquez sur OK. PubsDataSet1 doit apparaître dans la barre d'état des composants.

! Pour ajouter un DataGrid dans le formulaire et définir ses propriétés 1. À partir de l'onglet Windows Forms de la boîte à outils, ajoutez un contrôle

DataGrid au formulaire. 2. Dans la fenêtre Propriétés, renommez le contrôle DataGrid à

PubsDataGrid. 3. Dans la fenêtre Propriétés, définissez la propriété DataSource du contrôle

PubsDataGrid à PubsDataSet1, puis la propriété DataMember à Authors.

4. Redimensionnez le formulaire et le contrôle DataGrid afin d'afficher l'ensemble des lignes et des colonnes. La grille de données doit afficher les noms des champs de la table Authors.

! Pour remplir le DataSet à l'aide des données de la table Authors •••• Ouvrez un gestionnaire d'événements pour l'événement Form1_Load. Dans

le gestionnaire d'événements Form1_Load, appelez la méthode Fill de l'adaptateur de données pour remplir la table Authors à l'aide de données. Votre code doit se présenter comme suit : PubsSqlDataAdapter.Fill(PubsDataSet1)


! Pour tester l'application 1. Exécutez l'application.

Les données Authors doivent remplir la grille de données. 2. Parcourez les données à l'aide des barres de défilement de la grille de

données.

Bien que vous ayez créé une application de travail capable d'afficher les données en lecture seule d'une source de données, ses fonctionnalités restent limitées. Par exemple, seules les barres de défilement de la grille de données permettent de naviguer d'un élément à un autre. Dans une application réelle, vous voudriez sans doute modifier la sélection des champs à afficher. Pour ajouter davantage de fonctionnalités à votre formulaire, vous pourriez autoriser les utilisateurs à afficher des détails sur le produit. Vous pourriez aussi leur permettre de sélectionner un élément, de passer à un autre formulaire héritant des données du formulaire en cours, puis de créer une commande ou d'afficher des commandes existantes.

Les fichiers solution de cette application pratique sont disponibles à partir du dossier dossier_installation\Practices\Mod11\Solution.

Remarque

Fichiers solution


Leçon : Utilisation des données

! Utilisation d'un objet Connection

! Utilisation d'un objet DataAdapter

! Utilisation d'un objet DataSet

! Utilisation d'un contrôle DataGrid

! Utilisation de l'Assistant Formulaire de données


ADO.NET fournit tous les composants nécessaires à la connexion à des sources de données et à l'utilisation de données dans vos applications. Au cours de cette leçon, vous apprendrez à utiliser des objets ADO.NET pour vous connecter à une base de données, extraire des données, les modifier et retransmettre des données mises à jour à la base de données. Vous apprendrez également à afficher des données dans un formulaire Windows Forms à l'aide du contrôle DataGrid. Enfin, vous apprendrez à utiliser l'Assistant Formulaire de données pour automatiser le processus de manipulation des données. L'assistant regroupe en quelques étapes faciles la tâche consistant à ajouter des contrôles et à définir des propriétés.


! établir une connexion à une source de données à l'aide de l'objet Connection ;

! extraire les données d'une source de données à l'aide des objets DataAdapter et DataSet ;

! transmettre des mises à jour à une source de données à l'aide des objets DataAdapter et DataSet ;

! utiliser un contrôle DataGrid pour afficher les données ; ! utiliser l'Assistant Formulaire de données pour ajouter un nouveau

formulaire dépendant à un projet.


! Utilisation d'un objet Connection ! Utilisation d'un objet DataAdapter ! Utilisation d'un objet DataSet ! Utilisation d'un contrôle DataGrid ! Utilisation de l'Assistant Formulaire de données

Introduction




Utilisation d'un objet Connection

! L'objet Connection vous permet d'effectuer les tâchessuivantes :

" Choisir le type de connexion

" Spécifier la source de données

" Ouvrir la connexion à la source de données

" Fermer la connexion à la source de données

! Exemple de connexion à une base de données SQL Server

Dim PubsSQLConn As SqlClient.SqlConnectionPubsSQLConn = New SqlClient.SqlConnection( )PubsSQLConn.ConnectionString = "Integrated Security=True;" & _

"Data Source=local;Initial Catalog=Pubs;"PubsSQLConn.Open( )

Dim PubsSQLConn As SqlClient.SqlConnectionPubsSQLConn = New SqlClient.SqlConnection( )PubsSQLConn.ConnectionString = "Integrated Security=True;" & _

"Data Source=local;Initial Catalog=Pubs;"PubsSQLConn.Open( )


Pour travailler avec des données, vous devez d'abord établir une connexion avec une source de données. Pour vous connecter à une source de données, choisissez le type de connexion, spécifiez la source de données, puis ouvrez la connexion à la source de données. Lorsque vous avez fini de manipuler les données, fermez la connexion.

Vous pouvez utiliser l'objet Connection pour vous connecter à une source de données spécifique. Vous pouvez utiliser l'objet SqlConnection pour vous connecter aux bases de données SQL Server ou l'objet OleDbConnection pour vous connecter à d'autres types de sources de données.

Après avoir choisi le type de connexion, utilisez la propriété ConnectionString pour spécifier le fournisseur de données, la source de données et d'autres informations nécessaires à l'établissement de la connexion. Le format de ces chaînes diffère légèrement dans les espaces de noms SqlClient et OleDb.

L'objet Connection prend en charge une méthode Open qui ouvre la connexion lorsque les propriétés de connexion ont été définies et une méthode Close qui ferme la connexion à la base de données lorsque toutes les transactions sont terminées.

Introduction

Sélection du type de connexion

Définition de la source de données

Ouverture et fermeture de la connexion de données


L'exemple ci-dessous explique comment utiliser un objet Connection, une propriété ConnectionString et la méthode Open pour se connecter à une base de données SQL Server à l'aide du fournisseur de données SQL Server .NET :

Dim PubsSQLConn As SqlClient.SqlConnection PubsSQLConn = New SqlClient.SqlConnection( ) PubsSQLConn.ConnectionString = "Integrated Security=True;" & _ "Data Source=local;Initial Catalog=Pubs;" PubsSQLConn.Open( )

L'exemple suivant explique comment se connecter à une base de données Access à l'aide du fournisseur de données Jet 4.0 OLE DB :

Dim NWindOleDbConn As OleDb.OleDbConnection NWindOleDbConn = New OleDb.OleDbConnection( ) NWindOleDbConn.ConnectionString = _ "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\NWind.MDB" NWindOleDbConn.Open( )

Exemple SQL

Exemple Jet 4.0


Utilisation d'un objet DataAdapter

! Pour créer un objet DataAdapter" Déclarez l'objet DataAdapter à l'aide du mot clé Dim" Passez une chaîne de requête et un objet Connection

en tant que paramètres

! Méthodes clés de DataAdapter :" La méthode Fill remplit un groupe de données" La méthode Update transmet les modifications à la

banque de données

Dim PubsAdapter As SQLDataAdapter = New SQLDataAdapter _("Select * from Titles", PubsSQLConn)

Dim PubsAdapter As SQLDataAdapter = New SQLDataAdapter _("Select * from Titles", PubsSQLConn)


Après avoir établi une connexion à une source de données, vous pouvez utiliser un adaptateur de données pour échanger des données entre la source de données et un groupe de données. Pour de nombreuses applications, cela revient à lire les données d'une base de données dans un groupe de données à l'aide de l'adaptateur de données, puis à écrire les données modifiées du groupe de données dans l'adaptateur de données, puis à nouveau vers la base de données. Néanmoins, un adaptateur de données peut déplacer des données entre n'importe quelle source de données et un groupe de données. Il peut s�agir, à titre d'exemple, d'un adaptateur capable de déplacer des données entre un serveur utilisant Microsoft Exchange et un groupe de données.

Visual Studio propose deux adaptateurs de données principaux à utiliser dans le cadre des bases de données :

! OleDbDataAdapter convient à toute situation impliquant la présence d'une source de données provenant d'un fournisseur OLE DB.

! SqlDataAdapter est propre à SQL Server. Le passage par une couche OLE DB n'étant pas obligatoire, il s'avère plus rapide que l'adaptateur OleDbDataAdapter. En revanche, il est compatible uniquement avec la version 7.0 (ou ultérieure) de SQL Server.

Vous pouvez instancier l'objet DataAdapter à l'aide du mot clé Dim et en passant une chaîne de requête et un objet Connection en tant que paramètres. DataAdapter vérifie si l'objet Connection est ouvert. Dans le cas contraire, il l'ouvre, puis le referme automatiquement lorsque votre appel de méthode est terminé. Cette approche est utile si vous avez déjà défini les propriétés d'un objet Connection dans votre application et devez uniquement ouvrir la connexion pour renseigner les tables de données.

Introduction

Types d'adaptateurs de données

Création de DataAdapter


Les exemples ci-après illustrent la procédure de création d'une instance de la classe Sql Client DataAdapter. Le code destiné à la création d'une instance de la classe DataAdapter apparaît en gras.

L'exemple ci-dessous explique comment accéder à la table Titles dans la base de données Pubs :

Dim PubsSQLConn As SqlClient.SqlConnection PubsSQLConn = New SqlClient.SqlConnection( ) PubsSQLConn.ConnectionString = "Integrated Security=True;" & _ "Data Source=local;Initial Catalog=Pubs;" Dim PubsAdapter As SQLDataAdapter = New SQLDataAdapter _ ("Select * from Titles", PubsSQLConn) ' Code permettant de remplir le groupe de données Dim titlesDataset As DataSet = New DataSet PubsAdapter.Fill(titlesDataset) ' Entrer ici le code permettant de lier le groupe de données ' aux contrôles du formulaire

L'exemple ci-dessous explique comment accéder à la table Customers dans la base de données Northwind à l'aide du fournisseur OLE DB pour Microsoft Jet :

Private NWindOleDbConn as OleDb.OleDbConnection Private Sub Form1_Load(...) Handles MyBase.Load NWindOleDbConn = New OleDb.OleDbConnection( ) NWindOleDbConn.ConnectionString = "Provider= " & _ "Microsoft.Jet.OLEDB.4.0;Data Source=c:\NWind.mdb" Dim NWindAdapter As New OleDb.OleDbDataAdapter _ ("Select * from Customers", NWindOleDbConn) ' Entrer ici le code permettant de remplir le DataSet ' Entrer ici le code permettant de lier le DataSet aux ' contrôles du formulaire

Exemples

Exemple SQL

Exemple Jet 4.0


DataAdapter utilise des méthodes précises pour contrôler le va-et-vient des données entre le groupe et la source de données. Vous pouvez utiliser un adaptateur de données pour mener à bien les opérations suivantes :

! Extraire les lignes d'une banque de données et les transférer dans les tables de données correspondantes d'un groupe de données. Pour extraire les lignes d'une banque de données et les utiliser pour remplir un groupe de données, utilisez la méthode Fill de SqlDataAdapter ou OleDbDataAdapter. Lorsque vous l'appelez, cette méthode lève une instruction SQL SELECT dans la banque de données. L'exécution de la méthode entraîne l'ouverture et la fermeture de l'objet Connection.

! Transmettre les modifications apportées à la table du groupe de données à la banque de données correspondante. Pour cette opération, faites appel à la méthode Update de l'adaptateur. Lorsque vous l'appelez, cette méthode exécute l'instruction requise (SQL INSERT, UPDATE ou DELETE) conformément à l'état de l'enregistrement concerné (nouvel enregistrement ou enregistrement modifié ou supprimé). L'exécution de la méthode entraîne l'ouverture et la fermeture de l'objet Connection.

' Entrer le code permettant de manipuler localement les ' données à l'aide du DataSet ici ' Mettre à jour la base de données à l'aide de l'adaptateur ' de données PubsAdapter.Update (PubsDataSet)

' Créer l'objet Connection, le DataAdapter et le DataSet, ' puis remplir le groupe de données Dim NWindConn As OleDb.OleDbConnection NWindConn = New OleDb.OleDbConnection( ) NWindConn.ConnectionString = "Provider= " & _ "Microsoft.Jet.OLEDB.4.0;Data Source=c:\NWind.mdb" Dim NWindAdapt As New OleDb.OleDbDataAdapter("SELECT * " & _ "from Customers", NWindConn) Dim NWindDataSet As DataSet = New DataSet( ) NWindAdapt.Fill(NWindDataSet, "customersTable") ' Entrer le code permettant de manipuler localement les ' données à l'aide du DataSet ici ' Mettre à jour la base de données à l'aide de l'adaptateur ' de données NWindAdapt.Update (NWindDataSet.Tables("customersTable"))

Méthodes clés

Exemple

Exemple Jet 4.0


Utilisation d'un objet DataSet

! Fonctionnement des objets DataSet" Stockent les données dans un cache de données

déconnecté" Utilisent un modèle objet hiérarchique constitué de

tables, de lignes et de colonnes! Vous pouvez remplir un DataSet en :

" Utilisant la méthode Fill" Remplissant manuellement les tables" Lisant un document XML ou un flux" Fusionnant ou en copiant le contenu d'un autre DataSet


Après avoir spécifié les données que vous souhaitez extraire, votre étape suivante consiste à remplir un groupe de données à l'aide des données figurant dans la base de données. Les groupes de données stockent les données dans un cache de données déconnecté. Leur structure ressemble à celle d'une base de données relationnelle. Un groupe de données offre un modèle objet hiérarchique constitué de tables, de lignes et de colonnes. Il est également composé de contraintes et de relations définies pour lui.

Un groupe de données est un conteneur et doit, à ce titre, être rempli de données. Plusieurs méthodes vous permettent de remplir un groupe de données :

! Recours à la méthode Fill d'un adaptateur de données. Lorsque vous appelez cette méthode, l'adaptateur exécute automatiquement une instruction SQL ou une procédure stockée et remplit une table du groupe de données à l'aide des résultats obtenus. Si le groupe de données contient plusieurs tables, c'est que vous disposez sans doute d'adaptateurs de données séparés pour chaque table et devez, par conséquent, appeler séparément la méthode Fill de chacun de ces adaptateurs.

! Remplissage manuel des tables dans un groupe de données via la création de valeurs DataRow et l'ajout de ces valeurs à la collection Rows de la table. Vous pouvez effectuer cette opération au moment de l'exécution. Vous ne pouvez pas définir la collection Rows au moment du design.

! Lecture d'un document ou d'un flux XML dans le groupe de données. ! Copie du contenu d'un autre groupe de données. Cette technique peut être

utile si votre application récupère des groupes de données de différentes sources (par exemple, des services Web XML distincts) mais doit les placer dans un unique groupe de données.

Introduction

Remplissage des groupes de données


Vous utilisez un objet DataAdapter pour accéder aux données stockées dans une base de données, puis stocker ces données dans les objets DataTable figurant dans un DataSet de votre application.

Les instructions présentées en caractères gras dans l'exemple ci-dessous expliquent comment remplir un DataSet, appelé PubsDataset, avec les données d'une base de données SQL à l'aide d'un DataAdapter. Il existe une seule table et le groupe de données s'y réfère via un numéro d'index. La commande Update utilise la même table pour mettre à jour la base de données suite aux modifications apportées.

' Créer l'objet Connection, le DataAdapter et le DataSet, ' puis remplir le groupe de données Dim PubsSQLConn As SqlClient.SqlConnection PubsSQLConn = New SqlClient.SqlConnection( ) PubsSQLConn.ConnectionString = "Integrated Security=True;" & _ "Data Source=local;Initial Catalog=Pubs;" Dim PubsAdapter As SQLDataAdapter = New SQLDataAdapter _ ("Select * from Authors", PubsSQLConn) Dim PubsDataSet As DataSet = New DataSet( ) PubsAdapter.Fill(PubsDataSet) ' Entrer le code permettant de manipuler localement les ' données à l'aide du DataSet ici ' Mettre à jour la base de données à l'aide de l'adaptateur ' de données PubsAdapter.Update (PubsDataSet.Tables("authorsTable"))

Exemple

Exemple SQL


Les instructions présentées en caractères gras dans l'exemple ci-dessous expliquent comment remplir un DataSet, appelé NWindDataSet, avec les données d'une base de données OLE DB à l'aide d'un DataAdapter.

' Créer l'objet Connection, le DataAdapter et le DataSet, ' puis remplir le groupe de données : Dim NWindConn As OleDb.OleDbConnection NWindConn = New OleDb.OleDbConnection( ) NWindConn.ConnectionString = "Provider= " & _ "Microsoft.Jet.OLEDB.4.0;Data Source=c:\NWind.mdb" Dim NWindAdapt As New OleDb.OleDbDataAdapter("SELECT * " & _ "from Customers", NWindConn) Dim NWindDataSet As DataSet = New DataSet( ) NWindAdapt.Fill(NWindDataSet) ' Entrer le code permettant de manipuler localement les ' données à l'aide du DataSet ici ' Mettre à jour la base de données à l'aide de l'adaptateur ' de données NWindConn.Open( ) NWindAdapt.Update (NWindDataSet) NWindConn.Close( )

Exemple Jet 4.0


Utilisation d'un contrôle DataGrid

! Utilisez un contrôle DataGrid pour afficher les donnéesissues d'une seule ou de plusieurs sources de données" À l'aide de la boîte à outils, ajoutez un contrôle DataGrid à

un formulaire" Définissez les propriétés du contrôle DataGrid


Après avoir rempli un groupe de données, vous pouvez visualiser et modifier les données à l'aide du contrôle DataGrid de Windows Forms. Le contrôle DataGrid affiche les données sous la forme d'une série de lignes et de colonnes. Dans le cas le plus simple, la grille est liée à une source de données constituée d'une seule table ne contenant aucune relation. Les données apparaissent alors sous la forme de simples lignes et de simples colonnes, tout comme dans une feuille de calcul.

Si le contrôle DataGrid est lié à des données composées de plusieurs tables connexes et si vous activez la fonction de navigation dans la grille, cette dernière affiche des boutons de développement à chaque ligne. Un bouton de développement permet de naviguer entre une table parente et une table enfant. La table enfant s'affiche lorsque vous cliquez sur un n�ud ; la table parente apparaît lorsque vous cliquez sur le bouton Précédent. De cette manière, la grille dévoile les relations hiérarchiques qui relient les tables.

Le contrôle DataGrid offre une interface utilisateur au groupe de données, des fonctions de navigation entre les tables connexes ainsi que des fonctions d'édition et de mise en forme élaborée.

L'affichage et la manipulation des données sont l'objet de fonctions distinctes. Le contrôle gère l'interface utilisateur mais les mises à jour des données sont gérées par l'architecture de liaison des données Windows Forms et par les fournisseurs de données ADO.NET. C'est pourquoi plusieurs contrôles liés à la même source de données restent synchronisés.

Pour permettre au contrôle DataGrid de fonctionner, vous devez le lier à une source de données à l'aide des propriétés DataSource et DataMember au moment du design ou de la méthode SetDataBinding au moment de l'exécution. Cette opération lie le contrôle DataGrid à un objet source de données instancié (tel que DataSet ou DataTable) et le met à jour avec les résultats des actions menées sur les données.

Vous ne pouvez pas utiliser le contrôle DataGrid pour effectuer des actions propres aux données. Seule la source de données vous le permet.

Introduction

Utilisation du contrôle DataGrid

Liaison des données au contrôle


! Pour lier le contrôle DataGrid à une seule table dans le concepteur 1. Définissez la propriété DataSource du contrôle à l'objet contenant les

éléments de données avec lesquels vous souhaitez établir une liaison. 2. Si la source de données est un groupe de données, définissez la propriété

DataMember au nom de la table avec laquelle vous souhaitez établir une liaison.

3. Si la source de données est un groupe de données ou une vue des données fondée sur la table du groupe de données, ajoutez du code au formulaire pour remplir le groupe de données.

La liaison simple vous permet de lier un contrôle à un champ unique dans un DataSet. Par exemple, ce mode peut être utilisé pour un contrôle TextBox ou un contrôle Label. Vous pouvez spécifier le DataSet et le champ à lier à une propriété à l'aide de la propriété DataBinding d'un contrôle associé aux données.

L'exemple suivant illustre la liaison de données à un contrôle TextBox :

Dim PubsSQLConn As SqlClient.SqlConnection PubsSQLConn = New SqlClient.SqlConnection( ) PubsSQLConn.ConnectionString = "Integrated Security=True;" & _ "Data Source=local;Initial Catalog=Pubs;" PubsSQLConn.Open( ) Dim PubsAdapter As SQLDataAdapter = New SQLDataAdapter _ ("Select * from Titles", PubsSQLConn) Dim PubsDataSet As DataSet = New DataSet( ) PubsAdapter.Fill(PubsDataSet) TextBox1.DataBindings.Add(New Binding("Text", _ PubsDataSet, "Authors.FirstName"))

Le code du contrôle TextBox ne change pas lorsque vous utilisez un fournisseur Jet 4.0. Seul le code des objets Connection et DataAdapter change, comme le confirment les exemples précédents.

La liaison complexe vous permet de lier un contrôle à plusieurs champs dans un DataSet. Par exemple, vous utilisez ce mode pour un contrôle DataGrid. Vous pouvez spécifier la table à utiliser à l'aide de la propriété DataSource de ce contrôle.

Liaison simple

Exemple SQL

Exemple Jet 4.0

Liaison complexe


L'exemple ci-dessous explique comment utiliser la propriété DataSource d'un contrôle DataGrid dans le cadre d'une base de donnés Jet 4.0 : Le code qui définit la propriété apparaît en caractères gras.

Dim NWindOleDbConn As OleDb.OleDbConnection = _ New OleDb.OleDbConnection( ) Dim NWindAdapter As New OleDb.OleDbDataAdapter _ ("Select * from Customers", NWindOleDbConn) Dim NWindDataSet As DataSet = New DataSet( ) NWindOleDbConn.ConnectionString = "Provider= " & _ "Microsoft.Jet.OLEDB.4.0;Data Source=c:\NWind.mdb" NWindOleDbConn.Open( ) NWindAdapter.Fill(NWindDataSet) DataGrid1.DataSource = NWindDataSet DataGrid1.DataMember = "Customers"

Le code du contrôle TextBox ne change pas lorsque vous utilisez un fournisseur SQL. Seul le code des objets Connection et DataAdapter change, comme le confirment les exemples précédents.

Exemple Jet 4.0

Exemple SQL


Utilisation de l'Assistant Formulaire de données

! Pour exécuter l'Assistant Formulaire de données" Dans le menu Fichier, cliquez sur Ajouter

un nouvel élément" Dans le volet Modèles, cliquez sur

Assistant Formulaire de données" Suivez les étapes de l'Assistant

! L'Assistant Formulaire de données fournit les élémentssuivants :" Un formulaire Windows et des contrôles dépendants" Tous les composants de données nécessaires au formulaire" Des méthodes que vous pouvez appeler pour lire et écrire des

données

~~~ ~~~ ~~~

Assistant Formulairede données

Assistant Formulairede données


L'Assistant Formulaire de données vous permet de créer une application Windows Forms avec des contrôles dépendants. Ces contrôles affichent des données provenant d'une source de données spécifiée par vos soins.

Vous pouvez exécuter l'Assistant Formulaire de données de la même manière que vous ajoutez un élément à un projet existant.

! Pour exécuter l'Assistant Formulaire de données 1. Créez ou ouvrez une application Windows Forms.

L'Assistant peut créer un formulaire uniquement dans un type de projet prenant en charge les formulaires.

2. Dans le menu Fichier, cliquez sur Ajouter un nouvel élément. La boîte de dialogue Ajouter un nouvel élément apparaît.

3. Dans le volet Modèles, cliquez sur Assistant Formulaire de données. 4. Attribuez un nom au formulaire de données, puis cliquez sur Ouvrir.

L'Assistant démarre. 5. Suivez pas à pas la procédure qu'il vous indique.

L'Assistant Formulaire de données vous guide tout au long de la procédure de création du formulaire dépendant. Une fois cette procédure menée à terme, vous disposerez des éléments suivants :

! Un formulaire Windows Forms. ! Des contrôles dépendants dans le formulaire. ! Tous les composants de données nécessaires au formulaire. ! Des méthodes que vous pouvez appeler pour lire et, dans le cas de

Windows Forms, écrire des données.

Introduction

Exécution de l'Assistant Formulaire de données

Remarque

Objectifs de l'Assistant


Pour pouvoir afficher les données, le formulaire généré par l'Assistant est doté de contrôles liés à une source de données. Par exemple, le formulaire peut contenir un contrôle Grid.

Un formulaire Windows Forms vous permet de choisir entre une grille ou des contrôles individuels affichant un enregistrement à la fois. Vous pouvez également générer des boutons permettant aux utilisateurs de naviguer d'un enregistrement à un autre et inclure d'autres boutons permettant d'enregistrer les modifications apportées aux enregistrements et d'ajouter de nouveaux enregistrements.

L'Assistant Formulaire de données peut créer de nouveaux composants de données ou utiliser les composants déjà disponibles dans votre projet. Chaque composant de données du formulaire est composé de plusieurs éléments discrets :

! Une connexion à une source de données, telle qu'une base de données. ! Un adaptateur de données qui référence une instruction SQL ou une

procédure stockée pour obtenir des données. ! Un groupe de données typé pour contenir les enregistrements extraits de la

base de données. Le groupe de données inclut un schéma, un fichier de classe DataSet et une instance du groupe de données dans le formulaire.

Si vous l'utilisez pour créer une source de données, l'Assistant connecte automatiquement votre application à la base de données spécifiée. Il peut ensuite accéder à des tables ou des vues au sein de la base de données.

L'Assistant peut éventuellement créer et utiliser une référence à un service Web XML en tant que source de données. Dans ce cas, le service Web XML est supposé renvoyer un groupe de données.

Vous pouvez utiliser l'Assistant pour accéder à plusieurs tables et établir des relations entre elles. Dans cet autre cas, les contrôles du formulaire vous permettent de visualiser à la fois les enregistrements parents et enfants.

Vous devez obligatoirement remplir le groupe de données avec les données de la base de données. Par défaut, pour remplir le groupe de données, l'Assistant génère un bouton Charger conçu pour appeler du code en vue d'une opération de remplissage. Si vous créez un nouveau groupe de données à l'aide de l'Assistant, ce dernier génère automatiquement la méthode Fill. Si vous travaillez à partir d'un groupe de données existant, l'Assistant vous propose de créer une méthode Fill à l'aide des options suivantes :

! Sélectionner une méthode existante Si votre projet inclut une méthode renvoyant un groupe de données (en tant que valeur de retour d'une fonction ou en tant que paramètre), vous pouvez sélectionner cette méthode. L'Assistant génère alors du code pour l'appeler.

! Ignorer la méthode Choisissez cette option si vous souhaitez remplir le groupe de données vous-même plutôt que d'appeler le code de remplissage automatiquement.

Si vous générez un formulaire Windows Forms, l'Assistant peut également générer une méthode Update que vous pouvez appeler pour renvoyer les modifications du groupe de données vers la source de données.

Formulaire et contrôles

Éléments de données

Méthodes Fill et Update


Lorsque la procédure de l'Assistant parvient à son terme, vous disposez d'un nouveau formulaire prêt à être exécuté. Il reste à étudier quelques étapes supplémentaires qu'il peut être bon de suivre ainsi que diverses méthodes qui vous permettront d'aller au-delà des résultats obtenus avec l'Assistant.

Par exemple, pour utiliser le formulaire que vous venez de créer, vous devez le définir en tant que formulaire de démarrage pour pouvoir le tester.

! Pour définir le formulaire de démarrage dans Windows Forms 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet,

puis cliquez sur Propriétés. La page de propriétés Projet apparaît et affiche les propriétés générales.

2. Sélectionnez le formulaire de démarrage de votre choix dans la liste Objet de démarrage.

L'Assistant crée les contrôles, les éléments de données et l'ensemble du code nécessaire à l'exécution du formulaire. Vous pouvez lire ce code et le modifier si besoin est. Vous pouvez effectuer les tâches suivantes pour améliorer le formulaire créé par l'Assistant.

! Modifier l'apparence et l'organisation des contrôles au sein du formulaire. ! Si vous souhaitez ne pas remplir le groupe de données à l'aide du bouton

Charger, vous pouvez déplacer le code de remplissage vers un autre emplacement. L'exemple le plus souvent cité conseille de déplacer le gestionnaire d'événements du bouton vers la méthode d'initialisation du formulaire pour remplir automatiquement le groupe de données lors de l'exécution du formulaire.

! Affiner les requêtes générées par l'Assistant pour permettre à l'adaptateur de données d'extraire un sous-ensemble des données et d'ajouter ou de modifier les paramètres de ses commandes.

! Ajouter une logique applicative ou de validation au formulaire. ! Ajouter une logique de navigation pour empêcher l'apparition d'exceptions

lorsque vous allez au-delà du premier et du dernier enregistrement.

Étapes supplémentaires



! Concepts des bases de données

! Présentation d'ADO.NET

! Utilisation des données

Debugand Deploy

Écriturede code

Accèsaux données


Studio .NET


Créationd'une

interface


1. Quelle est la différence principale entre un environnement connecté et un environnement déconnecté ? Dans un environnement connecté, un utilisateur ou une application reste constamment connecté à une source de données. Dans un environnement déconnecté, un utilisateur ou une application n'est pas constamment connecté à une source de données. Les utilisateurs peuvent transférer un sous-ensemble de données sur un ordinateur déconnecté, puis fusionner ultérieurement les modifications dans la banque de données centrale.

2. Rédigez une instruction SQL capable de sélectionner tous les champs d'une table Customers. SELECT * FROM Customers

3. Identifiez l'objet ADO.NET utilisé pour gérer la communication entre une connexion et un groupe de données. L'objet DataAdapter.


4. Examinez le code ci-dessous et répondez aux questions suivantes. a. Quel est le nom de l'objet Connection ? b. Quel type de fournisseur a été sélectionné ? c. Quel est le nom de fichier de la base de données ?

Dim NWindOleDbConn As OleDb.OleDbConnection NWindOleDbConn = New OleDb.OleDbConnection( ) NWindOleDbConn.ConnectionString = _ "Provider=Microsoft.Jet.OLEDB.4.0;DataSource=c:\NWind.MDB" NWindOleDbConn.Open( )

a. NWindOleDbConn b. Fournisseur de données OleDb .NET c. NWind.MDB

5. Rédigez du code pour générer le groupe de données de YourDataSet à l'aide de l'adaptateur de données YourDataAdapter. La table à partir de laquelle vous extrayez les données s'appelle YourTable. Vous pouvez supposer que le groupe de données et l'adaptateur ont été tous les deux déclarés. YourDataAdapter.Fill(YourDataSet, "YourTable")

6. Quel est le nom du contrôle Windows Forms que vous pouvez utiliser pour afficher plusieurs enregistrements extraits d'une source de données ? Le contrôle DataGrid.

7. Quelles propriétés du contrôle DataGrid pouvez-vous utiliser au moment du design pour lier le contrôle à une source de données ? Les propriétés DataSource et DataMember.


Atelier 11.1 : Accès aux données à l'aide d'ADO.NET

! Exercice 1 : Utilisation de l'Assistant Formulaire de données


À la fin de cet atelier, vous serez à même d'utiliser l'Assistant Formulaire de données pour effectuer les tâches suivantes :

! établir une connexion à une base de données ; ! configurer et créer un groupe de données ; ! charger, afficher et mettre à jour les données extraites à l'aide des boutons

de l'Assistant Formulaire de données.

Cet atelier porte sur les concepts évoqués dans ce module. Il risque, en conséquence, de ne pas être conforme aux recommandations de sécurité énoncées par Microsoft.

Avant de poursuivre, vous devez disposer de connaissances dans les domaines suivants :

! Termes clés liés aux bases de données ! Objets ADO.NET courants, notamment Connection, DataAdapter et

DataSet ! Contrôle DataGrid

Objectifs

Remarque



Dans cet atelier, vous apprendrez à utiliser l'Assistant Formulaire de données pour créer un formulaire Windows Forms à partir duquel vous pourrez manipuler les données d'une base de données. À l'aide de l'Assistant, vous vous connecterez à la base de données Northwind, procéderez à la configuration et à l'extraction d'un groupe de données, puis utiliserez un contrôle DataGrid pour afficher les données extraites. Une fois l'atelier terminé, le formulaire Windows Forms que vous aurez créé se présentera comme suit :

Les fichiers solution de cet atelier sont disponibles à partir du dossier dossier_installation\Labfiles\Lab111\Ex01\Solution.

Scénario

Fichiers solution



Exercice 1 Utilisation de l'Assistant Formulaire de données

Au cours de cet exercice, vous effectuerez les tâches suivantes :

! utiliser l'Assistant Formulaire de données pour créer un formulaire de données affichant deux tables connexes ;

! tester les fonctionnalités d'exécution de la base de données (ajout, suppression, mise à jour, navigation) à l'aide des boutons de l'Assistant.

! Pour créer un nouveau projet 1. Démarrez Visual Studio .NET et créez un nouveau projet Visual Basic basé

sur le modèle Application Windows. 2. Nommez le projet NorthwindData, définissez l'emplacement du dossier à

dossier_installation\Labfiles\Lab111\Ex01, puis cliquez sur OK.

! Pour démarrer l'Assistant Formulaire de données 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

NorthwindData, pointez sur Ajouter, puis cliquez sur Ajouter un nouvel élément. � Ou � Dans le menu Projet, cliquez sur Ajouter un nouvel élément.

2. Sous Modèles, dans la boîte de dialogue Ajouter un nouvel élément, cliquez sur Assistant Formulaire de données.

3. Dans le champ Nom, tapez NWindCustomerOrdersDataForm.vb puis cliquez sur Ouvrir.

4. Dans la boîte de dialogue Bienvenue dans l'Assistant Formulaire de données, cliquez sur Suivant pour démarrer l'Assistant.

! Pour choisir le groupe de données de votre choix •••• Dans le champ Créer un nouveau groupe de données nommé de la boîte

de dialogue Choisir le groupe de données à utiliser, tapez NorthwindDataSet puis cliquez sur Suivant.


! Pour choisir une connexion de données 1. Dans la boîte de dialogue Choisir une connexion de données, cliquez sur

Nouvelle connexion pour afficher la boîte de dialogue Propriétés des liaisons de données.

2. Dans l'onglet Connexion de l'Étape 1, tapez le nom du SQL Server de votre ordinateur (nom_ordinateur\NetSDK). Notez que les noms SQL Server tiennent compte de la casse.

Lorsque vous installez SQL Server Desktop Engine, un n�ud SQL Server intitulé nom_ordinateur\NetSDK est créé. Ce n�ud est visible à partir de l'Explorateur de solutions. Tous les fichiers de bases de données SQL Server sont stockés dans ce n�ud comme si l'ordinateur fonctionnait sous SQL Server.

3. Dans l'onglet Connexion de l'Étape 2, cliquez sur Utiliser la sécurité intégrée de Windows NT.

4. Dans l'onglet Connexion de l'Étape 3, cliquez sur Northwind, puis sur Tester la connexion. Cliquez sur OK dans le message Test de connexion réussi, puis sur OK dans la boîte de dialogue Propriétés des liaisons de données.

5. Dans la liste Quelle connexion l'Assistant doit-il utiliser ?, cliquez sur la nouvelle connexion : nom_ordinateur\NetSDK.Northwind.dbo.

6. Cliquez sur Suivant dans la boîte de dialogue Choisir une connexion de données.

! Pour assigner des tables au DataAdapter 1. Dans la boîte de dialogue Choisir les tables ou les vues, sous Éléments

disponibles, cliquez sur Customers, puis sur le bouton pour ajouter l'élément au volet Éléments sélectionnés.

2. Ajoutez la table Orders au volet Éléments sélectionnés, puis cliquez sur Suivant.

! Pour créer une relation entre des tables 1. Dans la boîte de dialogue Créer une relation entre les tables, tapez

CustomerOrdersRelation dans la zone Nom. 2. Dans la liste Table parente, cliquez sur Customers, puis dans la liste Clés,

sous Customers, cliquez sur CustomerID. 3. Dans la liste Table enfant, cliquez sur Orders, puis dans la liste Clés, sous

Orders, cliquez sur CustomerID.

4. Cliquez sur le bouton pour ajouter la relation CustomerOrdersRelation dans la zone Relations.

5. Cliquez sur Suivant.

Remarque


! Pour choisir des tables et des colonnes à afficher depuis les tables Customers et Orders

1. À partir de la boîte de dialogue Choisir les tables et les colonnes à afficher dans le formulaire, dans la liste Colonnes, sous Customers, supprimez Address, City, Region, PostalCode et Fax.

2. Dans la liste Colonnes, sous Orders, supprimez EmployeeID, ShipVia, Freight, ShipAddress, ShipRegion, ShipPostalCode et ShipCountry.

3. Cliquez sur Suivant. 4. Dans la boîte de dialogue Choisir le style d'affichage, sélectionnez Un

enregistrement unique dans des contrôles individuels. 5. Sous Quels contrôles supplémentaires souhaitez-vous ajouter à votre

formulaire ?, laissez toutes les cases à cocher activées. 6. Cliquez sur Terminer. 7. Redimensionnez le formulaire et le contrôle DataGrid afin que tous les

champs s'affichent dans la grille de données. Votre formulaire de données doit se présenter comme suit :


! Pour tester les fonctionnalités d'édition des données du formulaire 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur

NorthwindData, puis cliquez sur Propriétés. 2. Dans la boîte de dialogue Pages de propriétés, modifiez l'Objet de

démarrage à NWindCustomerOrdersDataForm, puis cliquez sur OK. 3. Exécutez l'application. 4. Cliquez sur Charger pour charger les données dans le formulaire. 5. Modifiez le champ CompanyName à Microsoft, puis cliquez sur Mettre à

jour. Notez ici le nombre total d'enregistrements : __________. 6. Cliquez sur Ajouter, puis entrez des exemples de données dans les champs

Customer. Entrez 1111 (ou supérieur) dans le champ CustomerID. Notez ici le nouveau nombre d'enregistrements dans le formulaire : ___________. Passez à un enregistrement précédent.

7. Revenez à votre nouvel enregistrement, cliquez sur Annuler tout, puis passez à nouveau à l'enregistrement précédent. Vérifiez que le nombre d'enregistrements dans le formulaire correspond au nombre relevé à l'étape 5.

Le bouton Annuler tout permet uniquement d'annuler les modifications apportées depuis que vous avez cliqué sur le bouton Mettre à jour.

8. Quittez l'application en cours d'exécution.

Conseil


Table des matières

Vue d'ensemble 1

Leçon : Introduction au déploiement 2

Leçon : Déploiement d'une application Windows 10


Atelier 12.1 : Déploiement d'une application 25

Module 12 : Déploiement d'applications


Module 12 : Déploiement d'applications iii

Notes de l'instructeur Ce module explique comment déployer des applications à l'aide de Microsoft® Visual Studio® .NET. Il décrit également les options de déploiement que propose Visual Basic® .NET et explique comment créer et personnaliser un projet de configuration pour les applications Microsoft Windows®.


! décrire comment déployer des applications à l'aide de Microsoft® Visual Studio® .NET ;

! créer et personnaliser un programme de configuration pour une application Windows.


! Fichier Microsoft PowerPoint® 2560A_12.ppt ! Fichier de démonstration multimédia 2560A_12d005.htm


! lire tous les documents de cours relatifs à ce module ; ! prendre connaissance de la démonstration multimédia ; ! réaliser l'atelier de ce module.

Présentation : 45 minutes Atelier : 30 minutes

Documents de cours

Préparation

iv Module 12 : Déploiement d'applications


Leçon : Introduction au déploiement Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Cette rubrique a pour but de présenter brièvement les assemblys aux stagiaires. N'y consacrez pas trop de temps car ce cours n'a pas pour objet de traiter en détail le rôle des assemblys de Microsoft .NET Framework. Insistez sur le fait que tout code qui s'exécute dans le .NET Framework réside dans un assembly, et que les assemblys de .NET Framework aident à résoudre d'éventuels problèmes tels que, par exemple, toutes les questions liées à la gestion des versions.

Si les stagiaires souhaitent approfondir le sujet, conseillez-leur le livre blanc, « Simplification du déploiement et élimination de « l�enfer des DLL » avec .NET Framework », dans la section Lectures complémentaires de la page Web accessible à partir du CD-ROM du stagiaire. Précisez également qu'il existe bien d'autres informations sur les assemblys dans la documentation Visual Studio .NET sous le titre de rubrique « Assemblys ».

Décrivez les options qui permettent d'empaqueter le code et de distribuer une application vers un utilisateur final. Soulignez les avantages qu'offre Microsoft Windows Installer lors des déploiements. Expliquez ensuite les situations extrêmes où un développeur peut utiliser XCOPY ou la commande Copier un projet pour procéder au déploiement.

Ouvrez la boîte de dialogue Nouveau projet, cliquez sur Projets de configuration et de déploiement, puis décrivez brièvement aux stagiaires chacune des options. Au cours de l'atelier 12.1, Déploiement d'une application, les stagiaires auront la possibilité d'utiliser l'Assistant Configuration pour créer un projet de configuration.

Leçon : Déploiement d'une application Windows Cette section décrit la stratégie pédagogique à suivre pour animer chaque rubrique de cette leçon.

Cette démonstration offre une vue d'ensemble des sujets abordés dans cette leçon. Pour lancer cette démonstration, cliquez sur l'icône située au centre de la diapositive. Si vous préférez vous servir de cette présentation multimédia en tant que démonstration dirigée, vous trouverez les étapes à suivre dans la section Démonstration des notes de l'instructeur.


Cette rubrique explique globalement la façon dont les stagiaires peuvent utiliser l'Assistant Configuration pour créer des packages Windows Installer pour des applications Windows.

Présentation des assemblys

Déroulement du déploiement dans Visual Studio .NET

Choix du type de projet

Présentation multimédia : Déploiement d'une application Windows

Création d'un projet de configuration Windows Installer

Module 12 : Déploiement d'applications v

Montrez comment accéder et définir les propriétés de configuration d'un projet de déploiement. Expliquez aux stagiaires qu'ils devront inclure un programme d'amorçage dans le programme d'installation de leur application si Windows Installer 1.5 n'est pas installé sur l'ordinateur de destination.

Cette rubrique présente brièvement les six éditeurs que peuvent utiliser les développeurs pour personnaliser le projet de configuration d'une application. Expliquez brièvement le rôle de chacun d'entre eux. Dans la rubrique suivante, les stagiaires en apprendront davantage sur l'Éditeur du système de fichiers.

Expliquez aux stagiaires comment ils peuvent utiliser les dossiers virtuels dans l'Éditeur du système de fichiers afin de définir l'emplacement où sont installés les fichiers sur l'ordinateur de destination. Montrez comment utiliser l'Éditeur du système de fichiers pour créer un dossier personnalisé et créer un raccourci sur le Bureau de l'utilisateur ou dans un dossier spécifique.

Passez en revue les différences qui existent entre une version de débogage et la version finale d'une application. Montrez comment utiliser le Gestionnaire de configurations pour définir la configuration de solution active et inclure le projet de configuration dans la version.

Le .NET Framework doit être installé sur tous les ordinateurs qui exécutent une application créée dans Visual Studio .NET. Pour plus d'informations sur l'installation du .NET Framework à l'aide de dotnetfx.exe, consultez Microsoft MSDN® ou la section Liens Internet de la page Web accessible à partir du CD-ROM du stagiaire.

Contrôle des acquis Ces questions sont l'occasion de réviser les concepts et les procédures abordés en détail dans ce module. Adoptez le principe de la discussion pour répondre aux questions afin que chacun ait la possibilité de connaître la bonne réponse.

Atelier 12.1 : Déploiement d'une application Avant de commencer cet atelier, les stagiaires doivent avoir réalisé toutes les applications pratiques et répondu aux questions du contrôle des acquis. Les stagiaires devront pouvoir accomplir la plupart des tâches apprises dans les leçons et les applications pratiques. L'atelier est simple mais complet. Il guide les stagiaires pas à pas et leur fait revoir toutes les étapes de déploiement d'une application décrites en détail dans la dernière leçon de ce module.

Définition des propriétés d'un projet

Éditeurs de déploiement

Utilisation de l'Éditeur du système de fichiers

Génération du projet de configuration

vi Module 12 : Déploiement d'applications

Démonstrations Vous pouvez présenter la démonstration multimédia en exécutant le fichier multimédia fourni avec ce module. Vous pouvez également procéder vous-même à la démonstration en suivant ces instructions.


Présentation multimédia : Déploiement d'une application Windows Cette démonstration illustre le déploiement d'une application Windows. Elle explique comment ajouter un projet de configuration à une solution et en définir les propriétés. Elle montre également comment ajouter un groupe de programmes et un raccourci sur le Bureau de l'utilisateur.

! Ouvrez Visual Studio .NET et le projet de démonstration 1. Cliquez sur Démarrer, pointez sur Tous les programmes, puis sur

Microsoft Visual Studio .NET et cliquez sur Microsoft Visual Studio .NET.

2. Dans la page de démarrage, sous l'onglet Démarrer, cliquez sur Ouvrir un projet.

3. Dans la boîte de dialogue Ouvrir un projet, ouvrez le fichier Calc.sln, qui se trouve dans le dossier dossier_installation\Democode\Mod12\Calculator.

! Ajoutez un projet de configuration à la solution 1. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 2. Dans la boîte de dialogue Nouveau projet, dans le volet Types de projets,

cliquez sur Projets de configuration et de déploiement. 3. Dans le volet Modèles, cliquez sur Assistant Configuration. 4. Cliquez sur Ajouter à la solution. 5. Dans la zone Emplacement, tapez dossier_installation\Democode\Mod12\

Calculator\Setup, puis cliquez sur OK. 6. Dans l'Assistant Configuration, à la page Bienvenue dans l'Assistant

Configuration, cliquez sur Suivant. 7. Dans la page Choisir un type de projet, cliquez sur Suivant. 8. Dans la page Choisir les sorties de projet à inclure, cliquez sur Sortie

principale de Calc, puis cliquez sur Suivant. 9. Dans la page Choisir les fichiers à inclure, cliquez sur Ajouter.

10. Dans la boîte de dialogue Ajouter des fichiers, accédez à dossier_installation\Democode\Mod12\Calculator, cliquez sur Calc.ico, puis sur Ouvrir.

Module 12 : Déploiement d'applications vii

11. Dans la page Choisir les fichiers à inclure, cliquez sur Suivant. 12. Dans la page Créer le projet, cliquez sur Terminer.

Indiquez aux stagiaires que la solution se compose dorénavant de deux projets : le projet Exemple de calculatrice et le projet de configuration qui servira à déployer la calculatrice.

! Définissez les propriétés du projet de configuration 1. Dans l'Explorateur de solutions, cliquez sur Setup1. 2. Dans la fenêtre Propriétés, double-cliquez sur Manufacturer, tapez

Northwind Traders, puis appuyez sur ENTRÉE. 3. Double-cliquez sur ProductName, tapez Exemple de calculatrice, puis

appuyez sur ENTRÉE. 4. Double-cliquez sur Title, tapez Exemple de calculatrice, puis appuyez sur

ENTRÉE.

! Ajoutez un groupe de programmes et un raccourci 1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Setup1,

pointez sur Afficher, puis cliquez sur Système de fichiers. 2. Dans la fenêtre de l'éditeur Système de fichiers (Setup1), dans le volet

gauche, cliquez avec le bouton droit sur Menu Programmes de l'utilisateur, pointez sur Ajouter, puis cliquez sur Dossier.

3. Tapez Exemple de calculatrice, puis appuyez sur ENTRÉE. 4. Dans la fenêtre de l'éditeur du système de fichiers (Setup1), cliquez sur

Dossier d'application. 5. Dans la liste des éléments contenus dans le dossier d'application, cliquez

avec le bouton droit sur Sortie principale de Calc (Actif), puis cliquez sur Créer un raccourci vers Sortie principale de Calc (Actif).

6. Tapez Exemple de calculatrice, puis appuyez sur ENTRÉE. 7. Cliquez sur Exemple de calculatrice, si cet élément n'est pas encore

sélectionné. 8. Dans la fenêtre Propriétés, cliquez sur Icon, cliquez sur le bouton flèche

vers le bas, puis cliquez sur Parcourir. 9. Dans la boîte de dialogue Icône, cliquez sur Parcourir.

10. Dans la boîte de dialogue Sélectionner un élément dans le projet, double-cliquez sur Dossier d'application.

11. Cliquez sur Calc.ico, puis sur OK. 12. Dans la boîte de dialogue Icône, cliquez sur OK. 13. Dans la fenêtre Propriétés, cliquez sur Folder, puis cliquez sur le bouton

points de suspension. 14. Dans la boîte de dialogue Sélectionner un dossier, développez Menu

Programmes de l'utilisateur, cliquez sur Exemple de calculatrice, puis sur OK.

viii Module 12 : Déploiement d'applications

! Ajoutez un raccourci sur le Bureau de l'utilisateur 1. Dans la fenêtre de l'éditeur du système de fichiers (Setup1), cliquez sur

Dossier d'application. 2. Dans la liste des éléments contenus dans le dossier d'application, cliquez

avec le bouton droit sur Sortie principale de Calc (Actif), puis cliquez sur Créer un raccourci vers Sortie principale de Calc (Actif).

3. Tapez Exemple de calculatrice, puis appuyez sur ENTRÉE. 4. Cliquez sur Exemple de calculatrice, si cet élément n'est pas encore

sélectionné. 5. Dans la fenêtre Propriétés, cliquez sur Icon, cliquez sur le bouton flèche

vers le bas, puis cliquez sur Parcourir. 6. Dans la boîte de dialogue Icône, cliquez sur Parcourir. 7. Dans la boîte de dialogue Sélectionner un élément dans le projet,

double-cliquez sur Dossier d'application. 8. Cliquez sur Calc.ico, puis sur OK. 9. Dans la boîte de dialogue Icône, cliquez sur OK.

10. Dans la fenêtre Propriétés, cliquez sur Folder, puis cliquez sur le bouton points de suspension.

11. Dans la boîte de dialogue Sélectionner un dossier, cliquez sur Bureau de l'utilisateur, puis sur OK.

! Générez le projet de configuration • Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Setup1,

puis cliquez sur Générer. Remarquez que la barre d'état signale qu'une génération est en cours.

! Quittez Visual Studio .NET • Dans le menu Fichier, cliquez sur Quitter.

Vous souhaiterez très vraisemblablement exécuter le programme de configuration et montrez aux stagiaires les raccourcis créés sur le Bureau et dans le menu Programmes.

Module 12 : Déploiement d'applications 1

Vue d'ensemble

! Introduction au déploiement

! Déploiement d'uneapplication WindowsUtilisation


Accèsaux données Debug

and Deploy

Écriturede code

Créationd'une

interface



Après avoir créé et testé une application, vous devez la distribuer pour qu'elle puisse être utilisée sur d'autres ordinateurs. Il peut s'agir d'une application Web ou Microsoft® Windows® exécutée par des utilisateurs finaux ou d'une bibliothèque de code employée par d'autres développeurs. Le déploiement est le processus qui vous permet de distribuer une application finie ou un composant à installer sur d'autres ordinateurs.

Dans ce module, vous découvrirez les différentes options de déploiement disponibles dans Microsoft Visual Basic® .NET, et apprendrez à utiliser certaines d'entre elles pour déployer des applications Windows.


! décrire comment déployer des applications à l'aide de Microsoft Visual Studio® .NET ;

! créer et personnaliser un programme de configuration pour une application Windows.

Introduction

Objectifs

2 Module 12 : Déploiement d'applications

Leçon : Introduction au déploiement

! Présentation des assemblys

! Déroulement du déploiement dans Visual Studio .NET

! Choix du type de projet


Dans cette leçon, vous allez apprendre le rôle que jouent les assemblys dans le déploiement, découvrir le processus de déploiement proprement dit et vous familiariser avec les projets de déploiement que vous offre Visual Studio .NET.


! Présentation des assemblys ! Déroulement du déploiement dans Visual Studio .NET ! Choix du type de projet


! décrire les assemblys ; ! expliquer les options d'empaquetage et de distribution disponibles dans

Visual Studio .NET ; ! choisir les options de déploiement les mieux adaptées à des scénarios

spécifiques.

Introduction




Présentation des assemblys

! Le code doit être empaqueté dans une unité fonctionnelle, appelée un assembly, avant d'être exécuté par le Common Language Runtime

! Les assemblys contiennent toutes les informationsnécessaires au déploiement et à la gestion des versions

Boo.dll

Manifeste

Moo.dll Logo.bmpGraphic.jpg

Manifeste

Assembly sous formed'un seul fichier

Assembly sous formed'un seul fichier

Assembly sous formede plusieurs fichiers

Assembly sous formede plusieurs fichiers


Dans le Microsoft .NET Framework, le code doit être empaqueté dans une unité fonctionnelle, appelée un assembly, avant d'être exécuté par le Common Language Runtime. Les assemblys contiennent toutes les informations nécessaires au déploiement et à la gestion des versions.

Les applications du .NET Framework se composent d'un ou de plusieurs assemblys. Bien que, dans le cas le plus simple, une application se compose d'un seul assembly, le plus souvent, elle en comporte plusieurs.

Un assembly peut être empaqueté sous forme d'un seul fichier exécutable portable (PE, Portable Executable), tel qu'un fichier .exe (exécutable) ou .dll (bibliothèque de liaison dynamique), ou être constitué de plusieurs fichiers PE et de fichiers de ressources externes, tels qu'un fichier bitmap. Le plus souvent, les applications sont compilées en un seul fichier PE.

Les assemblys peuvent se composer des éléments suivants :

! Métadonnées de l'assembly (le manifeste) Les métadonnées décrivant un assembly sont appelées le manifeste. Le manifeste fournit, entre autres, le titre de l'assembly et sa description, ainsi que des informations relatives à la version. Il comprend aussi des informations sur la liaison de l'assembly avec d'autres fichiers et permet à l'assembly d'être auto-descriptif.

! Métadonnées de type Les métadonnées de type donnent des informations sur les classes, les interfaces, les méthodes et les propriétés disponibles.

Introduction

Structure d'un assembly


! Code MSIL (Microsoft Intermediate Language) à exécuter MSIL est un jeu d'instructions, parfaitement indépendant du processeur, qu'il est facile de convertir en code natif. La conversion du MSIL en code spécifique au processeur est assurée par un compilateur juste-à-temps (JIT, just-in-time).

! Toutes les ressources requises (les graphiques, par exemple) ou les fichiers de ressource nécessaires, par exemple, à la localisation.

L'un des principaux rôles des assemblys est d'assurer la gestion des versions. Plus précisément, les assemblys permettent aux développeurs de définir des règles de gestion des versions entre les différents composants logiciels et de les faire appliquer lors de l'exécution. Ils permettent une gestion côte à côte des versions : possibilité d'installer et d'exécuter en même temps plusieurs versions du même composant sur un ordinateur. Ainsi, les différentes applications qui s'exécutent sur un ordinateur peuvent utiliser différentes versions d'un composant partagé.

Pour plus d'informations sur les assemblys, consultez les sources suivantes : ! Documentation Visual Studio® .NET ! Livre blanc, « Simplification du déploiement et élimination de « l�enfer des

DLL » avec .NET Framework », dans la section Lectures supplémentaires de la page Web accessible à partir du CD-ROM du stagiaire

Assembly et gestion des versions

Remarque


Déroulement du déploiement dans Visual Studio .NET

! Options d'empaquetage" Sous forme de fichiers exécutables portables

(fichiers .dll et .exe)" Sous forme de fichiers cabinet ( .cab)" Sous forme de package Windows Installer

! Déploiement" Repose sur la technologie Windows Installer

! Autres modes de déploiement

" XCOPY

" Commande Copier un projet


Le déploiement compte deux étapes : l'empaquetage du code et la distribution des packages. Vous pouvez distribuer vos applications sur disquettes, sur CD-ROM, via un réseau, par le biais d'Internet ou d'un intranet.

Il existe plusieurs manières d'empaqueter les applications créées dans Visual Studio .NET :

! Sous forme de fichiers exécutables portables (fichiers .dll et .exe) La façon la plus simple d'empaqueter votre application est de créer une version de débogage de l'application. Lors de la génération de l'application, le code est empaqueté en assemblys. Les fichiers .exe qui en résultent peuvent être distribués par simple copie des fichiers. Vous pouvez, par exemple, copier tous les fichiers d'assembly sur un CD-ROM et écrire un fichier batch de façon à copier les fichiers vers un répertoire du disque dur de l'utilisateur. L'utilisateur n'a plus ensuite qu'à exécuter l'application.

! Sous forme de fichiers cabinet (.cab) Vous pouvez utiliser les fichiers .cab pour compresser votre application. Cette option est généralement utilisée lors de téléchargements Internet afin de réduire la durée de l'opération.

! Sous forme de package Windows Installer Cette option permet de créer des packages Windows Installer (fichiers .msi) à utiliser avec Windows Installer.

Introduction

Empaquetage


Dans Visual Studio .NET, le déploiement repose sur la technologie de Windows Installer. Windows Installer regroupe toutes les données et instructions d'installation dans un seul package. Avec Windows Installer, chaque ordinateur conserve une base de données des informations d'installation pour chaque application qu'il installe. S'y trouvent notamment, des fichiers, des clés de Registre et des composants.

Lors du déploiement d'une application, Windows Installer présente les avantages suivants :

! Lors de la désinstallation d'une application, la base de données de l'ordinateur est lue et vérifiée pour s'assurer qu'aucune autre application n'utilise un fichier, une clé de Registre ou un composant faisant l'objet d'une suppression. Cette fonctionnalité vous empêche de rendre une application inexploitable suite à la suppression d'une autre.

! Windows Installer assure l'auto-dépannage. Autrement dit, il permet à une application de réinstaller automatiquement les fichiers manquants que l'utilisateur aurait pu supprimer par inadvertance.

! Windows Installer offre également la possibilité de restaurer une installation. Par exemple, si une application repose sur une base de données spécifique qui reste introuvable lors de l'installation, l'utilisateur peut arrêter la procédure et redonner à l'ordinateur la configuration qu'il avait avant l'installation.

! Windows Installer permet de configurer et de créer automatiquement les paramètres de l'annuaire des services IIS (Internet Information Services), les paramètres de sécurité NTFS, les partages réseau et les comptes Utilisateur et Groupe du service d'annuaire Active Directory®.

! Windows Installer permet de créer automatiquement les raccourcis du Bureau, d'ajouter automatiquement des programmes à la liste Ajout/Suppression de programmes et de créer automatiquement les entrées du menu Démarrer.

Pour déployer une application, vous devez commencer par créer un projet de configuration et définir les propriétés du projet de déploiement ; propriétés qui déterminent où et comment générer le programme d'installation.

! Lorsque le déploiement se fait sur des supports traditionnels, il faut ensuite copier le fichier .msi de l'emplacement du build vers une disquette, un CD-ROM ou un autre support de votre choix.

! Pour procéder à un déploiement vers un intranet ou Internet, il faut créer un projet de configuration Web. Une fois le programme d'installation généré, vous devez le copier sur l'ordinateur serveur d'où il pourra ensuite être téléchargé sur le réseau.

Avantages de Windows Installer

Processus de déploiement


Pour déployer des applications simples dépourvues de dépendances, il suffit parfois de copier l'application sur l'ordinateur de destination. Pour désinstaller l'application, il suffit de supprimer le dossier du système. Avec le .NET Framework, vous disposez des options suivantes pour copier les applications :

! XCOPY Dans la mesure où les applications Common Language Runtime sont auto-descriptives et ne requièrent aucune entrée de Registre, vous pouvez utiliser la commande XCOPY pour les copier dans le répertoire de votre choix. L'application peut ensuite s'exécuter à partir de là. XCOPY est un moyen simple de copier un projet ou une application d'un emplacement à un autre. Réservez toutefois la commande XCOPY aux cas les plus simples. En effet, XCOPY n'enregistre ni ne vérifie l'emplacement des assemblys. De plus, en cas de projets Web, cette commande ne configure pas automatiquement les paramètres de l'annuaire des services IIS. Elle ne propose à l'utilisateur aucune interface graphique pour installer et désinstaller l'application. Plus important encore, si vous utilisez XCOPY pour déployer une application, vous n'avez pas accès aux fonctions de gestion des fichiers de Windows Installer. Ces dernières vous évitent les conflits de fichiers et vous empêchent d'écraser des fichiers ou de supprimer des fichiers partagés.

! La commande Copier un projet S'il s'agit de projets Web, vous pouvez utiliser la commande Copier un projet du menu Projet. La copie d'un projet s'avère beaucoup plus simple que le déploiement lorsqu'il n'est question que de transférer le contenu de votre projet sur un serveur Web de destination. N'oubliez pas, en revanche, qu'en copiant le projet, vous ne configurez pas automatiquement les paramètres de l'annuaire des services IIS. Dans la plupart des cas, vous aurez à déployer votre projet et non pas à le copier pour pouvoir bénéficier des fonctions de gestion de projet de déploiement que sont, par exemple, l'inscription aux services IIS et leur configuration.

Pour plus d'informations sur XCOPY, consultez l'article, « Determining When to Use Windows Installer Versus XCOPY », dans la section Lectures complémentaires de la page Web accessible à partir du CD-ROM du stagiaire.

Autres modes de déploiement

Remarque



Projet de configuration

! Crée un fichier Windows Installer (fichier .msi)

Projet de configuration Web

! Crée un fichier Windows Installer pour une application Web (fichier .msi)

Projet de module de fusion

! Empaquette des composants qui peuvent être partagés par plusieurs applications (fichier .msm)

Projet CAB

! Crée un fichier .cab pour le téléchargement vers un navigateur Web


Avant de déployer une solution, vous devez préciser, dans Visual Studio .NET, ce que vous voulez déployer, ainsi que l'endroit et la façon de procéder. Pour cela, vous ajoutez un ou plusieurs projets de déploiement à votre solution. Chaque projet de déploiement comporte les instructions nécessaires à l'installation des fichiers et des composants sur un ordinateur de destination.

Visual Studio .NET propose des modèles pour quatre types de projets de déploiement. De plus, un Assistant Configuration vous guide pas à pas tout au long de la création des projets de déploiement.

! Pour créer un projet de déploiement • Dans la boîte de dialogue Nouveau projet, cliquez sur Projets de

configuration et de déploiement, comme le montre la capture d'écran suivante.

Introduction

Création d'un projet de déploiement


Le tableau ci-dessous vous aide à choisir le type le mieux adapté à votre projet de déploiement.

Type de projet Description Fonction

Projet de configuration ou Projet de configuration Web

Les projets de configuration créent un fichier Windows Installer (.msi) qui contient l'application, les fichiers dépendants, les informations relatives à l'application telles qu'entrées de Registre et instructions d'installation.

En cas de projet de configuration, le programme d'installation installera les fichiers dans un répertoire Program Files de l'ordinateur de destination.

En cas de projet de configuration Web, le programme d'installation installera les fichiers dans un répertoire racine virtuel sur un serveur Web.

Projet de configuration : Crée un programme d'installation pour une application Windows.

Projet de configuration Web : Crée un programme d'installation pour une application Web.

Projet de module de fusion

Un fichier de module de fusion (.msm) est un seul package qui regroupe l'ensemble des fichiers, des ressources, des entrées de Registre et de la logique nécessaires à l'installation d'un composant. Les modules de fusion ne peuvent pas être installés seuls. Ils doivent être utilisés en conjonction avec un fichier Windows Installer.

Empaquette les fichiers ou les composants dans un seul module afin d'en faciliter le partage. Les fichiers .msm qui en résultent peuvent être inclus dans tout autre projet de déploiement.

Projet CAB Les projets CAB créent un fichier .cab qui empaquette les contrôles Microsoft ActiveX® et qui sert au téléchargement d'un serveur Web à un autre.

Crée un fichier .cab en vue du téléchargement vers un navigateur Web.

Dans Visual Studio .NET, vous pouvez créer différents types de programmes d'installation : les fichiers Windows Installer (.msi), pour les applications Windows ou Web, et les modules de fusion (.msm).

Ces deux types de programme d'installation se distinguent principalement par la cible à laquelle ils s'adressent :

! Les fichiers Windows Installer servent à installer des applications et des fichiers sur un autre ordinateur. Tout ce dont l'utilisateur final de l'application se servira directement (fichiers .exe, documents, pages HTML) doit être empaqueté dans un fichier Windows Installer.

! Les modules de fusion servent à installer des composants partagés par plusieurs applications. Les composants (fichiers .dll, contrôles et ressources, par exemple) peuvent être empaquetés dans un module de fusion, qui à son tour sera fusionné dans le fichier Windows Installer de chaque application utilisant ce composant. Lorsque les applications sont distribuées à plusieurs utilisateurs finaux, le composant est installé partout de la même manière.


Différence entre les fichiers Windows Installer et les modules de fusion


Leçon : Déploiement d'une application Windows

Créez un projet de configurationCréez un projet de configuration

Définissez les propriétés du projetDéfinissez les propriétés du projet

Générez l'applicationGénérez l'application

Distribuez et installez l'applicationDistribuez et installez l'application

Personnalisez le projet de configurationPersonnalisez le projet de configuration


Cette leçon explique les étapes par lesquelles vous devez passer pour créer et personnaliser un projet de configuration Windows Installer afin de déployer une application Windows.


! Présentation multimédia : Déploiement d'une application Windows ! Création d'un projet de configuration Windows Installer ! Définition des propriétés d'un projet ! Éditeurs de déploiement ! Utilisation de l'Éditeur du système de fichiers ! Génération du projet de configuration


! créer un projet de configuration pour une application Windows à l'aide de l'Assistant Configuration ;

! personnaliser votre projet de configuration en définissant les propriétés et en utilisant les éditeurs de déploiement ;

! déployer une application Windows.

Introduction




Présentation multimédia : Déploiement d'une application Windows


Au cours de cette démonstration, vous allez apprendre à déployer une application Windows, à ajouter un projet de configuration à une solution et à définir les propriétés du projet. Vous allez également apprendre à ajouter un groupe de programmes et un raccourci sur le Bureau de l'utilisateur.


Création d'un projet de configuration Windows Installer


Vous pouvez utiliser le modèle Projet de configuration pour créer des packages Windows Installer destinés aux applications Windows. L'Assistant Configuration vous aide pas à pas à recueillir toutes les informations dont vous avez besoin pour créer un projet de configuration.

! Pour ajouter un projet de configuration à une solution 1. Dans le menu Fichier, pointez sur Ajouter un projet, puis cliquez sur

Nouveau projet. 2. Dans la boîte de dialogue Ajouter un projet, cliquez sur le dossier Projets

de configuration et de déploiement. 3. Cliquez sur Assistant Configuration.

Dans l'Assistant Configuration, vous devrez suivre les étapes ci-dessous pour créer un projet de configuration et l'ajouter à votre solution :

1. Choisissez le type du projet. Le type de projet que vous choisissez détermine l'emplacement d'installation des fichiers sur l'ordinateur de destination et la façon de procéder au déploiement. Par défaut, l'Assistant Configuration vous aide à créer un programme de configuration afin d'installer une application Windows.

2. Choisissez les sorties du projet à inclure. Les projets Visual Studio .NET servent de conteneur au sein d'une solution afin de gérer logiquement, générer et dépanner les éléments qui constituent votre application. La sortie d'un projet est généralement un fichier .exe, un fichier .dll ou un module.

Introduction

Création d'un projet de configuration à l'aide de l'Assistant Configuration


Les types de sorties que vous avez le droit d'ajouter à votre projet de déploiement dépendent du type de projet que vous avez sélectionné. Le tableau ci-dessous décrit les différentes sorties que vous pouvez utiliser en vue du déploiement d'une application Windows. Sachez que vous pouvez sélectionner plusieurs types de sorties.

Sortie de projet Description

Sortie principale Contient le fichier.dll ou .exe généré par le projet. En règle générale, vous choisissez d'inclure cette sortie, quel que soit le déploiement.

Ressources localisées

Contient les assemblys satellites correspondant aux ressources de chaque culture. Vous pouvez inclure cette option si vous déployez une application dans plusieurs pays.

Symboles de débogage

Contient les fichiers de débogage associés au projet. Vous pouvez inclure cette sortie dans les projets qui feront l'objet d'un débogage ultérieur.

Fichiers de contenu

Comprend tous les fichiers de contenu du projet (des pages HTML, par exemple). Vous pouvez inclure cette sortie dans un projet qui sera utilisé par d'autres développeurs.

Fichiers sources Contient tous les fichiers sources du projet. Vous pouvez inclure cette sortie dans un projet qui sera utilisé par d'autres développeurs ayant besoin d'accéder au code source, ou avec des fichiers de contrôle qui seront compilés dans l'application finale par un autre développeur.

3. Choisissez les fichiers à inclure. Vous pouvez ajouter à un projet de configuration des fichiers tels que des fichiers Lisez-moi ou des pages HTML. En outre, si vous envisagez d'inclure un raccourci vers votre application, toute icône associée au raccourci doit être incluse dans les fichiers de configuration de l'application.

4. Créez le projet. Avant de créer le projet de configuration, l'Assistant Configuration résume les options que vous avez retenues. Vous pouvez ainsi revenir sur votre projet de configuration et y apporter les modifications voulues avant de l'ajouter à votre solution.


Définition des propriétés d'un projet

! Fenêtre Propriétés

" Définissez des propriétés générales

" Exemples : Author, Manufacturer, ProductName

! Boîte de dialogue Propriétés de déploiement

" Définissez des propriétés spécifiques à la configuration

" Exemples : Programme d'amorçage, Compression, Nom du fichier de sortie et Fichiers du package

" Lorsque vous effectuez une première installation sur des versions de Windows antérieures à Windows XP, vous devezinclure le programme d'amorçage dans le programmed'installation


Les projets de déploiement disposent de deux catégories de propriétés : des propriétés d'ordre général et des propriétés spécifiques à la configuration. Pour définir les propriétés générales, utilisez la fenêtre Propriétés. Ces propriétés s'appliquent à toutes les configurations de projet. Pour définir les propriétés spécifiques à la configuration, utilisez la boîte de dialogue Propriétés de déploiement.

1. Dans la fenêtre Propriétés, vous pouvez définir les propriétés du projet, notamment Author, Description, Manufacturer, ProductName, Title et Version.

2. Pour ouvrir la boîte de dialogue Propriétés de déploiement, cliquez sur Pages de propriétés dans le menu Affichage lorsqu'un projet de configuration est sélectionné dans l'Explorateur de solutions, puis cliquez sur Générer dans la liste Propriétés de configuration.

3. Le tableau ci-dessous décrit les propriétés de configuration les plus importantes.


Programme d'amorçage

Spécifie s'il faut inclure un programme d'amorçage dans le programme d'installation. Un programme d'amorçage comprend les fichiers nécessaires à l'installation de Windows Installer 1.5 sur l'ordinateur de destination au cas où il ne le serait pas déjà.

Compression Spécifie les paramètres de compression à utiliser pour les fichiers inclus dans un programme d'installation.

Introduction

Propriétés générales

Propriétés spécifiques à la configuration


(suite) Propriété Description

Nom du fichier de sortie

Spécifie l'emplacement où seront placés les fichiers .msi ou .msm lors de la génération.

Fichiers du package

Précise la façon dont les fichiers seront empaquetés à l'intérieur du fichier d'installation.

Windows Installer 1.5 est la version par défaut pour Windows XP. S'il s'agit d'une première installation sur des versions antérieures de Windows, vous devez inclure le programme d'amorçage dans le programme d'installation.

Remarque


Éditeurs de déploiement

! Utilisez les éditeurs de déploiement pour configurer le programme d'installation que vous créez

" Éditeur du système de fichiers

" Éditeur du Registre

" Éditeur des types de fichiers

" Éditeur de l'interface utilisateur

" Éditeur des actions personnalisées

" Éditeur des conditions de lancement


Les éditeurs de déploiement servent à configurer le programme d'installation que vous créez avec le projet de déploiement. Chaque projet de configuration dispose de six éditeurs : l'Éditeur du système de fichiers, l'Éditeur du Registre, l'Éditeur des types de fichiers, l'Éditeur de l'interface utilisateur, l'Éditeur des actions personnalisées et l'Éditeur des conditions de lancement.

Contrairement aux autres types de projet de déploiement, aucun éditeur ne permet de travailler avec les projets CAB. Pour ajouter des fichiers et des sorties de projet à un projet CAB, vous devez passer par l'Explorateur de solutions. Pour en définir les propriétés, il faut utiliser la fenêtre Propriétés ou les Pages de propriétés du projet.

Vous pouvez ouvrir les éditeurs de déploiement à partir de l'Explorateur de solutions, en cliquant sur le projet de configuration, puis en utilisant les boutons de la barre d'outils, comme le montre l'illustration suivante :

Introduction

Remarque

Ouverture des éditeurs


Cet éditeur permet d'ajouter des sorties de projet ainsi que d'autres fichiers à un projet de déploiement, de préciser les emplacements où seront installés les fichiers sur l'ordinateur de destination, et de créer des raccourcis sur un ordinateur de destination.

À l'aide de cet éditeur, vous pouvez accéder aux clés de Registre les plus fréquemment utilisées. Celles-ci varient en fonction du type d'application : Windows ou Web. Cet éditeur permet de définir vos propres clés et d'écrire leurs valeurs par défaut au cours du processus d'installation.

Cet éditeur permet d'établir des associations de fichiers sur l'ordinateur de destination. Il suffit pour cela d'associer des extensions de fichier à votre application et de spécifier les actions autorisées pour chaque type.

Cet éditeur permet de personnaliser les messages et les images dans les boîtes de dialogue qu'utilise l'utilisateur dans l'Assistant Installation. Vous pouvez personnaliser à la fois les programmes d'installation d'administration et standard.

Vous pouvez également ajouter des boîtes de dialogue supplémentaires au processus d'installation. Ces boîtes de dialogue peuvent, par exemple, servir à recueillir les préférences de l'utilisateur via des zones de texte et des boutons d'option, à collecter des informations utilisateur aux fins d'enregistrement ou à afficher des contrats de licence.

Cet éditeur vous permet d'inclure des actions personnalisées dans votre principal programme de configuration. Ces actions peuvent avoir lieu lors de l'installation, de la validation, de la restauration ou de la désinstallation. Parmi les actions possibles, citons entre autres l'exécution d'un fichier .exe, d'un fichier .dll ou d'un fichier script de votre choix, l'ajout ou la suppression d'utilisateurs dans une base de données ou encore l'ajout d'un contact de support technique au carnet d'adresses Microsoft Outlook®.

Grâce à cet éditeur, vous pouvez définir des conditions s'appliquant à l'installation de l'application ou à l'exécution d'actions personnalisées. Imaginons, par exemple, qu'une base de données fasse défaut sur le serveur, mieux vaut alors éviter d'y ajouter des utilisateurs, voire d'installer l'application. Selon le même principe, vous pouvez aussi vérifier des fichiers, des clés de Registre ou des installations Windows Installer. Il est également possible de personnaliser le message présenté à l'utilisateur en cas de non-respect d'une condition particulière.

Éditeur du système de fichiers

Éditeur du Registre

Éditeur des types de fichiers

Éditeur de l'interface utilisateur

Éditeur des actions personnalisées

Éditeur des conditions de lancement


Utilisation de l'Éditeur du système de fichiers

! Offre une représentation du système de fichiers sur un ordinateur de destination

! S'appuie sur le concept de dossiers virtuels pour s'assurer que les fichiers sont installés à l'endroitprécis où vous le voulez


L'organisation du système de fichiers peut varier d'un ordinateur à l'autre. Les noms de dossier peuvent également différer. L'Éditeur du système de fichiers s'appuie sur le concept de dossiers virtuels pour s'assurer que les fichiers sont installés à l'endroit précis où vous le voulez. Les dossiers virtuels de l'Éditeur du système de fichiers sont des représentations des dossiers du système Windows. Dans la mesure où Windows garde trace de l'emplacement des dossiers système, quels que soient l'emplacement ou le nom du dossier, les fichiers placés dans le dossier Bureau se retrouveront toujours dans le dossier système Bureau.

L'Éditeur du système de fichier se compose de deux parties : un volet de navigation sur la gauche et un volet de détails sur la droite. Le volet de navigation affiche une liste hiérarchique de dossiers qui reproduit le système de fichiers d'un ordinateur de destination. Dès qu'un dossier est sélectionné dans le volet de navigation, tous les fichiers et les raccourcis installés dans ce dossier s'affichent dans le volet de détails. Lorsque le n�ud de premier niveau Système de fichiers de l'ordinateur cible est sélectionné, le volet de détails affiche une liste de dossiers.

Le tableau ci-dessous décrit la fonction des dossiers par défaut affichés dans l'Éditeur du système de fichiers.

Nom de dossier Fonction

Bureau de l'utilisateur Utilisez ce dossier pour installer un raccourci de l'application sur le Bureau.

Dossier d'application Ce dossier correspond au dossier situé en dessous du dossier Program Files où l'application sera installée. Utilisez ce dossier pour installer les fichiers nécessaires à l'exécution de l'application.

Menu Programmes de l'utilisateur

Utilisez ce dossier pour installer un raccourci de l'application dans le menu Programmes.

Introduction

Présentation de l'Éditeur du système de fichiers

Dossiers par défaut


Dans l'Éditeur du système de fichiers, vous pouvez créer vos propres dossiers et sous-dossiers, et les placer à l'endroit de votre choix sous n'importe quel dossier système. Si vous créez, par exemple, un dossier Données d'application sous le dossier d'application, quel que soit l'emplacement du dossier d'application sur l'ordinateur de destination, les fichiers placés dans votre dossier Données d'application seront installés dans le même chemin de localisation relatif.

! Pour ajouter un dossier personnalisé 1. Dans le volet de navigation de l'Éditeur du système de fichiers, sélectionnez

le n�ud Système de fichiers de l'ordinateur cible. 2. Dans le menu Action, pointez sur Ajouter un dossier spécial, puis cliquez

sur Dossier personnalisé ou sur Dossier personnalisé Web. Le nouveau dossier est sélectionné dans la liste des dossiers. L'option Dossier personnalisé Web n'est disponible que s'il existe un projet de configuration Web dans la solution.

3. Donnez un nom au dossier personnalisé.

! Pour ajouter un sous-dossier 1. Sélectionnez un dossier dans le volet de navigation de l'Éditeur du système

de fichiers. 2. Dans le menu Action, pointez sur Ajouter, puis cliquez sur Dossier. Le

nouveau dossier est créé juste en dessous du dossier précédemment sélectionné dans la liste des dossiers.

3. Donnez un nom au nouveau dossier.

L'Éditeur du système de fichiers permet de créer des raccourcis de façon à vous laisser placer les fichiers dans un dossier et à les relier à un raccourci figurant sur le Bureau ou dans un autre dossier. Vous pourriez, par exemple, autoriser un utilisateur à lancer un fichier .exe via des raccourcis placés sur le Bureau de l'utilisateur et dans le menu Programmes.

! Pour ajouter un raccourci à un fichier ou à un dossier 1. Dans l'Éditeur du système de fichiers, cliquez avec le bouton droit sur le

fichier ou le dossier auquel vous voulez associer un raccourci (le fichier .exe de l'application, par exemple).

2. Cliquez sur Créer un raccourci vers Nom. Le raccourci apparaît dans la liste des fichiers.

3. Donnez un nom au raccourci, puis appuyez sur ENTRÉE. 4. Faites glisser le raccourci de la liste des fichiers vers le dossier où vous

voulez le faire apparaître sur l'ordinateur de destination (le dossier Bureau de l'utilisateur, par exemple).

Pour associer une icône au raccourci que vous créez, il vous suffit de définir la propriété Icon du raccourci dans la fenêtre Propriétés. Sachez que pour affecter une icône au raccourci, vous devez tout d'abord ajouter le fichier de l'icône au projet de configuration de l'application.

Création de vos propres dossiers

Création des raccourcis


! Pour ajouter des fichiers au dossier d'application • Dans le volet de navigation de l'Éditeur du système de fichiers, cliquez avec

le bouton droit sur Dossier d'application, pointez sur Ajouter et cliquez ensuite sur Fichier.


Génération du projet de configuration

! .NET Framework doit être installé sur n'importe quelordinateur qui exécutera une application créée à l'aide de Visual Studio .NET

! Pour installer .NET Framework, utilisez le programmed'installation redistribuable Dotnetfx.exe


Après avoir défini les paramètres de votre programme de configuration, vous pouvez générer le projet en vue de son déploiement. Jusqu'à maintenant, vous avez vraisemblablement généré des versions de débogage de votre application ; autrement dit, des versions que vous pouvez exécuter, tester et modifier dans l'environnement de développement. Dès que votre application est prête au déploiement, vous devez créer une version finale de tous les projets de votre solution.

! Pour créer une version finale de votre application 1. Dans le menu Générer, cliquez sur Gestionnaire de configurations. 2. Dans la boîte de dialogue Gestionnaire de configurations, faites passer le

paramètre de la configuration de solution active de Debug à Release. 3. Dans la colonne Générer, cochez les cases des projets que vous voulez

générer (y compris le projet de configuration), puis cliquez sur Fermer. En cas de version finale, cochez les cases de tous les projets de la solution.

4. Dans le menu Générer, cliquez sur Générer la solution.

Au cours de la génération du projet de configuration, les fichiers suivants sont créés dans le répertoire Project ou dans le répertoire Release.

Nom du fichier Description

MonProjet.msi Fichier d'informations Windows Installer utilisé par Setup.exe.

Setup.exe Copie de l'application d'installation standard.

Setup.ini Fichier d'initialisation de l'installation comprenant des informations spécifiques à votre application.

InstMsiA.exe

InstMsiW.exe

Fichiers d'installation nécessaires à l'installation de Windows Installer.

MonProjet.vdproj Fichier du projet de déploiement Visual Studio .NET utilisé par l'environnement de développement. Est créé dans le répertoire Project, et non dans le sous-répertoire Release.

Introduction

Création d'une version finale

Description des fichiers de configuration


Les applications et contrôles écrits pour le .NET Framework exigent la présence du .NET Framework sur l'ordinateur où les applications ou les contrôles s'exécuteront. La version 1.0 du .NET Framework propose un programme d'installation redistribuable, Dotnetfx.exe, qui contient les composants du CLR (common language runtime) et du .NET Framework dont vous avez besoin pour exécuter les applications .NET Framework.

Lorsqu'une vous créez une version finale de votre projet de configuration, le journal de génération affiché dans la fenêtre Sortie peut afficher l'avertissement suivant :

« Ce programme d'installation ne comprend pas le .NET Framework qui doit être installé sur l'ordinateur cible en exécutant dotnetfx.exe avant cette installation. Le fichier dotnetfx.exe se trouve sur le média Visual Studio .NET 'Windows Components Update'. Dotnetfx.exe peut être redistribué avec votre programme d'installation ».

Si le .NET Framework est déjà installé sur l'ordinateur de destination, ignorez tout simplement cet avertissement. Dans le cas contraire, vous pouvez inclure le fichier Dotnetfx.exe dans vos fichiers d'installation ou laisser l'utilisateur le télécharger sur Internet.

Pour plus d'informations sur l'installation de Dotnetfx.exe, consultez « .NET Framework Deployment Guide » à la section Liens Internet de la page Web accessible à partir du CD-ROM du stagiaire.

Installation du .NET Framework

Remarque



! Introduction au déploiement

! Déploiement d'uneapplication WindowsUtilisation


Accèsaux données Debug

and Deploy

Écriturede code

Créationd'une

interface



1. Parmi les options suivantes, quelles sont celles que vous pouvez utiliser pour empaqueter votre code en vue de sa distribution ? (Sélectionnez toutes les réponses possibles.) a. Fichiers .cab b. XCOPY des fichiers de projet c. Package Windows Installer d. Package Microsoft .NET Solution Installer Les réponses a et c sont correctes.

2. Indiquez si les instructions suivantes sont vraies ou fausses. Si une instruction est fausse, expliquez pourquoi. a. Vous devez empaqueter les modules de fusion dans un package

Windows Installer afin de le distribuer vers les utilisateurs finaux. b. Vous pouvez désinstaller une application Windows en utilisant l'option

Ajout/Suppression de programmes du Panneau de configuration. c. Vous devez inclure un programme d'amorçage dans un programme

d'installation si vous installez votre application sur des versions de Windows antérieures à Windows XP.

a. Vrai. b. Faux. Seules les applications installées au moyen de Windows

Installer peuvent être désinstallées par le biais de l'option Ajout/Suppression de programmes.

c. Vrai.


3. Quel est le rôle du fichier Dotnetfx.exe ? Dotnetfx.exe est un programme d'installation redistribuable qui sert à installer les composants du CLR (Common Language Runtime) et du .NET Framework dont vous avez besoin pour exécuter les applications .NET Framework.


Atelier 12.1 : Déploiement d'une application

! Exercice 1 : Utilisation de l'Assistant Configuration

! Exercice 2 : Installation de l'application de prêt



! créer un projet de configuration pour une application Windows à l'aide de l'Assistant Configuration ;

! installer et supprimer une application Windows.


Pour pouvoir aborder cet atelier, vous devez bien connaître les options de déploiement disponibles dans Visual Basic .NET.

Dans les ateliers des modules 2, 4, 5, 6 et 12 du cours 2560A, Introduction à la programmation en Visual Basic® .NET avec Microsoft® .NET, vous apprendrez à créer une simulation de prêt. Vous créerez l'ensemble de l'application en plusieurs étapes, chaque étape reprenant le code créé dans l'atelier précédent. Au commencement de chaque atelier, vous pouvez décider de poursuivre avec vos propres fichiers ou de démarrer avec les fichiers fournis.

Au cours de l'atelier 12.1, Déploiement d'une application, vous allez créer un programme de configuration pour l'application de prêt.


Objectifs

Remarque


Scénario

Fichiers solution



Exercice 1 Utilisation de l'Assistant Configuration

Au cours de cet exercice, vous allez utiliser l'Assistant Configuration pour créer un programme de configuration pour l'application de prêt.

! Ouvrez le projet d'application de prêt • Ouvrez le projet d'application de prêt que vous avez élaboré au cours de

l'atelier 6.1. Si vous n'avez pas réalisé l'atelier 6.1, ouvrez le fichier LoanApplication.sln qui se trouve dans le dossier dossier_installation\Labfiles\Lab121\Ex01\ Solution.

! Ajoutez un projet de configuration à la solution 1. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet. 2. Dans la boîte de dialogue Nouveau projet, dans le volet Types de projets,

cliquez sur Projets de configuration et de déploiement. 3. Dans le volet Modèles, cliquez sur Assistant Configuration. 4. Dans la zone Nom, tapez Loan Application Setup, puis cliquez sur

Ajouter à la solution. 5. Dans la zone Emplacement, tapez dossier_installation\Labfiles\Lab121\

Ex01\Starter, puis cliquez sur OK. 6. Dans l'Assistant Configuration, à la page Bienvenue dans l'Assistant

Configuration, cliquez sur Suivant. 7. Dans la page Choisir un type de projet, acceptez les valeurs par défaut

en cliquant sur Suivant. 8. Dans la page Choisir les sorties de projet à inclure, cliquez sur Sortie

principale de LoanApplication, puis cliquez sur Suivant. 9. Dans la page Choisir les fichiers à inclure, cliquez sur Ajouter.

10. Dans la boîte de dialogue Ajouter des fichiers, accédez à dossier_installation\Labfiles\Lab121\Ex01\Starter, cliquez sur App.ico, puis sur Ouvrir.

11. Dans la page Choisir les fichiers à inclure, cliquez sur Suivant. 12. Dans la page Créer le projet, cliquez sur Terminer.

! Définissez les propriétés du projet de configuration 1. Dans l'Explorateur de solutions, vérifiez que Loan Application Setup

est sélectionné. 2. Dans la fenêtre Propriétés, donnez aux propriétés du projet Loan

Application Setup les valeurs qui figurent dans le tableau suivant.

Propriété Nouvelle valeur

Manufacturer Northwind Traders

ProductName Simulation de prêt

Title Installation de Simulation de prêt


! Ajoutez un groupe de programmes et un raccourci 1. Dans l'Éditeur du système de fichiers, cliquez sur Dossier d'application. 2. Dans la liste des éléments contenus dans le dossier d'application, cliquez

avec le bouton droit sur Sortie principale de LoanApplication (Actif), puis cliquez sur Créer un raccourci vers Sortie principale de LoanApplication (Actif). Tapez Simulation de prêt et appuyez sur ENTRÉE.

3. Dans la fenêtre Propriétés, cliquez sur Icon, cliquez sur le bouton flèche vers le bas, puis cliquez sur Parcourir. a. Dans la boîte de dialogue Icône, cliquez sur Parcourir. b. Dans la boîte de dialogue Sélectionner un élément dans le projet,

double-cliquez sur Dossier d'application. c. Cliquez sur App.ico, puis sur OK. d. Dans la boîte de dialogue Icône, cliquez sur OK.


5. Dans la boîte de dialogue Sélectionner un dossier, cliquez sur Menu Programmes de l'utilisateur, puis sur OK.

! Ajoutez un raccourci sur le Bureau de l'utilisateur 1. Dans la fenêtre de l'éditeur du système de fichiers, cliquez sur Dossier

d'application. 2. Dans la liste des éléments contenus dans le dossier d'application, cliquez

avec le bouton droit sur Sortie principale de LoanApplication (Actif), puis cliquez sur Créer un raccourci vers Sortie principale de LoanApplication (Actif). Tapez Simulation de prêt et appuyez sur ENTRÉE.

3. Dans la fenêtre Propriétés, cliquez sur Icon, cliquez sur le bouton flèche vers le bas, puis cliquez sur Parcourir. a. Dans la boîte de dialogue Icône, cliquez sur Parcourir. b. Dans la boîte de dialogue Sélectionner un élément dans le projet,

double-cliquez sur Dossier d'application. c. Cliquez sur App.ico, puis sur OK. d. Dans la boîte de dialogue Icône, cliquez sur OK.


5. Dans la boîte de dialogue Sélectionner un dossier, cliquez sur Bureau de l'utilisateur, puis sur OK.


! Générez le projet de configuration 1. Dans le menu Générer, cliquez sur Gestionnaire de configurations. 2. Dans la boîte de dialogue Gestionnaire de configurations, faites passer le

paramètre de la configuration de solution active de Debug à Release, puis cliquez sur Fermer.

3. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Loan Application Setup, puis cliquez sur Générer.

Ignorez le message d'avertissement concernant Dotnetfx.exe. Ce programme de configuration ne sera installé que sur des ordinateurs où Visual Studio .NET est déjà présent.

! Quittez Visual Studio .NET • Dans le menu Fichier, cliquez sur Quitter.

Remarque


Exercice 2 Installation de l'application de prêt

Au cours de cet exercice, vous allez utiliser le programme de configuration pour installer l'application de prêt.

! Installez l'application • Double-cliquez sur le fichier Setup.exe situé dans le dossier

dossier_installation\Labfiles\Lab121\Ex01\Starter\ Loan Application Setup\Release pour installer l'application. Procédez à l'installation en utilisant les options par défaut.

! Affichez le dossier de l'application • Assurez-vous que l'application est installée dans le dossier

C:\Program Files\Northwind Traders\Simulation de prêt.

! Exécutez l'application à l'aide du raccourci du Bureau 1. Exécutez l'application en utilisant le raccourci situé sur le Bureau. 2. Quittez l'application.

! Exécutez l'application par le biais du menu Démarrer 1. Cliquez sur Démarrer, pointez sur Tous les programmes,

puis cliquez sur Simulation de prêt. 2. Quittez l'application.

! Désinstallez l'application • Supprimez l'application par le biais du Panneau de configuration.

Cette page est volontairement vide.