• Aucun résultat trouvé

[PDF] Support d’initiation à L’environnement de développement .NET | Cours informatique

N/A
N/A
Protected

Academic year: 2021

Partager "[PDF] Support d’initiation à L’environnement de développement .NET | Cours informatique"

Copied!
33
0
0

Texte intégral

(1)

Support de Cours

DEVELOPPEMENT

ET MISE EN ŒUVRE

D'APPLICATIONS

WINDOWS AVEC

MICROSOFT VISUAL

BASIC .NET 2003

Stéphane N’GUESSAN

Groupe Pigier – Abidjan

(2)

CHAPITRE 0 : INTRODUCTION ...3

I) Objectif ... 3

II) Conventions... 3

III) Informations... 3

CHAPITRE 1 : BASES DU LANGAGE VISUAL BASIC ...4

I) création d’une application... 4

II) l’environnement de développement intégré Visual Studio .NET... 4

III) structure d’un projet Visual Basic ... 5

IV) éléments fondamentaux de programmation ... 5

CHAPITRE 2 : PRESENTATION DE L’ARCHITECTURE .NET...14

I) composants d’une plateforme .NET ... 14

II) les langages .NET ... 14

III) Exécution d’une application .net... 15

IV) Programmation objet... 15

CHAPITRE 3 : CREATION DE L’INTERFACE UTILISATEUR.17 I) Programmation évènementielle... 17

II) création d’un formulaire... 18

III) Contrôles standards ... 20

IV) amélioration de l’interface utilisateur... 23

CHAPITRE 4 : VALIDATION ET TRAITEMENT DES SAISIES25 I) Limitation des entrées de l’utilisateur ... 25

II) validation au niveau champ... 27

III) validation au niveau formulaire... 29

CHAPITRE 5 : GESTION DES ERREURS...31

I) Types d’erreurs... 31

II) Déboguage ... 32

III) Gestion des exceptions ... 35

CHAPITRE 6 : ACCES AUX DONNÉES AVEC ADO.NET...37

I) Technologies antérieures d’accès aux données ... 37

II) Présentation de ADO.NET ... 37

III) Accès aux données ... 39

IV) Liaisons de données simples... 46

V) Contrôles de navigation ... 47

VI) Liaisons de données complexes... 48

VII) Modification des données ... 49

CHAPITRE 7 : DEVELOPPEMENT DE SOLUTIONS...51

I) Techniques liées aux applications MDI... 51

II) Techniques liées aux accès aux données ... 51

CHAPITRE 8 : DEPLOIEMENT D’APPLICATIONS...59

I) Méthode de déploiement... 59

ANNEXES...60

(3)

Bienvenue dans ce cours de « Développement et de Mise en œuvre d’application Windows avec Microsoft Visual Basic .NET et Microsoft Visual Studio .NET 2003».

I) Objectif

L’objectif de ce cours est de donner tous les éléments utiles pour développer des applications Windows de bonne qualité (fiable, robuste, conviviale et efficace). Ce support constitue un bon point de départ pour vous initier au langage Visual Basic .NET. Il s’appuie sur les logiciels « Microsoft Visual Studio .NET 2003 Edition Architect » et « Microsoft SQL Server 2000 Edition MSDE ».

II) Conventions

Dans ce document, nous utiliserons les conventions suivantes : - lorsque nous écrivons « cliquez sur Fichier->Ouvrir » cela

signifie « Déroulez le menu Fichier et sélectionnez l’élément Ouvrir » ;

- dans la syntaxe, les éléments entre crochets [ ] sont facultatifs ;

- dans la syntaxe, les éléments entre accolades { } sont des options où une est obligatoire. Le séparateur d’option est le caractère | .

III) Informations

Ce support de cours est libre de droit de reproduction. Vous pouvez le redistribuer sous toutes ses formes. Bien que toutes les précautions aient été prises lors de sa rédaction, nous déclinons toutes responsabilités concernant la fiabilité et l’exhaustivité du présent support. Nous vous saurions gré toutefois, de nous signaler toutes les imperfections que vous pourriez rencontrer pendant la lecture, de ce document.

Bonne Lecture !

Stéphane N’GUESSAN snb@powernet.ci

MCP Visual Basic .NET, MCDBA SQL Server 2000, MCSE 2000 Développeur Visual Basic depuis 1994

Groupe Pigier - Abidjan

Visual Basic .NET est la dernière évolution dans la famille des langages de programmation Visual Basic de Microsoft. Introduit en 1991, ce langage a évolué et s’est décliné en plusieurs éditions (Visual Basic Application, Visual Basic Script, etc.). Visual Basic .NET a su conserver les principes de bases tout en y apportant d’excellentes améliorations.

I) création d’une application

D’une façon générale, la création d’une application en Visual Basic passe par plusieurs étapes :

a) Conception de l’application (avec MERISE ou UML) b) Création de l’interface

• Définition des propriétés des objets de l'interface utilisateur

c) Ecriture du code d) Tests et déboguage

e) Génération et Déploiement

• Création d'un fichier exécutable • Création d'un programme d'installation Exemple :

Création d’une application permettant d’envoyer un message "Bonjour" suivi du nom d’une personne préalablement saisie.

Pour commencer une application Windows avec MS Visual Studio .NET 2003, on clique sur : Nouveau projet-> type de projet « Visual Basic » -> et le modèle « Application Windows », puis on valide. Pour faire marcher le bouton bonjour créé dans l’application, il faut cliquer sur lui et écrire le code suivant :

Msgbox("bonjour" & textbox1.text)

II) l’environnement de développement intégré Visual Studio .NET

L’environnement de développement intégré (EDI) Visual Studio .Net se lance à partir du menu Démarrer->Programme->Microsoft Visual Studio .Net 2003. Cet environnement de développement, est identique pour tous les langages (Visual Basic, Visual C++, Visual C# (prononcer C Sharped) , etc.) de la suite Visual Studio .NET.

(4)

III) structure d’un projet Visual Basic

Une application développée en Visual Basic .Net utilise différents types de fichiers :

• Une solution (le fichier de plus haut niveau) comprend une ou plusieurs applications (projets). Il utilise l’extension .sln ; • Les applications (appelées aussi projets) font l’objet d’une

compilation. Ils utilisent l’extension .vbproj ;

• Le fichier application comprend une référence de tous les éléments contenus dans l’application (formulaire, classes, modules…). Alors que VB6 utilisait des extensions différentes par types de fichiers (formulaires .frm, classes .cls, modules .bas) VB.NET utilise l’extension .vb pour la plupart des fichiers.

NB : les fichiers obtenus par des ressources externes au langage de programmation conservent leurs extensions. Ex : Crystal Report .rpt IV) éléments fondamentaux de programmation

1. les variables

Une variable est un objet de programmation qui permet de contenir une valeur. Cette valeur est d’un type bien déterminé. Visual Basic propose plusieurs types de données :

- Entier : byte (1o), short (2o), integer (4o), long (8o) - Réel : single (4o), double (8o), decimal (12o)

- Alphanumérique : char(2o unicode), string (taille varie) - Autres : date (8o), boolean (2o), object

On utilise le mot clé « DIM » pour déclarer une variable, et le symbole d’égalité (=) pour affecter une valeur à une variable.

Syntaxe :

DIM [Variable1] [,...] [AS Type] [=ValeurInitiale]

Exemple :

DIM nom, prénom as String

DIM jour as Date=#01/01/2003 15:56:23# Nom="KONAN"

Par défaut, le compilateur de Visual Basic .NET considère que toute variable qui apparaît dans le code doit être déclaré. Ce comportement peut être modifié par l’instruction suivante :

Option Explicit Off

Les tableaux permettent de faire référence à un ensemble de variables avec un nom unique et d’utiliser un indice pour les différencier.

Exemple :

DIM Temperature(11) AS Single ' declare un tableau de 12 éléments DIM Nom() as String={"YAO","KONAN"} DIM Matrice(9,9) as Interger

Temperature(0)=30 Matrice(0,0)=10

En VB.NET, les tableaux commencent toujours avec l’indice 0 (l’option base 1 de VB6 n’est plus prise en charge).

