La programmation des applications Visual Basic est dite événementielle, par opposition à la programmation linéaire traditionnelle.
Ainsi, une application Visual Basic est constituée d'un ensemble de procédures indépendantes les unes des autres.

Une procédure comprend des instructions écrites à l'aide du langage BASIC. Elle est associée à un objet, c'est à dire à un des éléments d'une feuille, la feuille elle même, ou bien un bouton, une liste, un champs de saisie etc...
La procédure est appelée par Visual Basic lorsqu'il se produit un événement pour l'objet correspondant.

Si vous n'avez pas écrit de code dans une procédure chargée de traiter un type d'événement pour un objet donné, il ne se passe rien de particulier lorsque l'événement est généré.
Pour écrire le code d'une application, il convient donc de déterminer les événements auxquels on souhaite réagir, et pour quels objets.
Cela détermine les procédures dans lesquelles le code est écrit.

La boite à outils, est une fenêtre qui comprend initialement tous les icônes visualisant des contrôles personnalisés (application complémentaire dont certains contrôles sont en option selon la version que vous possédez) pour la version standard 20 icônes.

Elle n'est accessible qu'en phase de conception (Mode Arrêt)

La fenêtre de projet comprend la liste des divers fichiers constituant une application.

La fenêtre de propriétés comprend la liste des propriétés de l'objet sélectionné dans la feuille courante (feuille) ou contrôle) ainsi que leurs valeurs.

En haut la liste des objets,présent définis dans le fichier sélectionné dans la fenêtre projet et à droite la procédure appelée par Visual Basic lorsqu'il se produit un événement pour l'objet correspondant

A ce stade de l'application, nous n'avons créé qu'une seule fenêtre, c'est donc la fenêtre principale.
La fenêtre principale que j'appelle l'interface d'accueil est la feuille que l'utilisateur voit en premier lorsque le programme est lancé.
Nous pouvons construire autant de feuilles que l'on veut et déterminer par la suite qu'elle est la feuille qui deviendra l'interface d'accueil.
Cette possibilité s'obtient par le paramétrage de l'environnement de travail de Visual Basic.

Cliquez dans la barre de menus sur l'étiquette "Projet", puis sur "Propriétés de projet1", sélectionnez "Objet de démarrage".
Si le champs de saisie comprend la valeur "Sub main", modifiez et écrivez "Form1" qui est le nom de la feuille que nous avons créée et sur laquelle nous sommes en train de travailler.
Par la suite nous modifierons la valeur de l'étiquette pour saisir le nom de la feuille que nous souhaitons lancer au démarrage du programme.

Avant de nous lancer dans la super production qui va nous tenir en haleine pendant quelques heures, je me dois de vous instruire de quelques notions qui me paraissent indispensable pour la bonne compréhension de la suite du programme.

Sous Visual Basic, certaines fonctions ne sont accessibles que combinées avec des objets. Ces instructions sont dénommées méthodes. Par exemple la méthode Show charge et affiche une fenêtre définie par l'utilisateur (vous en l'occurrence) (se référer aux sources pour les autres méthodes)

Les programmes Visual Basic sont commandés par les événements générés par les objets de l'interface utilisateur.
Par exemple, le chargement d'une feuille est un événement auquel certaines instructions peuvent être rattachées., comme par exemple l'effacement d'une feuille dans la mémoire.
L'événement sera causé par un clic de souris, dans le cas d'un bouton, ou par une modification du contenu d'une zone de texte.

Comme tout langage moderne, Visual Basic connaît les variables globales, locales et statiques.
Les variables globales sont accessibles depuis le programme entier mais les variables locales ne sont connues que dans leur procédure. Les variables statiques conservent leur valeur à la sortie de la procédure, ce qui les distingue des variables locales.

Quand un projet a été compilé, son extension devient EXE, et il n'est plus possible de le "démonter" : tous les fichiers qui le composent sont désormais intimement associés.
Les images installées dans un contrôle sont elles aussi intégrées à l'exécutable. Seuls les fichiers OCX ou TXT restent autonomes, et devront être livrés à l'utilisateur.
Les fichiers DLL devront également être fournis avec l'application.

De ce tableau on retient que si l'on doit déclarer une variable alphanumérique (caractères textes) on choisira une variable de type String
Pour une opération avec des chiffres ou des opérations de comptage simples, on choisira une variable numérique de type Integer, ou long pour des opérations importantes (voir limites).
Pour les calculs monétaires, on choisira la variable de type Currency.
Le type par défaut d'une variable est VARIANT.Ce type indique à Visual Basic que la donnée est susceptible de contenir divers types de données.
Je déconseille d'utiliser la variable de type Variant, sauf cas de force majeure.

