support de cours vb.net 2003

Support de Cours

DEVELOPPEMENT ET MISE EN ŒUVRE D'APPLICATIONS WINDOWS AVEC MICROSOFT VISUAL BASIC .NET 2003

Stéphane N’GUESSAN Groupe Pigier – Abidjan

Version 1.2

Développement d’applications Windows avec Visual Basic .NET

Page 1

��

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�Annexe I : Liste des fonctions et procédures clés de VB.NET.................. 60�


��

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 [email protected] MCP Visual Basic .NET, MCDBA SQL Server 2000, MCSE 2000 Développeur Visual Basic depuis 1994 Groupe Pigier - Abidjan


Page 4

��

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.


Page 5

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


Page 6

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)


Page 7

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.


Page 8

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:


Page 9

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.


Page 10

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


Page 11

'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


Page 12

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 MessageBox.show(prompt][, title][, buttons][, icon])


Page 13

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.


Page 14

��

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.


Page 15

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


Page 16

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#


Page 17

��

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 :


Page 18

- 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;


Page 19

- 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


Page 20

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


Page 21

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 ;


Page 22

- 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 :

- Image : définit le chemin d’accès au fichier image


Page 23

- 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 :


Page 24

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


Page 25

��!�"�� #� ��

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é ;


Page 26

• 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


Page 27

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


Page 28

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


Page 29

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


Page 30

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


Page 31

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

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


Page 32

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


Page 33

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êtPoints d'arrêt

Indicateurd’éxecutionIndicateur

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


Page 34

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é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

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


Page 35

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"


Page 36

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


Page 37

�$%&��'�.�%��*%-/,+��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.


Page 38

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.


Page 39

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


Page 40

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.


Page 41

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.


Page 42

2) Dans la fenêtre qui suit, choisissez la connexion que vous

avez crée ou créez en une nouvelle


Page 43

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.


Page 44

5) Cliquez sur « terminé » pour enregistrer le DataAdapter


Page 45

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


Page 46

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) ».


Page 47

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 :


Page 48

- 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


Page 49

- valuemember : colonne choisie dans le datasource pour retourner une valeur caractéristique de l’élément choisi

Par ailleurs, la collection (DataBindings) comprend les propriétés suivantes :

- SelectedValue : définit la valeur de la propriété de membre spécifiée par la propriété ValueMember

- SelectedItem : définit l’élément actuellement sélectionné dans le ComboBox

- Text : définit le texte affiché par le contrôle Dans le cas d’une relation Pere (PID, PNom)-Fils(FID, FPrenom, PID), si vous souhaitez afficher et selectionner le nom du pere dans le formulaire fils vous devez indiquer les valeurs suivantes aux propriétés du ComboBox :

- datasource : DatasetPere - displaymember : Pere.PNom - valuemember : Pere.PID - selectedvalue : Fils.PID - selecteditem : Pere.PNom - text : (Aucun)

2. Liaison de données dans un DataGrid Le DataGrid affiche toutes les informations d’une table, sous la forme d’une série de lignes. Chaque ligne peut être éditée directement. Les modifications sont automatiquement répercutées lorsque l’utilisateur se déplace de ligne en ligne. Pour utiliser un DataGrid, il suffit d’attribuer à la propriété DataSource le DataSet à afficher et à la propriété DataMember la table à afficher.Avec VS.Net, le contrôle DataGrid s’est enrichi d’une nouvelle propriété « AlternatingBackColor » permettant d’afficher les listes avec des alternances de couleur d’arrière plan, comme dans les listings.

VII) Modification des données

L’objet BindingContext du formulaire comprend un certain nombre de méthode permettant la modification des données liées. Parmi ces méthodes, nous avons :

- AddNew() : ajoute un nouvel élément - CancelCurrentEdit() : annule la modification en cours


Page 50

- EndCurrentEdit() : termine les modifications en cours - RemoveAt(index as integer) : supprime la ligne à

l’index spécifié - SuspendBinding() : suspend la liaison de données - ResumeBinding() : reprend la liaison de données

1. Ajout de données Code lié à l’évènement click du bouton Ajouter: Me.BindingContext(DataSet1).EndCurrentEdit() Me.BindingContext(DataSet1).AddNew() ‘Termine les opérations en cours et ‘ajoute un nouvel élément

2. Modification de données Aucun code n’est nécessaire pour la modification. Elles se font automatiquement lorsque l’on passe d’un enregistrement à l’autre.