L’instruction « REDIM » permet de modifier les dimensions d’un tableau. Son option « Preserve » permet de conserver le contenu du tableau devant être redimensionner.

Exemple :

REDIM Preserve Temperature (12)

Lorsque vous déclarez une variable avec le mot clé « DIM », sa portée se limite au même niveau (bloc, procédure, module) que sa déclaration. Vous pouvez étendre se comportement en utilisant l’un des mots clés suivants :

- Public : la variable est utilisable dans toute la solution - Friend : la variable est utilisable dans tout le projet - Private : la variable est utilisable dans le module

- Static : le contenu de la variable est conservé entre différents appels

Vous pouvez utiliser les fonctions Val(), CStr(), Cint(), CDbl(), etc ., pour convertir une variable en un type donnée, comme en VB6 ou utiliser la nouvelle fonction CType() dont la syntaxe est la suivante :

CType (expression, type_de_donnee)

Exemple :

DIM i as Integer=100, l as Long l=CType(i, Long)

La méthode ToString permet de convertir toute expression en chaîne de caractère.

Exemple :

DIM i as Integer=100 Msgbox(i.ToString)

(5)

Le compilateur de Visual Basic .NET prend en charge prend en charge certaines conversions de type automatiquement. Ce comportement peut être modifié par l’instruction suivante :

Option Strict On

Vous pouvez définir vos propres types de données en utilisant le mot clé Structure … End Structure.

Exemple :

Structure Voiture

Dim Marque As String 'Public est la portée par défaut Public Model As String

Private Numero as String End Structure

La structure possède un modificateur de son niveau d’accès nommé Protected qui restreint l’accès à sa propre classe et à ses classes dérivées uniquement.

2. les constantes

Une constante est un objet de programmation qui ne change pas de valeur durant toute la durée du programme. Il se déclare par le mot clé « Const ».

Exemple :

Const taux= 655.957 Const monnaie= "FCFA"

Const Pi as Double = 3.14159265

Une énumération est une liste de constantes, liées entre elles. Exemples : ENUM Jours Dimanche=1 Lundi=2 Mardi=3 Mercredi=4 Jeudi=5 Vendredi=6 Samedi=7 END ENUM 3. les opérateurs

Les opérateurs arithmétiques de base sont : + (addition) – (soustraction) * (multiplication) / (division) \ (division entière) Mod (reste de la division entière) ^ (puissance).

Dans une opération arithmétique, vous pouvez imposer l’ordre d’évaluation des opérateurs en utilisant les parenthèses.

Exemple :

+

=

S’écrit x= (a+b)/c-d

Les opérateurs de concaténation sont : & (force la conversion des opérandes avant la concaténation) + (ne force pas la conversion des opérandes).

Visual Basic .NET propose de nouveaux opérateurs simplifiés permettant l’affectation des variables :

Addition x = x + 2 x += 2 Soustraction x = x – 6 x -= 6 Multiplication x = x * 3 x *= 3 Division x = x / 4 x /= 4 Concaténation x = & "ABC" x &= "ABC"

Les opérateurs logiques sont : And (Et) Or (Ou) Xor (Ou exclusif) Not (Négation) AndAlso (identique à And mais l’opérande 2 n’est testée que si l’opérande 1 n’est vraie) OrElse (identique à Or mais l’opérande 2 n’est testée que si l’opérande 1 est fausse).

Les opérateurs de comparaison sont : = (égalité) <> (inégalité) < (inférieur) > (supérieur) <= (inférieur ou égal) >= (supérieur ou égal) Like (comparaison de chaîne de caractère avec la possibilité d’utilisé les caractères génériques ? pour un caractère et * pour n’importe qu’elle suite de caractère).

NB : Par soucis de compatibilité ascendante, True correspond à la valeur -1 et False à la valeur 0.

4. les structures de décision

Les structures de décision aiguillent l’exécution du code en fonction des valeurs que prend une expression.

La structure IF…THEN utilise la syntaxe suivante :

IF condition THEN instruction

Ou

IF condition THEN Instructions

[ELSE | ELSEIF (condition)] THEN Instructions

END IF

Exemple : Ecrire un code qui calcule le taux de commission en fonction des critères suivants:

(6)

Montant< 500.000 taux=10%

Montant (500.000 et 5.000.000) taux=5% (pour la partie>500.000)

Montant > 5.000.000 taux=1% (pour la partie>5.000.000)

If montant< 500.000 then

Commission = (montant*0.1) ElseIF montant< 5.000.000 then

Commission= 50.000 + (montant-500.000)*0.05 Else

Commission= 275000+ (montant-500.000)*0.01 End IF

L’instruction IIF permet de remplacer un IF THEN. Sa syntaxe est la suivante :

IIF(Condition,ValeurSiVrai,ValeurSiFaux)

La structure SELECT…CASE offre plus de possibilités d’aiguillage en fonction de la valeur d’une expression.

Exemple :

SELECT CASE moyenne CASE is <10 Msgbox ("Mauvais") CASE 10,11,12 Msgbox ("Passable") CASE 13 to 19 Msgbox ("Bien") CASE 20 Msgbox ("Très bien") CASE ELSE Msgbox ("Erreur") END SELECT

L’instruction Switch permet d’indiquer un ensemble d’expressions et de valeurs associées.

Exemple :

Resultat=Switch(Rep=221,"Sénégal",Rep=33,"France")

L’instruction Choose permet de choisir une valeur en fonction d’un index.

Exemple :

Monnaie=Choose(code,"FCFA","US$","€")

5. les boucles

Les boucles ont pour but d’exécuter plusieurs fois, un même bloc de code.

L’instruction FOR…NEXT permet d’exécuter un bloc de code, un nombre définit de fois. Sa syntaxe est la suivante :

FOR variable = Debut TO Fin [STEP Increment] Instructions

NEXT [variable]

Vous pouvez sortir d’une boucle FOR avant la fin du nombre d’itérations en utilisant EXIT FOR.

Une autre syntaxe de FOR…NEXT permet d’exécuter du code pour chaque élément d’un tableau.

FOR EACH element IN tableau Instructions

NEXT [elements]

L’instruction DO…LOOP permet d’exécuter une instruction un nombre indéfinie de fois. Sa syntaxe est la suivante :

DO { UNTIL | WHILE } Condition Instruction

LOOP

Ou

DO

Instruction

LOOP { UNTIL | WHILE } Condition

Avec UNTIL, la boucle se répète lorsque la condition est fausse alors qu’avec WHILE, la boucle se répète lorsque la condition est vraie. La deuxième syntaxe garantie que les instruction de la boucle seront exécuter au moins une fois. L’instruction EXIT DO provoque une sortie anticipée et inconditionnelle de la boucle DO…LOOP. 5. les procédures et fonctions

Les procédures et fonctions sont des blocs réutilisables de code. Elles peuvent prendre plusieurs paramètres. Une procédure ne retourne pas de valeur tandis qu’une fonction en retourne toujours une. Le mot clé de déclaration d’une procédure est SUB…END SUB et pour une fonction FUNCTION…END FUNCTION.

Syntaxe :

[Private|Friend|Public|Protected] SUB NomProcedure ([ [Optional] [Byval|ByRef] param1 as Type1 [=Defaut][,]])

'Instructions END SUB

[Private|Friend|Public|Protected] FUNCTION NomFonc ([ [Optional] [Byval|ByRef] param1 as Type1 [=Defaut][,]]) AS Type

(7)

'Instructions

{NomFonction=valeur | Return valeur} END FUNCTION

Exemple:

FUNCTON SurfaceCercle (r as single) as single CONST Pi=3.14

Return (Pi*r^2) END FUNCTION

Lorsque vous déclarez une procédure, vous pouvez préciser quelle sera sa portée grâce à l’un des mots clés suivants :

- Private : Par défaut. La procédure n’est visible que par les instructions du même niveau ;

- Friend : la procédure utilisable dans tout le projet ;

- Public : la procédure est utilisable dans les autres projets ; - Protected : la procédure est utilisable par les instructions de

même niveau et par les instructions des classes dérivées. Les paramètres des procédures et fonctions sont gérés par les mots clés suivants :