Les instructions sont constituées de verbes qui agissent sur des variables.
Une variable peut être considérée comme une case mémoire. Elle possède un nom et une valeur.
Le nom est constitué de lettres, de chiffres et de caractères < _ > ( le souligné), le premier caractère est obligatoirement une lettre et il ne peut y avoir plus de 40 caractères dans un nom de variable.

La déclaration d'une variable se fait de plusieurs façons , à savoir :
Dim <nom de la variable> As <type de la variable>
Ex : pour déclarer une variable de type String (alphanumérique), que vous avez nommée <Bazile>, vous écrirez
Dim Bazile As String représentée dans le programme par <Bazile$>
Si la même variable est de type Integer (numérique), vous écrirez :
Dim Bazile As Integer représentée dans le programme par <Bazile%>

Exemple d'un champs de saisie comportant une étiquette ayant comme propriété Caption : Nom, et comme propriété Name : Label1.

Ne pas confondre la propriété Name qui est le nom par défaut de l'objet, et la propriété Caption qui peut avoir n'importe quel nom et qui dans la cas présent est le Nom de l'utilisateur à saisir. Vous mettrez un certain temps à vous y faire, mais, vous comprendrez avec un peu d'expérience.

La propriété Name est le nom que vous donnez à l'objet dans la phase de développement. Cette propriété n'est pas visible par l'utilisateur. Par contre la propriété Caption est le nom que vous donnez à la valeur de l'étiquette, ici dans l'exemple c'est Nom : , mais cela aurait pu être <Adresse> ou <Ville> etc...et cette propriété est visible par l'utilisateur, mais au contraire de la TextBox celle-ci n'est pas modifiable.

Nous allons essayer de mettre en pratique les formules précédemment acquises.
Lorsque vous travaillez sur l'interface de travail vous vous trouvez en mode développement.
Vous pouvez contrôler le bon déroulement des instructions ou fonctions écrites dans les pages de code en passant en mode exécution.
Nous allons écrire notre première ligne de code et visualiser le fonctionnement en mode exécution.
Ecrire dans la propriété Caption de bouton de commande "Command1" &Quitter.

Nous allons nous servir à titre de démonstration de ce bouton pour quitter notre application.

En effectuant un "DoubleClick" sur le bouton, nous ouvrons une feuille qui est la feuille de code de l'objet qui vient d'être sélectionné.

  Cette feuille se présente avec une "ComboBox"(Command1) qui vous permet en cliquant sur le petit bouton de droite de dérouler une liste qui comprend tous les noms d'objets utilisés dans cette feuille(Form1).
La "ComboBox de droite(Click) liste toutes les propriétés disponibles pour l'objet sélectionné.
Nous devons générer un événement lorsque l'utilisateur appuiera sur le bouton, et lorsqu'il générera un clic avec le curseur de la souris.
Nous sélectionnerons donc l'événement "Click".
Ecriture du code dans la feuille de code du bouton de commande "Command1" avec l'événement "Click"
Nous écrivons notre première procédure en saisissant:

Private Sub Command1_Click ( )
'Sortie du programme
	 End
End Sub

  Vous avez vu que j'ai mis une apostrophe devant la ligne de texte "'Sortie du programme"
Ces lignes commençant par une apostrophe sont nommées "lignes de commentaires.  Il est conseillé en effet d'indiquer sous forme de texte l'explication de l'événement que l'on a voulu effectuer.
Cela sera très utile surtout lorsque notre programme sera composé de plusieurs dizaines de procédures.
Ne pas s'en priver d'autant que le compilateur ignore complètement les lignes de commentaires.

Si vous êtes un peu curieux(Il faut l'être en programmation) et que vous avez cliqué sur "Général" dans la feuille de code vous constatez que l'interface comprend une instruction "Option Explicite".
Cette instruction force le développeur à déclarer toutes les variables à utiliser dans son programme.
Si vous oubliez de déclarer une variable en phase de conception, le programme vous rappellera à l'ordre et vous indiquera une erreur.

Puisque nous venons de créer notre première procédure, essayons de la lancer pour visualiser ce qu'il se passe.
Dans la barre d'outils, cliquez sur le bouton exécuter
formé d'un petit triangle.
La feuille doit s'afficher, et lorsque vous cliquez sur le bouton "Quitter", l'application doit se fermer.

La prochaine leçon sera réservée à la création de tableaux.