3. Suppression de données La méthode RemoveAt permet de supprimer une donnée. Exemple : 'Code lié à l’évènement click du bouton Supprimer If (Me.BindingContext(DataSet1).Count > 0) Then Me.BindingContext(DataSet1).RemoveAt( _ Me.BindingContext(DataSet1).Position) End If 'Vérifie que le DataSet contient encore des données et 'supprime l’élément en cours.

4. Mise à jour de la base de données Lorsque le DataSet fonctionne en mode déconnecté. Les modifications s’effectuent localement. Pour faire appliquer ces changements à la base de données, vous pouvez utiliser la méthode Update du DataAdapter. Exemple 'Code lié à l’évènement Closing du formulaire OledbDataAdapter1.Update(DataSet1)


Page 51

�$%&��'�1�,��2+&&�3��,�*+2-��+�*

Dans ce chapitre, nous passons en revue plusieurs techniques de programmation que vous pouvez utiliser lors de vos développement de solutions d’entreprise

I) Techniques liées aux applications MDI

1) Lancer une seule fois la feuille fille Exemple :

Dim WithEvents IuLivre as frmLivre Private Sub IuLivre_Open() If (IuLivre Is Nothing) Then Iulivre = New frmLivre End If IuLivre.Show() End Sub Private Sub IuLivre_Close(sender As Object, e As System.EventArgs) Handles IuLivre.Closed IuLivre = Nothing End Sub

2) Confirmer la sortie d’un formulaire Exemple :

Private Sub Form1_Closing(sender As Object, e As System.ComponentModel.CancelEventArgs) Handles form1.Closing 'Demander à l’utilisateur If MessageBox.Show("Voulez vous quitter" , MessageBoxButtons.YesNo) = DialogResult.Yes Then 'Annuler la fermeture du formulaire e.Cancel = True End If End Sub

3) Déterminer la liste des applications en cours d’exécution Exemple :

Dim pList() As Process Dim myProcess As System.Diagnostics.Process pList = myProcess.GetProcesses For Each myProcess In pList MsgBox(myProcess.ProcessName)

Next

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


Page 52

1) Filtrage et tri des données Ex :

2) Formulaire principaux/secondaires Dans des applications de base de données, il est souvent utile d'afficher un enregistrement avec un groupe d'enregistrements détails de la facture associés. On peut aussi afficher un Client avec les commandes en cours le concernant. Pour cela, on crée un formulaire dit entête/détails ou principal/secondaire. Cet exemple affiche un Datagrid pour les clients et un DataGrid pour les commandes de chaque client. Le premier objet DataGrid affiche la liste des clients. Le deuxième objet DataGrid affiche la liste des commandes. Lorsque le client sélectionné est modifié, le deuxième objet DataGrid met à jour l'affichage des commandes pour ce client. De façon à lier les deux objets DataGrid, vous devez définir le DataSource de chaque DataGrid avec le même DataSet. Vous devez également définir les propriétés DataMember pour indiquer au BindingContext Windows Forms qu'ils sont apparentés. Pour cela, vous définissez le DataMember pour le deuxième DataGrid avec le nom de la relation entre les tables Customers et Orders - Customers.CustomersOrders Ex :

3) Etats Simples Le composant Crystal Reports pour Visual Studio .NET ajoute des fonctionnalités de création d'états à votre. Vous pouvez créer un état de toutes pièces ou utiliser un des Experts de Crystal Reports pour vous aider tout au long du processus de conception Pour ajouter un état à votre projet, faites Projet -> Ajouter un composant et choisissez « Etat Crystal Report »


Page 53

Choisissez ensuite l’un des experts correspondant à vos besoins


Page 54

Suivons l’exemple de l’exemple standard. La première étape consiste à déterminer. Si votre état s’appuie sur plusieurs tables, un onglet liaison apparaît.

Dans l’onglet liaison, vous pouvez définir les liaisons entre les tables

Dans l’onglet Champs, vous choisissez les champs ou des formules basées sur des champs, qui devront apparaître sur l’état.


Page 55

L’onglet groupe permet de définir des sections dans l’état

L’onglet Total permet de faire des calculs de synthèse pour chaque section


Page 56

Les onglets « N Sup », « Diagramme » et « Selectionner » sont facultatifs. Le dernier onglet « Style » permet de choisir une apparence.