- Optional : indique que ce paramètre peut être omis au moment de l’appel de la procédure. Tous les paramètres qui suivent ce paramètre doivent aussi être déclarés comme optionnels.

- = : précise la valeur d’un paramètre optionnel en cas d’omission au moment de l’appel;

- ByVal : La valeur du paramètre est passée à la procédure ; Il s’agit du mode de passage par défaut.

- ByRef : la référence du paramètre est passée à la procédure. Toutes les modifications du paramètre demeurent, même après la fin de la procédure.

Vous pouvez organiser vos procédures, fonctions et variable sous forme d’unité logique appelée module. L’utilisation des modules permet de structurer votre code, simplifie sa lecture et sa réutilisation. La syntaxe de création d’un module est la suivante :

[Public | Friend] Module NomDuModule 'Instructions

END Module

Vous pouvez créer un module en cliquant sur Projet -> Ajouter un Module.

Les procédures événementielles se distinguent des procédures classiques par le fait quels sont appelées automatiquement

lorsqu’un évènement survient. Elles utilisent le mot clé Handles. Visual Basic .NET génère à la demande, l’entête des procédures évènements que nous conseillons fortement d’utiliser. Pendant l’exécution, le mot clé AddHandler permet d’ajouter un gestionnaire à un évènement et le mot clé RemoveHandler permet de le supprimer.

Exemple :

Sub No_Click(ByVal sender As Object, ByVal e As

System.EventArgs) Handles BtnNo.Click, BtnCancel.Click 'Instructions

End Sub

Le langage VB comprend un nombre important de procédures et de fonctions prêtes à l’emploi. Une liste de ces principales procédures et fonctions se trouve en Annexe I. Parmi celles-ci, nous avons InputBox et MessageBox.Show (qui devrait remplacer la procédure MsgBox).

InputBox : Affiche une boite de dialogue avec une zone de saisie pour

recueillir une entrée de l’utilisateur

Syntaxe

InputBox(prompt[, title][, default][, xpos][, ypos]) Prompt : Message à afficher

Title : Titre de la boite de dialogue Default : Réponse par défaut attendue

Xpos, Ypos : position du bord haut gauche de la boite de dialogue

Exemple

Matricule = InputBox("Entrez votre numéro Matricule")

MessageBox.Show : Affiche une boite de dialogue qui affiche un message

et attend que l’utilisateur clique sur un bouton. VB.NET a introduit ce nouvel objet en remplacement de la procédure MsgBox.

Syntaxe

(8)

Prompt : Message à afficher

Title : Titre de la boite de dialogue

Buttons : Définit les boutons à afficher. Parmi les options disponibles, nous avons OKOnly, OKCancel, AbortRetryIgnore, YesNoCancel, YesNo,RetryCancel.

Icon : Définit l'icône à afficher. Parmi les options disponibles, nous avons Critical, Question, Exclamation, Information.

Exemple

MessageBox.Show("Etes vous sur de vouloir quitter ?")

6. Commentaires

Les commentaires sont des parties de texte insérées dans le code pour en expliquer le but. Les commentaires ne sont pas exécutés. Le caractère « ' » et l’instruction REM permettent de créer des commentaires.

Une région de code est un découpage logique de vos instructions. L’instruction #REGION…#END REGION permet de créer vos propres régions.

Visual Basic .NET génère automatiquement du code qu’il inclut dans la région « Code généré par le concepteur Windows Form », pour le masquer et permettre au développeur de se concentrer sur leurs propres codes.

La plateforme .NET est un environnement intégré et managé de développement et d’exécution de code.

I) composants d’une plateforme .NET

La plateforme .NET comprend les composants suivants :

.NET framework gère tous les aspects de l’exécution du programme. Ceci comprend l’allocation, la réallocation et le nettoyage de la mémoire, l’autorisation ou le refus d’accès aux ressources, la gestion des erreurs etc.…

CLR (common language runtime) : c’est ce composant qui gère l’exécution du code (compilation, allocation de mémoire, gestion des processus…). Avec le CTS (common type system) il assure un contrôle strict des types de données et un environnement d’exécution protégé ainsi qu’une gestion de la sécurité.

La bibliothèque de classe (class library) : elle fournie une collection de méthodes et de propriétés conçues pour être utilisées avec le CLR. Ces méthodes et propriétés sont accessibles par la rotation orienté objet et son extensible. II) les langages .NET

L’architecture .NET est conçue pour assurer une compatibilité entre les différents langages de programmation. Ce niveau de compatibilité n’est possible que par le respect des spécifications du Common Language Specification (CLS). Le développement d’application pour la plateforme .NET ne nécessite donc pas d’apprendre un nouveau langage de programmation. Tout langage qui respecte le CLS (ex : Delphi) peut être utilisé.

L’unité logique d’exécution d’une application .net est l’assembly (assemblage en français). Il s’agit d’une collection de plusieurs objets .exe .dll en autres fichiers de ressources. Le manifeste d’un assemblage fournit des informations telles que :

- liste des autorisations requises par l’application ; - liste des propriétés et méthodes exposées ;

- des informations d’identité telles que le nom et la version.

(9)

Les assemblages sont créés automatiquement lors de la compilation depuis l’EDI ou par la commande VBC.EXE

III) Exécution d’une application .net

Lorsque vous compilez une application .net vous obtenez du code Microsoft Intermediate Language (MSIL) et un assemblage. Quand l’exécution du programme commence le CLR charge en mémoire le code MSIL et examine le manifeste de l’assemblage. Si toutes les conditions de sécurité et d’exécution sont remplies le CLR exécute le code. Lorsque l’exécution démarre pour chaque partie de code MSIL en code binaire (code machine). Ce code est alors exécuté et enregistré de sorte que le JIT n’est plus à recompiler cette partie. IV) Programmation objet

Comme la création d’une maison s’appuie sur un plan, il faut un « moule » pour créer un objet. En Visual Basic, ce moule se nomme une classe. La classe va servir à créer un objet que l’on nomme aussi une instance de la classe.

1) Concepts de programmation orienté objet

La programmation objet s’appuie sur les concepts suivants :

- l’encapsulation : permet de regrouper les données (propriétés) et les procédures permettant de les manipuler (méthodes) en une seule unité logique ;

- l'abstraction : elle protège la modification des propriétés d'un objet en dehors des méthodes de l’objet. Ceci sert à prévenir des modifications "accidentelles" des données d'un objet par des fonctions externes à la classe ;

- l'héritage: mécanisme par lequel une classe dérivée (ou classe fille) hérite de toutes les caractéristiques de sa classe de base (ou classe mère) ;

- la surcharge: technique qui permet d'utiliser le même nom de fonction avec des paramètres de types différents ;

- le polymorphisme : c’est un mécanisme via lequel un objet peut prendre plus d'une forme ;

- constructeur et destructeur : un constructeur est une procédure spéciale qui est automatiquement exécutée quand un objet est créé. Cette procédure se nomme New(). Par opposition, un destructeur est une procédure qui est

automatiquement exécutée à la mort de l'objet. Cette procédure se nomme Finalize().

La déclaration d’une classe se fait en utilisant le mot clé Class … End Class.

Exemple :

Public Class Personne Dim Nom As String Dim Prenoms As String Dim Date_Naissance As Date Function Age() as short

Return DateDiff(Year,Date_Naissance,Now()) End Function

End Class

La classe s’utilise de la façon suivante :

Dim unePersonne As Personne unePersonne = New Personne() unePersonne.Nom="KONAN"

Ou simplement

Dim unePersonne As New Personne

unePersonne.Date_Naissance=#11/05/05#

(10)

L’interface utilisateur fournit un mécanisme qui permet aux utilisateurs d’interagir avec votre application. Il est donc essentiel, de créer des interfaces simples et conviviales.

I) Programmation évènementielle 1. Concepts de base

A la différence de la programmation séquentielle, où les instructions s’exécutent de manière séquentielle, VB est un langage qui permet de réaliser de la programmation par événements, c’est à dire programmer des procédures qui s’exécutent quand un événement est déclenché. La plupart du temps, l’événement est déclenché par l’utilisateur du programme mais il peut l’être aussi par le système. 2. présentation des propriétés, méthode et évènements

Les classes décrivent les propriétés, méthodes et évènements qui constituent les objets. Les propriétés sont les caractéristiques d’un objet telle que la taille (Size) ou la position (Location). Les méthodes sont les actions qu’un objet peut accomplir telle que afficher (Show) ou Fermer (Close). Les évènements sont des éléments auxquels l’objet sait réagir tel que « clique sur le bouton gauche de la souris » (Click).

3. Propriétés communes des objets de programmation

La plupart des objets de programmation (Formulaires, Contrôles, etc.) possèdent les propriétés suivantes :

- Name: indique le nom utilisé dans le code pour référencer l’objet. A l’intérieur d’un même formulaire, la valeur de la propriété Name doit être unique. Elle permettra d’accéder aux différentes propriétés et d’appeler les différentes méthodes de l’objet. A l’intérieur du formulaire, vous pouvez accéder aux propriétés et méthodes du formulaire en utilisant le mot clé « Me ».

Exemple : Me.Width

Lorsqu’un contrôle est placé sur un formulaire, VB lui affecte un nom, généré automatiquement, composé du nom du contrôle, suivi d’un chiffre. Microsoft recommande de donner un nom plus parlant à chaque objet en respectant la convention suivante :

- utiliser uniquement des lettres, des chiffres et des soulignés ;

- commencer le nom par une lettre ou un souligné ; - ne pas utiliser des mots clés du langage VB ; - utiliser tant que possible la casse (ex : BonNom) ; - utiliser des substantifs pour les objets et verbes pour

les méthodes.

- Size : indique la taille d’un objet en pixel. Elle se compose de la largeur (width) et de la hauteur (height).

- Location : indique la position du bord haut gauche du contrôle par rapport à son conteneur. Elle se compose de position par rapport au bord gauche (X) et de la position par rapport bord haut (Y).

- MaximunSize : indique la taille maximale d’un objet ; - MinimumSize : indique la taille minimale d’un objet ; - Visible : détermine si le contrôle est affiché ou masqué. II) création d’un formulaire

Pour créer une application Microsoft Windows, il faut commencer par créer un formulaire.

1. création

Chaque formulaire est une classe qui hérite de la classe System.Windows.Forms.Form. Depuis l’EDI vous avez plusieurs méthodes pour ajouter un formulaire à votre application. Exemple : Projet -> Ajouter un formulaire Windows.

Un formulaire est une fenêtre de votre application qui est capable de contenir des contrôles. Ses propriétés caractéristiques sont les suivantes :

- Text (string): détermine le texte affiché dans la barre de titre ; - ControlBox (boolean) : détermine si le formulaire affiche les

bouton système dans le coin droit ;

- MinimizeBox (boolean) : détermine si le bouton réduire apparaît dans le coin;

- MaximizeBox (boolean) : détermine si le bouton agrandir apparaît dans le coin;

(11)

- FormBorderStyle : contrôle l’apparence de la bordure du formulaire ;

- Opacity : définit l’opacité (ou la transparence) du formulaire. La valeur 0% correspond à transparent et 100% à opaque ; - TransparencyKey :

- Icon : définit l’icône utilisée par le formulaire ;

- TopMost : permet de conserver le formulaire au premier plan, même si il n’a pas le focus.

Il possède les méthodes suivantes : - Show : affiche le formulaire;

- Hide : cache le formulaire (il n’est plus visible mais reste en mémoire) ;

- Close : ferme le formulaire (et décharge de la mémoire) ; - CenterToScreen, CenterParent : Place le formulaire au

centre de l’écran.

Un formulaire réagit aux évènements suivants :

- Load : se produit lors de la première apparition du formulaire ;

- Activated : se produit lorsque le formulaire reçoit le focus; - Deactivate : se produit quand le formulaire perd le focus ; - Closing : se produit au moment de la fermeture, avant la

fermeture ;

- Closed : se produit au moment de la fermeture, après la fermeture.

2. Gestion d’un formulaire

En VB.NET, un formulaire peut en appeler un autre. Le code permettant de réaliser cette opération est différent de celui utilisé en VB6 du fait que VB.NET considère les formulaires comme des classes alors que VB6 les considéraient comme des objets.

Un formulaire peut en afficher un autre selon deux modes :

- Mode non modal : l’utilisateur peut passer librement d’un formulaire à l’autre ; la méthode Show affiche un formulaire dans ce mode ;

- Mode modal : l’utilisateur ne peut pas interagir avec d’autres formulaire de l’application tant que le formulaire en mode modal n’est pas fermé. La méthode ShowDialog affiche un formulaire dans ce mode.

Exemple :

Dim Frm As New Form1

Frm.Show()

Lorsque que souhaitez que votre application lance au démarrage un formulaire autre que le premier ou lorsque vous modifiez le nom de votre premier formulaire, vous devez précisez le nom de « l’objet de démarrage » de votre application. Cette précision se fait dans le menu Projet -> Propriété de … Puis choisir dans la liste déroulante « Objet de démarrage ».

3. Les Applications MDI

Dans les applications Multiple Document Interface (MDI), une feuille principale (appelée feuille Mère) agit comme conteneur pour les autres feuilles (appelées feuilles filles) de l’application. La feuille MDI est la feuille mère qui appelle les feuilles filles.

La propriété IsMdiContainer permet de transformer n’importe quel formulaire en Feuille Mère quand on lui affecte la valeur true.

Une feuille fille doit être lancée en précisant sa feuille mère grâce à la propriété MdiParent.

Exemple :

Dim Frm As New Form2 Frm.MdiParent=Me Frm.Show()

La propriété ActiveMdiChild permet de déterminer la feuille fille active à tout moment.

Exemple :

Me.ActiveMdiChild.Close() 'Ferme la feuille active

III) Contrôles standards

Les contrôles sont des objets pré-programmés dont l’utilité principale est de faciliter l’interaction avec l’utilisateur.

Chacun de ces objets

graphiques a une fonctionnalité bien précise. Les contrôles standards sont fournis par Microsoft et ne nécessitent pas de licence supplémentaire avant d’être utilisés. Vous pouvez créer vos propres contrôles (on parle

(12)

alors de contrôle personnalisé) ou acquérir des contrôles conçus par des éditeurs de logiciels tiers.

Dans la Boite à outils, le « Pointer » désigne simplement le mode dans lequel vous pouvez sélectionner les autres contrôles.

1. Le contrôle Label

Il permet d’afficher un texte. Ses propriétés caractéristiques sont les suivantes :

- Autosize (boolean) : active le dimensionnement du contrôle en fonction du contenu;

- BackColor : la couleur d’arrière-plan; - ForeColor : la couleur du texte;

- Font : la police utilisée pour afficher le texte; - Text (string): contient le texte affiché.

2. Le contrôle TextBox

Il permet d’afficher et de saisir un texte. Ses propriétés caractéristiques sont les suivantes :

- BorderStyle : determine le type de bordure du contrôle ; - Enabled (boolean) : contrôle si le texte accepte les saisies ; - MultiLine (boolean) : contrôle si le texte saisi peut s’étendre

sur plusieurs lignes;

- Text (string): contient le texte saisi et affiché ;

- TextAlign : Indique la façon dont le texte doit être affiché. Les valeurs possibles sont Left, Right et Center ;

- ScrollBars : contrôle l’affichage des barres de défilement. Les valeurs possibles sont None, Horizontal, Vertical et Both ;

- WordWrap (boolean): contrôle le renvoie automatique à la ligne.

Il réagit aux évènements suivants :

- KeyPress : on a appuyé une touche du clavier ;

- TextChanged : La valeur stockée par le contrôle change 3. Le contrôle Button

Il est principalement utilisé pour lancer l’exécution d’une procédure après l’action d’un utilisateur. Ses propriétés caractéristiques sont les suivantes :

- BackGroundImage : définit l’image d’arrière plan ; - Image : définit l’image affichée sur le contrôle ;

- ImageAlign : définit l’une des 9 positions possibles pour l’image sur le contrôle ;

- FlatStyle : détermine l’apparence lorsque l’utilisateur survole le contrôle;

- Text : contient le texte affiché; Le caractère & permet de définir une touche d’accès. Pour afficher le caractère « & » saisissez « && ».