Cliquez sur terminer pour voir afficher le résultat. Vous pouvez désormais modifier cet état à votre guise.


Page 57

Pour afficher cet état, vous devez ajouter à votre projet un nouveau formulaire Windows et ajouté à ce dernier un contrôle « Crytal Report Viewer ».

Dans le code de ce formulaire, tapez les instructions suivantes :

Public rpt As New CrystalReport1 Dans le code du formulaire appelant l’état à afficher, tapez les instructions suivantes

Private Sub Button1_Click(…) Handles Button1.Click Dim frm As New Form1 frm.rpt.SetDataSource(DataSet11) frm.CrystalReportViewer1.ReportSource=frm.rpt frm.Show() End Sub

2) Etats sur sélection Pour afficher un état sur des données filtrées, vous pouvez créer votre propre DataSet basé sur votre filtre et d’afficher ce dataset.

Private Sub Button1_Click(…) Handles Button1.Click Dim frm As New Form1 Dim oledbadap As New OleDb.OleDbDataAdapter Dim ds As New DataSet oledbadap.SelectCommand = New OleDb.OleDbCommand("SELECT * FROM Editeurs WHERE " + selection, OleDbConnection1) oledbadap.Fill(ds, "Editeurs") frm.rpt.SetDataSource(ds)


Page 58

frm.Show() End Sub

Vous pouvez aussi passer le filtre à Crystal Report afin qu’il l’applique aux données sélectionnées. Dans le code du formulaire ayant le contrôle Control Report Viewer, tapez les instructions suivantes :

Private Sub Button1_Click(…) Handles Button1.Click Dim frm As New Form1 frm.rpt.SetDataSource(DataSet11) frm.CrystalReportViewer1.ReportSource=frm.rpt frm.CrystalReportViewer1.SelectionFormula = selection frm.Show() End Sub


Page 59

�$%&��'�4�,�&2+��3��,�%&&2��%��+�*

Une fois l’application développé, testée et déboguée, elle est prête à être déployée sur les ordinateurs clients.

I) Méthode de déploiement

1. Déploiement XCOPY Cette méthode consiste à faire une copie exacte du dossier de votre application vers l’ordinateur cible. Cela suppose que l’ordinateur cible possède déjà toutes les ressources externes aux projets dont le .NET Framework. Exemple : XCOPY F:\MonApplication C:\MonApplication /s


Page 60

%��/�*

Annexe I : Liste des fonctions et procédures clés de VB.NET

Catégorie Entrée/Sortie 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”) MsgBox : Affiche une boite de dialogue qui affiche un message et attend que l’utilisateur clique sur un bouton. Syntaxe MsgBox(prompt[, buttons][, title]) Prompt : Message à afficher Buttons : Définit les boutons et icônes affichées. Parmi les options disponibles, nous avons OKOnly, OKCancel, AbortRetryIgnore, YesNoCancel, YesNo,RetryCancel, Critical, Question, Exclamation, Information. Ces options sont cummulables par simple addition Title : Titre de la boite de dialogue Exemple MsgBox("Cette opération prendra plusieurs minutes", _ MsgBoxStyle.Exclamation + MsgBoxStyle.OKCancel)

Catégorie Manipulation de Fichier ChDir : change le répertoire par défaut mais pas le lecteur. Exemple ChDir("D:\TEMP") 'se place sur le dossier D:\TEMP ChDir("..") 'se place sur le dossier parent ChDrive : change le lecteur actif Exemple ChDrive("A") 'se place sur le lecteur A: CurDir : Dir : FileCopy : FileDateTime :


Page 61

FileLen GetAttr : Kill MkDir : Rename : RmDir : SetAttr : EOF : FileAttr : FileClose : FileOpen : FileGet : FilePut : FreeFile : Input : LineInput : Loc : Lock : LOF : Print : PrintLine : Reset : Seek : Unlock : Width : Write : WriteLine :

Catégorie Identification des types de données IsArray : IsDate : IsDBNull : IsNothing : IsNumeric : IsReference : TypeName : VarType :

Catégorie Conversion de Type CInt : Convertit une expression en Integer MyInt = CInt(346.789) 'MyInt prend la valeur 346 CByte : Convertit une expression en Byte CChar : Convertit une expression en Char CDate : Convertit une expression en Date CDbl : Convertit une expression en Double CDec : Convertit une expression en Decimal CBool : Convertit une expression en Booleen CLng : Convertit une expression en Long