- TextImageRelation : spécifie l’emplacement relatif de l’image par rapport au texte sur le bouton.

Ce contrôle réagit aux évènements suivants :

- Click : clique sur le bouton gauche de la souris ;

- DoubleClick : double clique sur le bouton gauche de la souris ;

- MouseMove : la souris a été déplacée. 3. Les contrôles RadioButton et CheckButton

Ils permettent de faire des boutons d’options (RadioButton) et des Case à cocher (CheckButton). La différence majeure en ses deux contrôles est qu’avec un RadioButton vous ne pouvez choisir qu’une seule option alors qu’avec un CheckButton, vous pouvez en choisir plusieurs. Les propriétés caractéristiques sont les suivantes :

- Checked (boolean): indique si l’option est activée;

- CheckAlign : détermine l’emplacement du bouton (ou de la case à cocher) dans le contrôle ;

- Text : contient le texte affiché par le contrôle. 4. Les contrôles GroupBox et Panel

Ce sont des contrôles particuliers car ils peuvent contenir d’autres contrôles (appelés aussi conteneur de contrôle). Ces contrôles permettent de grouper logiquement et physiquement des contrôles. Les contrôles contenus dans ces conteneurs se déplacent avec leur conteneur. La modification de certaines propriétés (Enabled, BackColor, ForeColor, Font) du conteneur s’applique aux contrôles contenus.

La différence entre ces deux contrôles est que le contrôle GroupBox offre une étiquette paramétrable grâce à sa propriété Text tandis que le contrôle Panel possède une propriété AutoScroll qui permet d’activer des barres de défilement.

5. Le contrôle PictureBox

Il permet d’afficher des images de plusieurs format (jpeg, bmp, etc.). Ses propriétés caractéristiques sont les suivantes :

(13)

- SizeMode : détermine la façon dont le contrôle gère le placement de l’image et ses dimensions.

6. Les contrôles ListBox, CheckedListBox et ComboBox

Le contrôle ListBox permet d’afficher une liste de plusieurs éléments parmi lesquels l’utilisateur peut faire un choix. Le contrôle CheckedListBox rajoute une case à cocher devant chaque élément de la ListBox. Il permet ainsi de sélectionner plusieurs éléments. Le contrôle ComboBox affiche une zone de texte modifiable avec une liste déroulante des valeurs autorisées. Ces contrôles possèdent une propriété Items qui permet de définir la liste des valeurs affichées. Sorted : CheckOnClick NumericUpDown DomainUpDown DateTimePicker (Format,ShowUpDown,MaxDate,MinDate) MonthCalender(ShowToday,ShowTodayCircle,CalenderDimension) IV) amélioration de l’interface utilisateur

Une interface utilisateur peut facilement être enrichie grâce à plusieurs contrôles.

1) Le contrôle ImageList

Il permet de gérer une collection d’images qui pourront être utilisés dans d’autres contrôles. Il possède les propriétés suivantes :

- Images : stocke les images ;

- ImageSize : définit la taille en pixel de chacune des images. Chacune des images possède un index dont les valeurs commencent à partir de zéro.

2) Les propriétés d’ancrage

Ils permettent de modifier le comportement d’un contrôle dans le formulaire :

- Anchor : permet de forcer le maintien d’une distance constante entre un contrôle et un ou plusieurs bords d’un formulaire. La valeur par défaut est Top,Left ;

- Dock :

Graphiques

La réalisation d’objets graphique sur les formulaires, passe par l’écriture d’un code, dans l’évènement Paint du formulaire et utilisant la classe System.Drawings. Le contrôle Graphics utilisé dans Visual Basic 6 n’est plus disponible.

Exemple :

Private Sub Form1_Paint(...)

Dim gra As System.Drawing.Graphics gra = Me.CreateGraphics

gra.FillRectangle(Brushes.Black, 0, 0, 100, 100) End Sub

(14)

! " #

La validation et le traitement des saisies garantissent que les données saisies par l’utilisateur sont conformes à celles attendues par votre application. Ex : plaque d’immatriculation : 3333AA03 I) Limitation des entrées de l’utilisateur

Dans la plupart des applications que vous créer, les utilisateurs doivent entrer des informations qui seront traitées. Il est important que votre application s’assure bien que les informations saisies sont valides afin d’éviter des erreurs dans les traitements.

1. Directives pour la validation des saisies

Afin d’obtenir une application fiable, vous devrez vous efforcer à suivre le plus possible les directives suivantes :

- 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

- Penser aux implications liées à la validation lors de la conception de l'application

2. Validation intrinsèque

Certains contrôles possèdent des méthodes et propriétés qui permettent de restreindre automatiquement les données saisies par les utilisateurs. Parmi ces contrôles, nous pouvons citer :

RadioButton : Restreint les entrées à On/Off ou Oui/Non; CheckBox : Restreint les entrées à Checked ou Unchecked; CheckedListBox : Fournit une liste d'entrées valides;

ListBox : Fournit une liste d'entrées valides (graphiques et texte);

DateTimePicker : Restreint les entrées à des dates ou à des heures;

MonthCalendar : Restreint les entrées à une plage de dates 3. Propriétés du contrôle TextBox

Le contrôle TextBox propose des propriétés utiles dans la validation (intrinsèque) des données saisies :

MaxLength : définit un nombre maximal de caractères à entrer dans une zone de texte ;

Enable : indique si le contrôle est activé ;

ReadOnly: fournit une information qui ne peut pas être modifiée ;

CharacterCasing : Définit tous les caractères d'une zone de texte en majuscules (Upper) ou en minuscules (Lower); • PasswordChar : Cache ou masque les caractères entrés

dans une zone de texte. 4. Ordre de tabulation

L’ordre de tabulation définit la séquence dans laquelle le focus passe d’un contrôle à un autre, lorsque l’on appuie sur la touche tabulation. Voudrez veuillez a ce que cet ordre facilite la saisie des données car boutons d’utilisateurs privilégie l’utilisation de la tache tabulation pendant la saisie de volumes importants de données. L’ordre de tabulation peut être définit manuellement par la propriété TabIndex en indiquant un valeur numérique correspondant au numéro d’ordre du contrôle ou graphiquement en cliquant sur le menu Affichage -> Ordre de tabulation et en sélectionnant successivement les contrôles dans l’ordre.

5. Propriété du contrôle MaskEdit

Le contrôle MaskEdit permet d’obtenir des restrictions plus poussées sur les entrées des utilisateurs.

Ces propriétés utiles sont :

Mask : définit un masque de saisie pour le contrôle. Elle utilise les caractères génériques suivants :

o # : caractère numérique requis o 9 : caractère numérique optionnel

(15)

o ? : caractère alphabétique (a-z, A-Z) requis o & : caractère alphabétique (a-z, A-Z) optionnel o > : convertit l’entrée en majuscule

o < : convertit l’entrée en miniscule o A : caractère alphanumérique requis o a : caractère alphanumérique optionnel

Ex : (###)999-9999 pour (123)223-0001

Format: définit le format de présentation des données FormattedText : retourne la donnée saisie avec le masque ClipText : retourne la donnée sans le masque de saisie Le contrôle MaskEdit n’est pas disponible par défaut dans la boîte à outils. Il faut donc l’ajouter en faisant :

a. Assurer vous que l’onglet Formulaire Windows est active dans la boite à outils.

b. Dans le menu Outils, cliquez sur Personnaliser la Boîte à Outils.

c. Dans l’onglet Composant COM, cocher Microsoft Masked Edit Control, version 6.0, et cliquer sur OK.

Le control MaskEdit sera ajouter à la boite à outils comme dans l’illustration suivante:

II) validation au niveau champ

La validation au niveau champ à lieu pendant la saisie ou juste au moment ou le contrôle perd le focus.

1. Evènement de validation

Tous les contrôles fournissent des évènements permettant de gérer la validation de leur contenu. Ces évènements sont :

Validating : Se produit lorsque le control est en cours de validation. Cet ’évènement gère une variable e de type CancelEventArgs dont la propriété cancel lorsqu’elle est initialisée à True permet d’annuler la perte du focus.

Validated : Se produit lorsque le control a fini sa validation. La propriété CauseValidation commande le déclenchement des évènements validating et validated.

Pendant la saisie, chaque touche du clavier appuyée et relachée génère successivement les évènements KeyDown et KeyUp. Tous le caractères imprimables génèrent aussi un évènement KeyPress. KeyDown et KeyUp permettent de gérer toutes les touches claviers

tandis que KeyPress ne gère que les touches correspondantes à des caractères imprimables.

Exemple :

Private Sub TextBox1_KeyDown(...)

If e.Shift and e.KeyCode=Keys.F8 Then TextBox1.Text=UCase(TextBox1.Text) End If

End Sub

Private Sub TextBox2_KeyPress(...) If Not IsNumeric(e.KeyChar) Then

e.Handled=True

‘La propriété Handled permet d’indiquer que la touche a

‘été gérée et ne doit plus être pris en compte. End If

End Sub

2. Les fonctions de validation

Plusieurs fonctions permettent de vérifier le type d’une donnée saisie. On peut citer IsDate, IsNumeric, IsNothing, IsError, etc. Ces fonctions retournent une valeur vrai lorsque la donnée et du type vérifier.

3. Utilisation du composant ErrorProvider

Le composant ErrorProvider vous permet d’avertir discrètement l’utilisateur d’un problème pendant la saisie des données.

Ce composant gère les méthodes et propriétés suivantes :

SetError : détermine le texte du message à afficher et la position de l’icône. Pour effacer un message d’erreur, il suffit d’utiliser la chaîne de caractère vide.

Icon : définit l’icône d’erreur à afficher 4. Gestion du Focus

(16)

Lorsqu’un contrôle possède le Focus, l’utilisateur peut entrer des données dans le contrôle. La méthode .Focus permet à un contrôle de prendre le focus.

Exemple :

TextBox1.Focus() TextBox1.SelectAll()

‘SelectAll permet de sélectionner le texte du contrôle

La prise du focus génère les évènements suivants : - Enter : le contrôle va recevoir le focus - GotFocus : le contrôle a reçu le focus La perte du focus génère les évènements suivants :

- Leave : le contrôle va perdre le focus - LostFocus : le contrôle a perdu le focus

Pour un formulaire, les évènements Activated et Deactivate correspondent aux évènements Enter et Leave des contrôles.

Remarque : Certains contrôles tels que Label, LinkLabel, PictureBox ne peuvent pas recevoir le Focus. Il en est de même pour les contrôles invisibles comme le Timer ou ImageList.

III) validation au niveau formulaire

C’est un processus qui valide tous les champs du formulaire en une seule opération.

1. Propriété du formulaire

Les propriétés suivantes facilitent la validation au niveau formulaire : - KeyPreview : force la génération des évènements claviers

au niveau du formulaire avant les évènements du contrôle - AcceptButton : désigne le bouton d’acceptation qui sera

automatiquement le bouton par défaut. C’est ce bouton qui sera exécuté lorsque l’on appuie sur la touche Entrée.

- CancelButton : désigne le bouton d’annulation. C’est ce bouton qui sera exécuté lorsque l’on appuie sur la touche Echap.

2. Code de validation

Un code de validation consisterait par exemple à activer le bouton Ok que lorsque tous les champs requis sont renseignés.

Exemple :

Function EnableOk() as Boolean

If TextBox1.Text<>"" And TextBox2.Text<>"" Then EnableOk=True

Else

EnableOk=False End If

End Function

Private Sub TextBox1_TextChanged(...) OKButton.Enabled=EnableOk() End Sub

Private Sub TextBox2_TextChanged(...) OKButton.Enabled=EnableOk() End Sub

Vous pouvez aussi utiliser la collection Controls d’un formulaire pour manipuler les contrôles.

Ex : Le code suivant est saisi dans un module pour effacer toutes les saisies effectuées dans les contrôles d’un formulaire et peut être appelé par un bouton.

Public Sub Effacer(f as System.windows.forms.form) Dim ctl as Control

For each ctl in f.Controls

If TypeOf(ctl) is TextBox Then Ctl.Text=""

ElseIf TypeOf(ctl) is RadioButton Then Ctl.Checked=False

End If Next ctl End Sub

(17)

$%& ' ( ) * + , * '' -'*

Les erreurs de programmation sont inévitables et même les programmeurs les plus expérimentés en introduisent dans leur code. La gestion des erreurs consiste à intercepter et à traiter ces erreurs. I) Types d’erreurs

Il existe trois types d’erreurs : • Erreur de syntaxe

Elle se produit quand le compilateur ne comprend pas le code que vous avez saisi. Une telle erreur apparaît lorsque un mot clé comporte une erreur ou quand un signe de ponctuation est oublié.

Ex :

Msgbox(Ou est l’erreur ?)

‘Les doubles quottes encadrant le texte à

‘afficher sont manquantes.

Visual Basic .NET simplifie l’identification des erreurs de syntaxe. Pendant la saisie, ces erreurs sont détectés et soulignées dans le code. Elles sont aussi rajoutées dans la fenêtre « Liste des tâches ».

Erreur d’exécution

Elles se produisent lorsque l’application tente d’exécuter une opération qui ne peut aboutir. Cette opération peut être impossible à exécuter comme dans le cas d’une division par zéro, ou non autorisée, comme dans le cas des exceptions de sécurité. Lorsqu’une telle erreur se produit, une exception la décrivant en générée par le système. Nous apprendrons par la suite à gérer ces erreurs.

Erreur de logique

Lorsque l’application est compilé et semble s’exécuter correctement, mais quelle ne produit pas les résultats escomptés, elle comporte des erreurs de logique. Ces erreurs sont les plus difficiles à identifier car Visual Basic ne fournit aucun mécanisme adapté. La manière courante de détecter ce type d’erreur est de tester l’application avec plusieurs scénarios. Exemple : If Age>20 Then MsgBox("Majeur") Else MsgBox("Majeur") End If

'Dans la clause « Else », le message à

'afficher devrait être « Mineur ».

II) Déboguage

Les outils de débogage aident à diagnostiquer les erreurs de programmation en examinant le cours de l’exécution du programme. 1. Modes de fonctionnement

Il existe trois modes de fonctionnement l’environnement de développement intégré de Visual Studio .NET :

Mode Conception : permet modifier les interfaces et écrire le code ;

Mode Exécution : le programme s’exécute et interagit avec les utilisateurs mais vous ne pouvez pas changer le code ; • Mode Arrêt : dans ce mode, l’exécution du programme est

interrompue (mais pas arrêté).C’est dans ce mode, que nous pourrons utiliser toutes les fonctions de déboguage.

2. Présentation du mode arrêt

Vous ne pouvez entrer en mode arrêt que si vous choisissez la configuration d’exécution « Debug ». Visual Basic permet d’entrer dans ce mode suivant différentes conditions : si il rencontre un Point d’arrêt ou une instruction Stop dans votre code, si vous appuyez Ctrl+Alt+Pause durant l’exécution de votre programme, si une ligne de code génère une erreur et que vous choisissez « Debug » dans la boite de dialogue qui s’affiche, etc.

Dans ce mode, vous pouvez : Parcourir votre code ligne après ligne, déterminer les procédures actives qui ont été appelées, contrôler les valeurs des variables ou des expressions, utiliser les fenêtres de

(18)

déboguage pour modifier les valeurs des variables et des propriétés, modifier le programme, exécuter des instructions.

3. 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, au lieu de continuer l’exécution de votre code.

Points d'arrêt Points d'arrêt Indicateur d’éxecution Indicateur d’éxecution

Vous pouvez définir un point d’arrêt sur n’importe quel ligne de code exécutable de votre application. Un point d’arrêt se définit ou se retire, soit en cliquant dans la marge gauche, soit en utilisant la touche fonction « F9 », soit enfin en choisissant « insérer un point d’arrêt » dans le menu contextuel sur une ligne de code. On peut aussi effacer tous les points d’arrêt en cliquant sur le menu Déboguer->Effacer tous les points d’arrêts.

Par défaut, l’interruption du programme à un point d’arrêt est systématique mais il peut aussi se baser sur une condition ou sur le nombre de fois que le point d’arrêt est atteint.