Page 62

CObj : Convertit une expression en Objet CShort : Convertit une expression en Short CStr : Convertit une expression en String CType : Convertit une expression en un type de donnée MyInt = CType(346.789, int) 'MyInt prend la valeur 346

Catégorie Manipulation de chaîne de caractère Asc : retourne le code ascii d’un caractère MyInt = Asc("A") 'MyInt prend la valeur 65 AscW : Chr : retourne le caractère correspondant au code ASCII ChrW : Filter : InStr : retourne la position de la première occurrence du caractère dans la chaîne MyInt = Instr("Auto","t") 'MyInt prend la valeur 3 InStrRev : Join : LCase : transforme la chaîne en minuscules MaStr = LCase("ABC") 'MaStr prend la valeur "abc" Left : retourne les n premiers caractères de la chaine en partant de la gauche MaStr = Left("Auto",2) 'MaStr prend la valeur "Au" Len : retourne la longueur d’une chaîne MyInt = Len("Pigier") 'MyInt prend la valeur 6 LTrim : supprime les espaces en début de chaîne MaStr = LTrim(" abc ") 'MaStr prend la valeur "abc " Mid : retourne les n caractères du milieu à partir de la position indiquée MaStr = Mid("Auto",2,2) 'MaStr prend la valeur "ut" Replace : Right : retourne les n derniers caractères de la chaine en partant de la droite MaStr = Right("Auto",2) 'MaStr prend la valeur "to" RTrim : supprime les espaces en fin de chaîne MaStr = RTrim(" abc ") 'MaStr prend la valeur " abc" Space : génère n fois le caractère espace MaStr = Space(4) 'MaStr prend la valeur " " Split : StrComp : StrConv : StrDup : String : recopie n fois le caractère spécifié MaStr = String(4,"A") 'MaStr prend la valeur "AAAA" StrReverse : Trim : supprime les espaces en début et en fin de chaine MaStr = Trim(" abc ") 'MaStr prend la valeur "abc" UCase : transforme la chaîne en majuscules MaStr = UCase("abc") 'MaStr prend la valeur "ABC"

Catégorie Formatage de données Format : FormatCurrency :


Page 63

FormatDateTime : FormatNumber : FormatPercent : LSet : RSet : Str : Val :

Catégorie Mathématique Abs : donne la valeur absolue du nombre MaVar = Abs(-19) 'MaVar prend la valeur 19 Atan : donne l’arc tangente de l’angle Cos : donne le cosinus de l’angle Exp : donne l’exponentielle du nombre MaVar = Exp(1) 'MaVar prend la valeur 2.71828 Fix : tronque les décimales du nombre MaVar = Fix(-4.68) 'MaVar prend la valeur -4 Hex : Int : donne la partie entière du nombre MaVar = Int(-4.68) 'MaVar prend la valeur -5 'Int et Fix ne diffèrent que 'pour les valeurs négatives Log : donne le logarithme naturel (base e) Oct : Pow : Round : arrondit à la valeur supérieure MaVar = Round(4.68) 'MaVar prend la valeur 5 Sgn : donne le signe d’un nombre en retournant la valeur 1, 0 ou –1 MaVar = Sgn(-4.68) 'MaVar prend la valeur -1 Sin : donne le sinus de l’angle Sqrt : donne la racine carrée de la valeur (valeur positive uniquement) MaVar = Sqrt(16) 'MaVar prend la valeur 4 Tan : donne la tangente de l’angle

Catégorie Date et Heure DateAdd : Ajoute ou retranche une durée donnée à une date DateDiff : Détermine le nombre de durées spécifiées qui existent entre deux valeurs date/heure DatePart : DateSerial : DateValue : Day : Hour : Minute : Month : MonthName : Now : Second :


Page 64

TimeSerial : TimeValue : Weekday : WeekdayName : Year :

Catégorie Nombre Aléatoires Rnd : Randomize

Catégorie Couleur QBColor : RGB :

Catégorie Base de Régistre DeleteSetting : GetAllSettings : GetSetting : SaveSetting :

Application Collaboration AppActivate : Shell :

Catégorie Autres Beep : Envoie un signal sonore de courte durée à partir du haut-parleur interne de l’ordinateur Beep() CallByName : Choose : Environ : IIf : Option Switch :

support de cours vb.net 2003

Documents