4. Barre d’outils Déboguer

La barre d’outils Déboguer propose les outils suivants :

- Démarrer ou F5: lance ou continue l’exécution du programme

- Interrompre tout ou Ctrl+Alt+Pause : passe en mode arrêt. - Arrêter le déboguage ou Shift+F5: termine l’application et

passe en mode conception - Redémarrer : relance l’application

- Pas à pas détaillé ou F11 : exécute la prochaine ligne de code. Si la prochaine ligne appelle une procédure, alors le

déboguage se poursuivra pour chaque ligne de code de la procédure.

- Pas à pas principal ou F10 : exécute la prochaine ligne de code. Si la prochaine ligne appelle une procédure, alors le déboguage exécute entièrement la procédure et passe à la ligne suivante.

- Pas à pas sortant ou Shift+F11 : exécute intégralement (et non en pas à pas), les lignes de code restantes de la procédure en cours et s’arrête à la ligne suivante de la procédure appelante. Démarrer Démarrer Interrompre tout Interrompre tout Arrêter le débogage Arrêter le débogage Redémarrer Redémarrer Afficher l'instruction suivante Afficher l'instruction suivante Pas à pas détaillé Pas à pas

détaillé Pas à pas Pas à pas sortantsortant

Pas à pas principal Pas à pas principal Points d'arrêt Points d'arrêt Affichage hexadécimalAffichage hexadécimal

D’autres commandes sont aussi possibles :

- Exécuter jusqu'au curseur : le débogueur exécute votre application jusqu'à ce qu'il atteigne le point d'insertion que vous avez défini.

5. Fenêtres de déboguage

Les fenêtre de déboguages vont vous permettre de visualiser et de modifier le contenu des variables durant l’exécution de votre programme.

La méthode la plus simple pour connaître le contenu d’une variable est de placer la souris sur le nom de la variable, pendant le mode arrêt. Une info-bulle (DataTips) s’affiche alors avec la valeur de l a variable.

La Fenêtre Automatique permet d’afficher les variables utilisées dans l’instruction courante et dans l’instruction précédente. La Fenêtre Variables Locales permet d’afficher toutes les variables accessibles (les variables locales de la procédure et les variables globales). La Fenêtre Espion et la Fenêtre Espion Express

(19)

permettent l’affichage des variables de votre choix. La Fenêtre Pile des appels permet d'afficher l'historique des appels à la ligne de code en cours de débogage. La Fenêtre Commande permet d’exécuter des commandes dans son mode commande et d’évaluer des expressions dans son mode immédiat

Exemple :

? MaVariable

III) Gestion des exceptions

Lorsqu’une erreur d’exécution se produit avec une application, celle-ci déclenche une exception. Une exception est une instance d’une classe spécialisée dérivée de la classe de base System.Exception. Elle est conçue pour simplifier le diagnostic et la gestion des erreurs. Dans les versions antérieures du langage Visual Basic, l’instruction de rupture de séquence « Goto » était très utilisée mais aussi très critiquée si bien que son usage tendait à être abandonné. Dans Visual Basic 6, il est recommander de ne plus utiliser cette instruction sauf dans la gestion des erreurs avec l’instruction « On Error Goto ». Dans Visual Basic .NET, on peut complètement se passer de « Goto ».

1. Création d’un gestionnaire d’exceptions

La syntaxe de base du gestionnaire d’exception est la suivante :

Try

' Insérer ici le code normal du programme

' susceptible de générer une erreur Catch [e as System.Exception]

' Insérer ici le code traitant des exceptions [Finally]

' Insérer ici du code qui sera exécuté en toutes

' circonstances. End Try

2. Utilisation d’un gestionnaire d’exceptions

Prenons l’exemple d’un programme capable d’afficher les images de votre ordinateur. Vous créer un nouveau projet Visual Basic .NET et sur le formulaire vous utiliser les contrôles PictureBox pour afficher l’image, Button pour faire un bouton de chargement de l’image et

OpenFileDialog pour faire une boîte de dialogue pour sélectionner le

fichier image. Les propriétés significatives sont les suivantes : Button1.Text = "Charger Image"

Dans l’évènement click du bouton (button1_click) tapez le code suivant :

Dim f as String

Dim o as New OpenFileDialog Try

o.Filter="Toutes les images|*.bmp;*.jpg" o.ShowDialog() f=o.FileName If f<>"" then PictureBox1.Image =_ System.Drawing.Bitmap.FromFile(f) End If Catch

MsgBox("Format non supporté !") End Try

3. Création d’une exception

Vous pouvez générez vos propres erreurs avec le nouveau gestionnaires d’exceptions grâce à l’instruction throw .

Exemple :

If (day < 1) Or (day > 365) Then

Throw New ArgumentOutOfRangeException( ) End If

4. Gestion des exceptions avec l’objet Err

Visual Basic .NET continue de supporter la gestion des erreurs dans le style de Visual Basic 6. L’objet Err permet de gérer l’erreur qui est survenu dans le programme comme dans l’exemple suivant :

Dim Msg As String

On Error Resume Next ‘ Initialise la gestion d’erreur

‘Tapez ici le code ou

Err.Raise(6) ‘Générer votre propre erreur If Err.Number <> 0 Then

Msg = "Erreur # " & Str(Err.Number) & _ " was generated by " & _

Err.Source & ControlChars.CrLf & Err.Description MsgBox(Msg, MsgBoxStyle.Information, "Erreur") End If

(20)

$%& ' . % *%-/,+ 0 *% %,+

Beaucoup d’applications ont besoin d’accéder à des données stockées dans des bases de données.

I) Technologies antérieures d’accès aux données

Les utilisateurs de Visual Basic 6 et de ces versions antérieures ont eu à utiliser plusieurs technologies d’accès aux données.

1. ODBC (Open DataBase Connectivity)

L’une des premières technologies d’accès aux données, indépendante du SGBDR. Elle fournit aux développeurs une interface lui permettant d’accéder à n’importe quel SGBDR, pourvu qu’il existe son pilote (Driver) ODBC. La limitation majeure de ODBC s’est qu’elle prend en charge très peu d’instructions SQL et donc ne permet pas d’exploiter convenablement des grands SGBDR tels que SQL Server, Oracle, etc.

2. DAO (Data Access Object) et RDO (Remote Data Object)

La technologie DAO a été initiée par MS afin de fournir un accès plus performant à certaines bases de données dont MS Access. La limitation majeure de cette technologie est qu’elle n’est pas efficace pour des bases de données en réseaux. Aussi, en complément, MS a introduit RDO pour fournir un accès performant pour des BD en réseaux. Mais la encore, la technologie RDO se relève inefficace pour les BD locales.

3. ADO (ActiveX Data Object)

Introduite dans Visual Basic 6, cette technologie réunit tous les avantages de ces prédécesseurs : elle permet l’accès à un grand nombre de SGBR au travers de fournisseurs (providers) OLEDB et reste efficace pour les BD locales comme pour les BD en réseau. II) Présentation de ADO.NET

1. Généralités

La technologie ADO.NET reprend les atouts d’ADO et y ajoute des améliorations significatives.

ADO.NET est la technologie standard d’accès aux données pour tous les outils de développement de la suite Visual Studio .NET. Les contrôles Data et Data ADO ne sont plus disponibles dans Visual Basic .NET.

ADO.NET utilise le format XML (eXtended Markup Language) pour le stockage interne des données. Ceci lui permet d’accéder à plus de SGBDR et d’être complètement intégré dans les applications Web.

ADO.NET fournit un accès « déconnecté » aux données stockées dans les BD. Ce mode de fonctionnement permet une utilisation optimale des ressources serveurs.

2. Les composants d’ADO.NET

L’accès aux données dans ADO.NET s’appuie sur plusieurs composants comme dans le schéma ci-après.

Ces composants sont les suivants : • L’objet Connection

Il représente la connexion réelle avec une base de données. Il s’appuie sur le fournisseur spécifique de la BD avec laquelle il doit se connecter.

Ex : « Microsoft Jet 4.0 OLEDB Provider » pour Access 2000 Visual Basic .NET fournit deux classes de connections : sqlConnection spécifiquement pour SQL Server et oledbConnection pour tout type de SGBR (Oracle, DB2, etc.). Le Groupe de données (DataSet)

Il est la représentation déconnectée, en mémoire, des données. Il peut être considéré comme une copie locale des parties significatives de la base de données. Pendant que le groupe de données est en mémoire, vous pouvez manipuler et mettre à jour les données indépendamment de la base de données. Le groupe de données peut ensuite être utilisé pour mettre à jour la base de données centralisée.

(21)

L’objet DataSet est constitué de zéro ou plusieurs DataTable eux-mêmes constitués des DataColumns et de DataRows. • L’objet DataAdapter

Elle joue le rôle d’intermédiaire, pour simplifier la communication entre la BD et le groupe de données. Le DataAdapter alimente le DataSet avec les données en provenance de la BD quand la méthode Fill est appelée. Une fois que les données ont été modifiées en mémoire, le DataAdapter transmet les modifications à la BD lorsque vous appelez la méthode Update. Le DataAdapter fournit quatre propriétés représentant les commandes de BD : SelectCommand, InserCommand,

DeleteCommand et UpdateCommande.

III) Accès aux données 1. Connexion à la BD

La méthode la plus simple pour implémenter une connexion vers une BD est d’utilisé le conteneur « Connexions de données » dans la fenêtre « Explorateur de serveurs »

La boîte de dialogue « Propriétés des liaisons de données ».permet de définir les options spécifiques d’une BD. Pour vous connecter à une BD SQL Server, vous devez réaliser les opérations suivantes :

1) Dans l’onglet fournisseur, choisir le fournisseur « Microsoft OLEDB Provider for SQL Server »

2) Dans l’onglet connexion

a. Indiquez le nom du serveur. Laissez vide ou indiquez (local) pour le serveur de votre poste b. Choisissez « utiliser la sécurité intégrée de

Windows NT » valable dans la plupart des cas c. Précisez le nom de la BD à laquelle vous voulez

être connecté

3) Cliquez sur « Tester la connexion » est si la connexion réussie, cliquez sur « Ok » pour enregistrer.

(22)

2. Création d’un DataAdapter

Maintenant que vous êtes connecté à la BD, vous pouvez précisez les informations (tels que les tables, les vues, etc.) auxquelles vous voulez avoir accès. Réalisez les étapes suivantes :

1) Dans l’onglet « Données » de la « Boîte de contrôles », sélectionnez le composant « OledbDataAdapter » ou « SqlDataAdapter » selon la connexion et laissez vous guider par l’assistant.

2) Dans la fenêtre qui suit, choisissez la connexion que vous avez crée ou créez en une nouvelle

(23)

3) La première option de la fenêtre suivante vous laisse opportunité de saisir une ou plusieurs instructions SQL « Select » que vous utiliserez dans votre programme

4) Vous pouvez maintenant saisir une ou plusieurs instructions « Select » séparées par des points-virgules ( ;). Vous pouvez aussi vous servir du générateur de requêtes.

(24)

VS.NET ajoute un composant OleDbDataAdapter1 ou SqlDataAdapter1 à la barre des composants, en dessous du formulaire.

3. Création d’un DataSet

La prochaine étape consiste à créer l’objet qui représente localement les données de la BD. Réalisez les étapes suivantes :

1) Assurer que le formulaire contenant le DataAdapter est sélectionné

2) Cliquez sur le menu « Données » puis sur « Générer le groupe de données » ou fait apparaître le menu contextuel du DataAdapter et choisissez « Générer le groupe de données » dans le menu.

3) Dans la boite de dialogue qui apparaît, indiquez le nom du nouveau DataSet ou choisissez un DataSet existant. Sélectionnez aussi la table que vous voulez manipuler et validez

Un composant DataSet11 est ajouté à la barre des composants, en dessous du formulaire.

IV) Liaisons de données simples

Une liaison de données simple représente la liaison d’une valeur unique (généralement une colonne). Plusieurs contrôles sont susceptibles d’avoir des liaisons simples.

1. Affiché les données

Vous pouvez utiliser plusieurs contrôles (textbox, label, picturebox, etc.) pour afficher les données d’une base de données. Dans la plupart des cas, on utiliser un contrôle « Textbox » que vous lierez à une colonne par sa propriété « text » de la collection « (Databinding) ».

(25)

2. Chargement des données

Avec ADO.NET, les données doivent être récupérés depuis la BD avant de pouvoir être affiché. La méthode « Fill » du DataAdapter permet de le faire. Cette méthode peut être appelée dans l’évènement « Load » du formulaire ou associé à l’évènement « click » d’un bouton chargement des données.

Exemple :

DataSet11.Clear

OledbDataAdapter1.Fill(DataSet11,"NomTable")

V) Contrôles de navigation

Maintenant que les contrôles sont liés à la BD, ils peuvent afficher les données. Dans les affichage en formulaire, il faut prévoir les boutons de navigations (premier, dernier, précédent, suivant).

Chaque objet Form comprend un BindingContext. Le BindingContext est responsable de la gestion des collections de données auxquelles sont liés les contrôles. Il gère la mise à jour et la dépendance. Il gère un ensemble de propriétés utiles pour la navigation dans les données. Nous avons :

- position : détermine la position courante de l’enregistrement. La position 0 correspond au premier enregistrement et (n-1) correspond au dernier

- count : détermine le nombre d’enregistrement dans le dataset.

Vous devez préciser le Dataset à utiliser et si il y a lieu, la table. 1. Bouton premier et dernier

Les boutons précédent et suivant correspondent respectivement à aller à la position 0 et à la position n-1.

- Code lié à l’évènement click du bouton premier:

Me.BindingContext(DataSet11,"NomTable").position=0

- Code lié à l’évènement click du bouton dernier:

Me.BindingContext(DataSet11,"NomTable").position= _ Me.BindingContext(DataSet11,"NomTable").count -1

2. Bouton précédent et suivant

Les boutons précédent et suivant correspondent respectivement à diminuer la position de 1 et augmenter la position de 1:

- Code lié à l’évènement click du bouton suivant:

Me.BindingContext(DataSet11,"NomTable").position+=1

- Code lié à l’évènement click du bouton précédent:

Me.BindingContext(DataSet11,"NomTable").position-=1

VI) Liaisons de données complexes

Une liaison de données complexe représente la liaison d’un contrôle à un ensemble de données. Plusieurs contrôles sont susceptibles d’avoir des liaisons complexes et nous détaillerons le cas des contrôles combobox et datagrid.

1. Liaison de données dans un ComboBox

Les cas d’utilisation d’un combobox répondent fréquemment au souci d’afficher de façon lisible, les informations d’une relation et d’effectuer des recherches de façon conviviale.

Les propriétés suivantes sont significatives :

- datasource : représente le dataset qui contient les données à afficher

- displaymember : spécifie la propriété de la source de données dont vous voulez afficher le contenu

Références

Documents relatifs

Then, in Section III, we propose the main stability results for a general class of impulsive systems with several aperiodic and asynchronous sequences of impulses and derive

Fig. 7: An Example of non-declared sponsored post: 1) A verified Mega influencer holding a box on her hand and promoting products. 2) The product page is tagged in the photo

La fouille a cepen- dant permis d’identifier nettement au moins quatre objets en argile crue distincts au sein de cette couche de destruction : deux grandes urnes sur pied 9 et

Ontario (Procureur général), préc., note 42, par.. leurs libertés fondamentales, mais de les renforcer considérablement. À cet égard, le contexte de l’affaire joue pour beaucoup.

Guardar as plantas medicinais secas em vidros escuros ou latas com tampas, bem limpos e secos, em lugar fresco e longe da luz do sol. O período ideal para a utilização da planta seca

(Collier! and! Levitsky! 1997;! Diamond! 2002;! Levitsky! and! Way! 2002,! 2010;! Schedler! 2002,! 2006;! Ottaway! 2003;! Karl! 2005;!.. Howard! and! Roessler!

Le coût des incendies de résidences lié au tabac est obtenu directement selon les chiffres publiés dans le rapport des coûts de l’abus de substance au Canada (2006) et qui sont

L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des