Ma voiture est un objet, cet objet existe, on peut l'utiliser.

Ma voiture fait partie de "Les voitures", du type, du genre "Les voitures". "Les voitures" c'est une classe (Class) qui a ses caractéristiques.
"Les voitures" ont une couleur, un moteur…, elles roulent en transportant des passagers…

mais je ne peux pas utiliser "Les voitures", la Classe; pour me déplacer, il faut avoir un objet "voiture".

Avec la Classe je vais créer des Objets.

Pour fabriquer ma voiture, je prends les caractéristiques de la class "Les voitures" (c'est comme un moule, une usine) et je fabrique une voiture, je la nomme 'MaVoiture'.

Dim MaVoiture As New Lesvoitures

MaVoiture est maintenant un nouvel objet de type 'Les voitures'.

Class --> Objet

Type 'Les voitures'--> Objet 'Mavoiture'

Un Objet est créé selon un 'modèle' qu'on appelle une Classe.

On dit aussi qu'il faut instancier un objet à partir de la Classe.

'Mavoiture' est une instance de la classe 'Les voitures'.

(On dit aussi une 'occurrence' de la classe).

De manière générale, une classe est une représentation abstraite de quelque chose.
Tandis qu'un objet est un exemple utilisable de ce que représente la classe.

Remarque

Avec la même classe on peut instancier plusieurs Objets.

Propriétés (Attributs)

Prenons MaVoiture.

Elle a des propriétés : une marque, une couleur, une puissance…

Pour indiquer la couleur de ma voiture on utilise la notation :

MaVoiture.couleur

Syntaxe : Objet.Propriété (Il y a un point entre les 2 mots).

Pour modifier la couleur et avoir une voiture verte on écrit :

MaVoiture.couleur= "Vert"

Et la voiture devient verte !!

MaVoiture.Phares.Avant indique les phares avant de la voiture.

MaVoiture.Phares.Avant.Allumé indique l'état des phares (Allumé ou non)

Si je fais :

MaVoiture.Phares.Avant.Allumé=True (Vrai) cela allume les phares.

Méthodes

MaVoiture fait des choses : elle roule par exemple.

Pour faire rouler la voiture j'appelle la méthode 'Roule'.

MaVoiture.Roule

Syntaxe : Objet.Méthode (il y a un point entre les 2 mots).

Si c'est possible pour cette méthode je peux indiquer à quelle vitesse la voiture doit rouler :

MaVoiture.Roule(100) 'j'ai ajouté un paramètre.

Le paramètre est un renseignement envoyé avec la méthode.

Il est possible parfois d'indiquer en plus si la voiture doit rouler en marche avant ou en marche arrière.

MaVoiture.Roule(10, Arriere)

Il y a donc 2 manières d'appeler la méthode Roule : avec 1 ou 2 paramètres, on dit que la méthode est surchargée, chaque manière d'appeler la méthode s'appelle 'signature'.

Première signature: MaVoiture.Roule(100)

Seconde signature: MaVoiture.Roule(10, Arriere)

événement

Des événements peuvent survenir sur un objet.

MaVoiture_démarre est un événement, quand la voiture se met en route (si par exemple j'ai fait MaVoiture.Roule(10, Arriere)), cet événement démarre se déclenche automatiquement.

Interface et implémentation

Ce que je vois de l'objet, c'est son interface exemple: la méthode Roule fait partie de l'interface d'une voiture. Par contre ce qui fait rouler physiquement la voiture se nomme implémentation, c'est le moteur, ce n'est ni visible ni accessible.

Si je crée une voiture je vais faire l'implémentation, je vais fabriquer le moteur, mais si je suis simplement utilisateur de l'objet voiture, je vais me contenter d'utiliser l'interface.

Visibilité

Quand un objet est créé, il est visible et utilisable, uniquement dans la zone où il a été défini.

Relation entre Objets

Héritage

Une Classe (un moule) peut hériter d'une autre classe (d'un autre moule).

La classe Voiture hérite de la classe Véhicule, cela veut dire qu'une voiture est un véhicule; la classe voiture aurait les propriétés de la classe Véhicule.

Contenant-contenu

On peut créer une Classe qui contient des Objets, une classe qui se compose d'objets. On parle de composition.

L'objet Voiture contient 4 objets Roue.

On dit que l'objet encapsule le contenu.

Collections

Les collections sont des groupes d'objets semblables qui peuvent être énumérés.

Un parc automobile contient X Voitures, chaque voiture a un numéro d'item:

ParcVoiture.item(1) pour la première Voiture ;

ParcVoiture.item(2) pour la seconde Voiture.

Espace de noms

Un espace de noms regroupe des objets qui appartiennent au même 'domaine'. Cela sert a différencier des objets qui ont même nom, mais ne font pas partie du même domaine. Si je parle de 'Porte' ce terme n'a pas la même signification si je suis dans l'espace de noms 'Composant électronique' (on y trouve des portes logiques) ou l'espace de noms 'Maison'.

Tout cela c'est simpliste, mais voilà, vous avez compris ce qu'est un objet !

Une application Windows se compose de fenêtres (nommées aussi formulaires) dans lesquelles se trouvent des contrôles (bouton, liste, texte…).

Exemple de fenêtre avec 2 boutons, une zone de texte (un label) et une icône :

Dans une application Windows, il y a aussi des lignes de code utilisant des variables pour faire des calculs.

En Visual Basic.Net tout est objet :

- les fenêtres (on dit les formulaires) ;

- les variables ;

- les contrôles (bouton, liste, image, case à cocher…).

Il faut un moule pour faire un objet. Le moule c'est une Classe.

Le moule va servir à créer un objet,on dit une instance.

On peut créer, instancier une multitude d'objets avec le même moule.

Pour créer, démouler un objet, on utilise les mots-clés Dim et As New.

Dim objet As New Classe

New est un constructeur.

Exemple : créer une fenêtre (un formulaire) :

Je dessine une fenêtre FormDémarrage (c'est la Classe, le moule)

puis

Dim F As New FormDémarrage

Crée une fenêtre qui se nomme 'F' à partir du moule, du modèle (FormDémarrage) que j'ai dessiné.

Autre exemple :

Dim B As New Button

Créer un bouton nommé 'B' avec les attributs habituels des boutons (Class Button)

Troisième exemple

Comment créer une variable nommée Mavariable pouvant contenir un entier (Integer)

Dim MaVariable As New Integer

Dim MaVariable As Integer 'est correct aussi.

Ici, pour une variable, on remarque que New peut être omis

Tout objet a des propriétés.

On utilise la syntaxe : Objet.Propriété (il y a un point entre les 2 mots).

Si F est une fenêtre, F.BackColor indique la couleur de fond de la fenêtre.

S'il y a un bouton, la couleur de fond du bouton sera :

Bouton.BackColor

ou

F.Bouton.BackColor

Noter la syntaxe : la couleur du bouton qui est dans la fenêtre F.

En fait une propriété c'est une sorte de variable.

Comment modifier cette propriété ?

Bouton.BackColor=Color.Red

'modifie la couleur de fond du bouton

Autre exemple :

La propriété Visible : si elle a la valeur True (Vraie) l'objet est visible, si elle est à False l'objet n'est pas visible.

Bouton.Visible=False

fait disparaitre le bouton.

=Ici il y a un bouton invisible !! oui, oui !!

Les objets ont des méthodes parfois.

Une méthode agit sur l'objet ou fait agir l'objet.

Prenons un exemple simplifié.

Les listes (liste déroulante) ont des lignes (Items) et une méthode Clear qui permet de les vider.

Si je veux vider toutes les lignes d'une liste nommée Liste1, je fais :

Liste1.Items.Clear()

Les propriétés et méthodes se nomment les membres d'un objet.

Certains objets ont des événements.

Reprenons notre bouton. Quand l'utilisateur clique dessus, l'événement Bouton_Click survient.

Ce sont les objets contrôles (bouton, case à cocher…)et les formulaires qui ont des événements.

Interface et implémentation

Ce que je vois de l'objet, c'est son interface (le nom des propriétés, méthodes…) exemple : la méthode Clear fait partie de l'interface d'une ListBox. Par contre le code qui effectue la méthode (celui qui efface physiquement toutes les lignes de la listBox), ce code se nomme implémentation, lui n'est ni visible ni accessible.

Visibilité

Quand un objet est créé, il est visible et utilisable, uniquement dans la partie du programme où il a été défini.

Par exemple habituellement, je peux voir et modifier la couleur d'un bouton uniquement dans le code de la fenêtre ou il est situé.

Pour les variables on parle de portée : la variable peut être locale (Private) ou de portée générale ('Public') visible partout.

Relation 

Héritage

Une Classe (un moule) peut hériter d'une autre classe (d'un autre moule).

La classe Button hérite de la classe Control, cela veut dire qu'un bouton est un contrôle.

Si je crée un bouton, il aura les caractéristiques de la classe Button, mais aussi de la classe Control.

Contenant-contenu

Une Classe peut contenir d'autres classes.

Je peux décider qu'un Objet Rectangle va contenir 4 Objets Point

Collections

Les collections sont des groupes d'objets semblables qui peuvent être énumérés.

Une fenêtre Windows (on dit un 'formulaire' contient une collection nommée 'Controls' composée de tous les objets (boutons, List, texte) contenus dans la fenêtre :

maFenetre.Controls.item(1)

contient par exemple le premier bouton

maFenetre.Controls.item(2)

contient par exemple une liste.

En résumé

Une classe est un élément logiciel qui décrit un type de données abstrait. Un type de données abstrait est un ensemble d'objets définis par une liste d'opérations et les propriétés de ces opérations Une classe est un élément logiciel qui décrit les caractéristiques d'un ensemble d'objets. En programmation orientée une classe déclare des propriétés communes à un ensemble d'objets. La classe déclare des attributs représentant l'état des objets et des méthodes représentant leur comportement. Une classe représente donc une catégorie d'objets. Il apparait aussi comme un moule ou une usine à partir de laquelle il est possible de créer des objets. On parle alors d'un objet en tant qu'instance d'une classe (création d'un objet ayant les propriétés de la classe). (www.techno-science.net)

En Visual Basic.net tout est objet.

Les Classes sont des types d'objets.

Pour créer (instancier) un objet à partir d'une Classe, il faut utiliser les mots clé Dim …As New :

Dim Objet As New Class

Un objet a :

• des propriétés ;
• des méthodes ;
• des événements.

Espace de noms

Les objets sont regroupés dans des bibliothèques d'objets, dans des 'espaces de noms'.

Il faut parfois importer la bibliothèque avant d'utiliser l'objet :

'Importe l'espace de noms Systel.IO
Imports System.IO

'On peut maintenant utiliser l'objet 'File':
Fl = File.Exists("vessaggi.gif")

Si l'import n'a pas été fait, System.IO.File.Exists() est accepté aussi.

Lexique anglais=>français.

New = Nouveau.

Le programmeur va dessiner l'interface utilisateur (fenêtre, bouton, liste…), il va ensuite uniquement écrire les actions à effectuer quand certains événements se produisent sur cette interface.

C'est Visual Basic qui va entièrement s'occuper de la gestion des événements.

Il affiche 'Bonjour' quand on clique sur un bouton.

Ce n'est pas original : le premier programme, dans tous les cours d'informatique, permet d'afficher 'Bonjour' (ou 'Hello Word').

Que voit l'utilisateur du programme ?

L'utilisateur final, celui qui utilise le logiciel, voit une fenêtre avec un bouton, S'il appuie sur ce bouton il voit s'afficher "Bonjour".

Que se passe-t-il dans le programme ?

Quand l'utilisateur clique sur le bouton, cela déclenche automatiquement un événement. (Button1_Click), cet événement contient du code qui affiche "Bonjour".

Que doit faire le programmeur pour arriver à ce résultat ?

Pour atteindre ce résultat, le programmeur va dessiner la fenêtre, le bouton, la zone d'affichage du texte (un label) puis il va simplement indiquer dans l'événement Button_Click d'afficher "Bonjour".

Voir la vidéo : au format 'Flash'> ou au format 'Avi' en Visual Basic 2005.

Le programmeur est en mode 'conception' (ou mode Design) : il écrit le programme.

III-B-3-a. Il dessine l'interface utilisateur▲

(Ce que verra l'utilisateur final, c'est l'interface utilisateur : une fenêtre avec des boutons, des listes, du texte…) :

Il ouvre un projet : une fenêtre 'Form1' apparait.

Il ajoute un bouton.

Pour cela il utilise la Boite à outils :

Il clique sur 'Boite à Outils' à gauche, bouton Windows Forms, puis bouton 'Button', il clique dans Form1, déplace le curseur sans lâcher le bouton, puis lâche le bouton de la souris : le dessin d'un bouton apparait.

Pour l'exemple,Il ajoute un label.

Un label est un contrôle qui permet d'afficher un texte.

Comme pour le bouton, il clique sur 'Boite à Outils' à gauche, bouton Windows Forms, bouton 'Label' et met un contrôle label sur la fenêtre.

III-B-3-b. Il écrit le code correspondant aux événements▲

Il double-clique sur le bouton qu'il a dessiné :

Une fenêtre de conception de code s'ouvre et il apparait :

 

Sélectionnez

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

End Sub

Cela correspond à la procédure événement en rapport avec l'événement 'On a cliqué sur le bouton1'.

Quand le programme fonctionne, quand l'utilisateur du logiciel clique sur le bouton1, le code situé entre Private Sub Button1Click et End Sub est effectué.

Une procédure est un ensemble de lignes de code qui commence par Sub et se termine par End Sub (ou Function…End Function).

Comment indiquer dans cette procédure d'afficher "Bonjour" ?

Le label possède une propriété nommée '.text' qui contient le texte à afficher.

Il faut taper le code qui modifie cette propriété '.text' , qui y met la chaine de caractères "Bonjour":

 

Sélectionnez

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Label1.Text = "Bonjour"

End Sub

Cela donne :

Voilà votre premier programme est écrit.

Comment exécuter ce programme ?

Il est possible de tester immédiatement le programme en mode débogage, sans quitter l'environnement de développement.

Utiliser le menu 'Déboguer' puis 'Démarrer' qui lance l'exécution du programme.

On peut aussi taper sur F5 pour lancer le programme.

Ou plus simplement cliquer sur la flèche :

C'est plus rapide, lancer l'exécution avec le premier bouton, le second servant à arrêter temporairement l'exécution, le troisième à terminer l'exécution.

En mode exécution

L'utilisateur voit bien une fenêtre avec un bouton, s'il clique dessus, "Bonjour" s'affiche.

Quand le programme est totalement écrit, terminé, testé, il est possible de le compiler et ainsi de créer un fichier exécutable (possédant une extension '.exe') qui fonctionne de manière autonome en dehors de l'environnement de développement.

C'est ce fichier exécutable qui est fourni à l'utilisateur.

Par opposition le code écrit par le programmeur, composé d'instructions Visual Basic, se nomme le code source.

En résumé

Le programmeur utilise des outils de dessin pour construire une interface utilisateur : des fenêtres avec des contrôles dessus: menus, boutons, case à cocher…

VB, pour chaque fenêtre ou pour chaque contrôle, génère une liste d'événements, (événement lié au chargement d'une fenêtre, événement lié au fait de cliquer sur un bouton, événement survenant quand on modifie un texte…).

Il suffit, dans la procédure événement qui nous intéresse, d'écrire le code qui doit être effectué lorsque cet événement survient.

Comme nous l'avons vu le code sert à agir sur l'interface (Afficher un texte, ouvrir une fenêtre, remplir une liste, un tableau), mais il peut aussi effectuer des calculs, évaluer des conditions et prendre des décisions, travailler en boucle de manière répétitive et ainsi effectuer les tâches nécessaires.

Une instruction est le texte tapé au clavier dans le 'code source' et permettant d'effectuer une opération, une déclaration, une définition.
Elle contient des mots-clés, des opérateurs, des variables, des constantes et des expressions des appels à des fonctions ou des méthodes. On verra cela en détail.

Dim A As Integer

est une instruction (de déclaration).

A = 1

est aussi une instruction qui effectue une opération.

C'est habituellement une 'ligne de code exécutable'…

Une instruction est exécutée lorsque le programme marche.

Plusieurs instructions peuvent se suivre sur une même ligne, séparées par ':'

Dim B As String : B="Bonjour"

Si une ligne est très longue, on peut passer à la ligne grâce à ' _'

(caractère 'Espace' puis caractère "_" puis immédiatement après, passage à la ligne) :

Dim B, C As String
B = "Bonjour monsieur ": C= _
"le professeur"

est équivalent à :

Dim B, C As String
B = "Bonjour monsieur ": C= "le professeur"

En VB 2010, après certains mots, il peut y avoir continuation de ligne implicite (plus besoin de _ après la virgule, une parenthèse ouvrante, après & ou { ou = ou +…).

Quand un programme tourne, les instructions sont effectuées ligne après ligne.

1  Dim B As String 

2  B="Bonjour"

3  Dim A As Integer 

4  A= 3

5  A= A + 1

La ligne 1 est exécutée puis la ligne 2 puis la 3, la 4…

Bien que l'on puisse avoir des numéros de ligne, ils ne sont plus utilisés actuellement et non visibles :

Dim B As String 

B="Bonjour"

Dim A As Integer 

A= 3

A= A + 1

Pour mettre des commentaires dans un programme, on le fait précéder de ' (on peut aussi utiliser le mot REM en début de ligne).

'Ceci est un commentaire, 
'Cela n'est pas une instruction.
REM Ceci est aussi un commentaire.

Le commentaire ne sera pas exécuté.

Il peut aussi, à partir de VB 2005 , y avoir des commentaires en XML, ils sont dans ce cas précédés de ''' (3').

Une procédure est un ensemble d'instructions, de lignes de code, un groupement d'instructions bien définies effectuant une tâche précise.

Les procédures sont bien délimitées.

Il y en a de 2 sortes.

Les procédures Sub

Elles débutent par le mot Sub et se terminent par End Sub.

Les procédures Function

Elles débutent par Function et se terminent par End Function.

Exemple :

Sub Maprocédure

   A=1

End Sub

Exemple concret d'une procédure : la procédure Button_Click du premier programme. (Celui qui affiche 'Bonjour', elle ne contient qu'une ligne de code. Le mot Sub est précédé de Private, on verra plus loin ce que cela signifie.

Vous avez vu que l'on peut dessiner l'interface, une fenêtre Form1 par exemple. En mode conception, après avoir dessiné l'interface, on doit avoir accès aux procédures.

Quand on voit ces procédures, on peut y inclure du code.

Nous allons voir qu'il y a 2 types de procédures : les procédures liées aux événements et celles qui ne sont pas liées.

Si on double-clique sur le fond d'une fenêtre (en vb 2010),(celle du programme 'Bonjour') on voit apparaitre les procédures liées à cette fenêtre et aux contrôles contenus dans cette fenêtre :

Public Class Form1



Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)  _
Handles MyBase.Load

            Label1.Text = ""   

End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles Button1.Click

        Label1.Text = "Bonjour"

End Sub

End Class

Détaillons :

Public Class Form1
    
End Class

Ce n'est pas une procédure, mais la 'Classe' définissant la fenêtre.

En VB 2003, il y a une 'région' que vous déroulez, en cliquant sur le petit +, vous pouvez y lire le code permettant de créer la fenêtre, les contrôles… C'est généré automatiquement par VB. (Le chapitre VII-C sur les formulaires explique en détail le code généré par VB, mais c'est un peu complexe pour les débutants pour le moment !!).

En VB 2005 2008 et 2010, cette partie générée par VB n'est pas visible directement.

Il faut comprendre qu'à un formulaire (fenêtre) et aux contrôles qui sont dans ce formulaire correspond du code généré par VB. Ce code (sur lequel vous n'intervenez habituellement pas) permet de créer le formulaire et les contrôles.

Chaque fenêtre a une procédure Form_Load qui est exécutée lorsque la fenêtre est chargée, on y met généralement le code initialisant la feuille.

Private Sub Form1_Load

End Sub

Il y a bien d'autres procédures liées à la fenêtre.

Dérouler la liste box en haut à gauche de la fenêtre de code, cliquer sur (Form1 events), si vous déroulez maintenant la liste à droite vous aurez tous les événements qui génèrent une procédure :

Load Lors du chargement de la fenêtre ;

Unload Lors du déchargement de la fenêtre ;

Activated Lorsque la fenêtre devient active ;

GotFocus Lorsque la fenêtre prend le focus ;

Resize Lorsque la fenêtre est redimensionnée.

Private Sub  Button1_Click

End Sub

C'est la procédure liée au bouton et qui contient le code à effectuer quand l'utilisateur clique sur le bouton.

C'est là que l'on écrit le code qui doit s'effectuer lorsque l'utilisateur clique sur le bouton.

De la même manière que pour la fenêtre, vous pouvez voir dans la liste en haut, tous les événements liés aux boutons qui génèrent une procédure :

Click Lorsque l'utilisateur clique sur le bouton ;

DoubleClick Lorsque l'utilisateur double-clique sur le bouton ;

MouseDown 'se déclenche si appui du bouton gauche de la souris ;

MouseUp 'se déclenche si relâchement du bouton gauche de la souris.

Parfois on a besoin de code qui fait une tâche particulière, qui est utilisé à plusieurs endroits et qui n'est pas liée à un événement.

On crée dans ce cas une procédure indépendante des événements.

Le système des procédures permet aussi de découper un problème complexe en quelques fonctions moins complexes et indépendantes les unes des autres.

Un programme vb est donc composé de procédures dont l'exécution est déclenchée par des événements (ouverture d'une fenêtre, clic sur un bouton…), ces procédures en appellent d'autres qui en appellent d'autres…

Ces procédures sont en fait des sous-programmes : si une ligne appelle une procédure, le programme 'saute' au début de la procédure, il effectue le code de la procédure puis revient juste après la ligne qui avait appelé la procédure et continue les lignes suivantes.

Exemple : plusieurs fois dans le programme j'ai besoin de calculer la surface d'un cercle à partir de son rayon et de l'afficher sur un label.

Plutôt que de retaper dans chaque procédure le code, je peux créer une procédure 'Sub' nommée AfficheSurfaceCercle.

Il suffit ensuite si nécessaire d'appeler la procédure qui effectue le calcul et affiche le résultat puis revient effectuer le code situé après l'appel.

Comment appeler une procédure ?

Avec :

Call NomdeProcedure()

ou par

NomdeProcedure()

Call est facultatif.

Noter les parenthèses après le nom de la procédure.

Comment créer cette procédure Sub ?

Dans la fenêtre de code, tapez :

Sub AfficheSurfaceCercle

puis validez. Vous obtenez :

Sub AfficheSurfaceCercle()

End sub

Le code de la procédure est compris entre le Sub et le End Sub.

Pour que le calcul se fasse, il faut fournir (transmettre de la procédure qui appelle à la procédure Sub) la valeur du rayon.

Pour indiquer que la Sub doit recevoir un paramètre (un argument en VB) ajouter entre les parenthèses :

Sub AfficheSurfaceCercle( Rayon as Single)

Cela signifie qu'il existe une procédure qui reçoit comme paramètre une variable de type Single (Réel simple précision) contenant le Rayon.

Ajouter le code :

Label.text =(3.14*Rayon*Rayon).ToString

Que fait cette ligne ?

Elle fait le calcul: '3.14*Rayon*Rayon' ('*' signifie multiplier), on transforme le résultat en chaine de caractères (grâce à '.ToString') que l'on met dans la propriété .text du label : Cela affiche le résultat. (On verra toute cette syntaxe en détail ultérieurement.)

On obtient :

Sub AfficheSurfaceCercle( Rayon as Single)

    Label.text =(3.14*Rayon*Rayon).ToString

End sub

Comment appeler cette Sub ?

N'importe quelle procédure pourra appeler la Sub AfficheSurfaceCercle en envoyant la valeur du rayon afin d'afficher la surface du cercle dans un label.

Exemple d'appel pour un rayon de 12 :

AfficheSurfaceCercle(12)

Affiche dans le label : 452.16.

Parfois on a besoin que la procédure retourne un résultat, un seul, qu'elle donne en retour un résultat à la procédure appelante. Dans ce cas on utilise une Fonction.

Exemple : je veux créer une fonction à qui je fournis un rayon et avoir en retour la surface d'un cercle.

Comment créer cette Function ?

Tapez Function SurfaceCercle puis validez, ajouter (Rayon As Single)

Tapez Return 3.14*Rayon*Rayon

Ce que la fonction doit retourner est après Return (ce que la procédure doit renvoyer à la procédure appelante).

On obtient la fonction complète :

Function SurfaceCercle( Rayon as Single)

    Return 3.14*Rayon*Rayon

End Function

Comment appeler cette Function ?

Dans la procédure qui appelle, il faut une variable pour récupérer la valeur retournée par la Fonction :

S= NomdelaFonction()

N'importe quelle procédure pourra appeler la fonction et obtenir le résultat dans la variable S par exemple pour un rayon de 12 :

Dim S As Single

S=SurfaceCercle(12)

On appelle la fonction SurfaceCercle en envoyant le paramètre '12', ce qui fait qu'à l'entrée de la fonction, Rayon=12, le calcul est effectué et le résultat du calcul (452.16) est retourné grâce à Return. S récupère ce résultat.

Après l'appel de cette fonction, S est égal à 452.16.

Il est possible de spécifier le type retourné par la fonction :

Function SurfaceCercle( Rayon as Single) As Single

As Single en fin de ligne après () indique que la fonction retourne un Single (un nombre en simple précision). Il faut donc que la variable qui reçoit la valeur retournée (S dans notre exemple) soit aussi un Single.

Il existe une autre manière de retourner le résultat d'une fonction, reprenons l'exemple précédent, on peut écrire :

Function SurfaceCercle( Rayon as Single)

     SurfaceCercle= 3.14*Rayon*Rayon

     Exit Function

End Function

Ici on utilise le nom de la fonction pour retourner le résultat, avec un signe '='.

Utilisez plutôt la méthode Return.

Exit Function permet aussi de sortir de la fonction, cela a le même effet que Return sauf que Return peut être suivi d'un argument de retour (et pas Exit Function).

La Sub AfficheSurfaceCercle affiche le résultat dans le formulaire où elle est située.

Par contre la fonction SurfaceCercle est d'intérêt général, n'importe quelle procédure doit pouvoir l'appeler, de plus elle n'intervient pas sur les contrôles des formulaires et n'est donc pas liée aux formulaires.

On la placera donc dans un module standard qui est un module du programme qui ne contient que du code. (Pas d'interface utilisateur)

Pour créer un module standard Menu Projet>Ajouter un module.

Y mettre les procédures.

Avant le mot Sub ou Function on peut ajouter :

Private indiquant que la procédure est accessible uniquement dans le module.

C'est donc une procédure privée.

Les procédures liées aux événements d'une feuille sont privées par défaut.

Public indiquant que la procédure est accessible à partir de toute l'application.

S'il n'y a rien devant Sub la procédure est publique

Exemple :

Private Function SurfaceCercle( Rayon as Single)

    Return 3.14*Rayon*Rayon

End Function

Pour sortir d'une procédure Sub avant la fin, utiliser Exit Sub (Exit Function pour une fonction).

Quand vous appelez une procédure, il faut toujours mettre des parenthèses même s'il n'y a pas de paramètres.

FrmSplash.ShowDialog ()

Éventuellement on peut faire précéder l'appel du mot-clé Call, mais ce n'est pas obligatoire.

Call FrmSplash.ShowDialog ()

Nommage

Quand vous créez une procédure utilisez "la casse Pascal" pour créer les noms de routine:

la première lettre de chaque mot est une majuscule (c’est donc une convention).

Sub CalculTotal()

Call = Appel.

Return= Retour.

Private= Privé.

Show= spectacle, exposition.

To show= montrer.

On a vu qu'un programme est décomposé en modules, chaque module contenant des procédures.

Chaque module correspond physiquement à un fichier '.vb'.

Il existe

• les modules de formulaire ;
• les modules standards ;
• les modules de 'Classe'.

Comment se présentent-ils ?

Un programme Visual Basic comporte donc :

• Les 'Modules de Formulaires' contenant :
  - le dessin des fenêtres de l'interface utilisateur (ou formulaire)contenant les contrôles (boutons, listes, zones de texte, cases à cocher…) ;
  - le code qui comprend :
  les procédures liées aux événements de la feuille (Button_Click…),
  les procédures indépendantes des événements. Ce sont des Sub() ou des Function().
  Exemple :

   

  Sélectionnez

  Class Form1        'Nom du Formulaire
  
  Inherits System.Windows.Forms
  
  Public A as String
  
      ……
  
  Private Button1_Click 'Procédure liée à un événement
  
   …
  
  End Sub
  
   
  
  Sub MaRoutine         'Procédure indépendante
  
   ….
  
  End Sub
  
  End Class

  Un programme Visual Basic comporte donc :

• les modules standards.
  Ils servent de stockage de procédures. Procédures "d'intérêt général".
  Ces procédures sont des Sub() ou des Function() qui peuvent être appelées à partir de n'importe quel endroit (pourvu qu'elles soient 'Public').
  Ils peuvent aussi servir à déclarer les objets ou déclarer les variables 'Public' qui seront utilisées donc accessibles par la totalité du programme.
  Exemple :

   

  Sélectionnez

  Module Module1        'Nom du Module
  
      Public A as String
  
      ……
  
   Sub MaRoutine        'Procédure indépendante
  
   ……
  
   End Sub
  
  End Module

  Un programme Visual Basic comporte donc :

• les modules de Classe.
  Ils ont vocation à fabriquer des objets, on verra cela plus loin (Chapitre sur la programmation objet).
  Exemple :

Class MaClasse            'Nom de la Classe

    Public A as String

    ……

End Class

Un programme Visual Basic comporte donc :

Exemple :

Module Module1        'Nom du Module

….

End Module

 

Sub MaRoutine        'Procédure

 ……

End Sub

Faire Menu Projet puis Ajouter un module. Donner un nom au module. C'est Module1.vb par défaut.

Module Module1        'Nom du Module

….

End Module

On remarque que le module est bien enregistré dans un fichier '.vb'.

Un module standard ne contient que du code.

Comment ajouter une Sub dans un module Standard ?

Taper Sub Calcul puis valider, cela donne :

Sub Calcul()

End Sub

Remarque Les Sub, Functions et Modules sont utilisés dans un type de programmation dite 'procédurale' où on découpe le code. Il existe un autre type de programmation dit 'Objet' ou on crée et on utilise des Objets, on verra cela plus tard.

Return = Retour.

Choisir l'icône 'Application Windows forms', puis donner un nom au projet, enfin valider sur 'OK'.

(Le chemin de l'emplacement du projet n'est pas modifiable ici, il est par défaut ' C:\Documents and Settings\Nom Utilisateur\Mes documents\Visual Studio 2008\ Projects\MonProjet'.)

On remarque qu'on aurait pu choisir 'Application WPF', on y reviendra.

Dans un nouveau projet, créer ou ajouter une fenêtre 'WinForm'.

Pour ajouter une fenêtre (un formulaire) Menu Project, Ajouter un formulaire Windows ( 'Add a WindowsForms' en version anglaise ) :

Cliquer sur Windows Form, une fenêtre (un formulaire) Form2 vide apparait (Form1 était le nom du premier formulaire).

Il y a des fenêtres toutes faites pour accélérer le travail (les templates) comme les 'Écrans de démarrage' les 'Formulaire Explorateur'…

Designer

La zone de travail se trouve au centre de l'écran : c'est l'onglet Form1.vb[Design] ci-dessous qui donne donc accès au dessin de la feuille (du formulaire), on peut ajouter des contrôles, modifier la taille de ces contrôles…

On peut passer en mode 'Multidocument Mdi' (comme en VB6) au lieu du mode 'Onglet'.

(Passer par le menu 'Outils' puis 'Options…' puis bouton 'Multidocument (Mdi)'.)

On obtient un mode multidocument avec plusieurs fenêtres.

Exemple en mode Mdi montrant les 3 types de modules.

À noter que si on utilise le menu 'Projet' puis 'Ajouter…' cela permet d'ajouter un formulaire, un module standard, un module de Classe.

Voir les procédures.

L'onglet Form1.vb donne accès aux procédures liées à Form1.

On peut 'taper' du code dans les procédures.

La liste déroulante de gauche donne la liste des objets, celle de droite, les événements correspondants à cet objet.

Il est possible en double-cliquant dans le formulaire ou un contrôle de se retrouver directement dans le code de la procédure correspondant à cet objet.

Ici on voit la procédure Button1_Click liée au Button1 de la fenêtre de Design.

Ajouter des contrôles au formulaire 'Winform'

Ajouter un bouton par exemple :

Cliquer sur Boite à outils (Toolbox) à gauche, les contrôles apparaissent tous ou classés par ordre alphabétique.

Cliquer sur 'Button' dans la boite à outils, cliquer dans la Form, déplacer le curseur sans lâcher le bouton, puis lâcher : un bouton apparait.

Modifier les propriétés d'un contrôle ou du formulaire.

Quand un formulaire ou un contrôle est sélectionné dans la fenêtre Design, ses propriétés sont accessibles dans la fenêtre de 'Propriétés' (Properties) à droite en bas : ici ce sont les propriétés du contrôle 'Button1' qui sont visibles (Text, Location…) on peut modifier directement les valeurs.

En bas de la fenêtre propriétés, il y a une explication succincte de la propriété sélectionnée (si elle n'apparait pas, clic droit sur la propriété puis dans le menu 'Description').

Exemple

Si au niveau de la ligne 'Text' des propriétés du bouton, j'efface 'Button1' et que je tape 'OK', dans le designer, le texte écrit sur le bouton deviendra 'OK'.

Le déplacement des contrôles ou l'accès aux principales tâches est facile.

La croix à gauche permet de déplacer le contrôle, la petite flèche à droite permet d'ouvrir un menu qui donne accès aux tâches les plus fréquentes.

L'alignement automatique des contrôles

Si on modifie la taille ou l'emplacement d'un contrôle, VB signale par un trait bleu que le contrôle modifié et le contrôle voisin sont alignés :

Renommer un nom : modification automatique

On nomme cela 'Refactoring': cliquer sur une variable, puis bouton droit, dans le menu cliquer sur 'Renommer'. Modifier le nom de la variable, valider. Dans toute la Classe la variable est renommée.

Voir tous les composants d'un projet

Pour cela il faut utiliser la fenêtre Explorateur de solutions en haut à droite, elle permet de voir et d'avoir accès au contenu du projet (pour voir tous les fichiers, il faut cliquer sur le deuxième bouton en haut) : gridview est le nom du programme.

MyProjet : double-cliquer dessus, vous ouvrirez la fenêtre 'propriétés du projet'.

Références qui contient les dll chargées. Pour atteindre les références, on peut aussi passer par le menu 'Projet' puis 'Propriétés' ou double-cliquer sur 'MyProjet' puis choisir l'onglet 'Références'.

Form1.vb est un formulaire (une fenêtre). Les formulaires, modules de classe ou standard sont tous des '.vb' Il suffit de double-cliquer dessus pour les ouvrir.

Si on ouvre la sous-liste de Form1.vb (en cliquant sur le '+'), on voit :

Form1.Designer.vb (qui montre le code qui crée le formulaire, on n'a pas à y toucher) ;

Form1.resx (le fichier de ressources).

Il suffit de cliquer sur la ligne Form1 dans l'explorateur de solution pour voir apparaitre la Form1 dans la fenêtre principale.

Si on clique sur un espace de noms dans la liste Références, cela montre l'arborescence des Classes.

Tester son logiciel

On peut tester le projet grâce à : lancer l'exécution avec le premier bouton (mode 'Run', le second servant à arrêter temporairement l'exécution (mode 'Debug'), le troisième à terminer l'exécution (Retour au mode 'Design' ou 'Conception').

Quand on est en arrêt temporaire en mode 'Debug', la ligne courante, celle qui va être effectuée, est en jaune :

Si on tape la touche F10 (exécution pas à pas), la ligne 'Label1.Text=i.ToString' est traitée et la position courante passe à la ligne en dessous.

En mode Debug, on peut modifier une ligne et poursuivre le programme qui tiendra compte de la modification (sauf pour les déclarations). On parle d''Edit and continue'.

La sauvegarde du projet se fait comme dans tous les logiciels en cliquant sur l'icône du paquet de disquettes.

On peut compiler le programme pour créer un exécutable par le menu Générer ('Build'). Le code présent dans l'IDE est le code source, après compilation le fichier exécutable contient du code exécutable.

Projet

Dans la terminologie VB, un projet est une application en cours de développement.

Une 'solution' (Team Project) regroupe un ou plusieurs projets (c'est un groupe de projets). Il n'y en a pas dans la version express.

En VB express on parle donc uniquement de projet, en fait ,VB crée aussi une solution de même nom.

Fichiers, Chemins des sources

Si vous regardez dans ' C:\Documents and Settings\Nom Utilisateur\Mes documents\Visual Studio 2008\ Projects\MonProjet')les fichiers correspondant à un projet VB :
sous Windows 7) le programme est accessible dans 'Document/Visual Studio/Projects/Database/Database (Database étant le nom du programme). (En effet sous Windows 7 'Documents ans Settings' n'est pas accessible !! il faut passer par le répertoire 'Document' de l'utilisateur en cours.

MonProjet.sln est le fichier solution.(Pas de solution en VB express, que des projets.)

MonProjet.psess est le fichier de performance (pas toujours présent).

MonProjet.suo est le fichier de User solution.

Dessous existe un répertoire nommé aussi MonProjet qui contient:

MonProjet.vbProj le fichier de projet.

Form1.vb contient un formulaire et ses procédures.

MyClasse.vb contient par exemple des classes.

Form1.Designer.vb contient le code qui crée la fenêtre et les contrôles.

Il a encore les sous-répertoires \Bin, il y a aussi un répertoire \Obj et un répertoire \MyProjet

Si on compile le projet l'exécutable est dans un sous répertoire \Bin,

Propriétés du projet

Toutes les propriétés de l'application peuvent être modifiées dans le 'Projet Designer' (Propriétés du projet), pour l'atteindre, il faut double-cliquer sur 'My Project' dans l'explorateur de solutions :

Une autre manière d'ouvrir le 'Projet Designer' est de passer par les menus 'Projet' puis 'Propriétés de…'

On retrouve dans le projet designer :

Le nom de l'application, son icône, la fenêtre de démarrage, celle de fin. (Application)

Les Option Strict, Explicit compare et la nouvelle Option Infer. (Compiler).

Les références (dll liées au projet).

Les paramètres (valeurs liées à l'application).

Les ressources (texte, image, son) utilisées dans le programme.

La signature et la sécurité.

Les Extension My (nouveauté 2008).

Les paramètres relatifs à la publication (distribution et installation).

Plutôt que de travailler avec les Windows Forms (formulaire habituel utilisant GDI+), en VB 2008 on peut utiliser un mode graphique vectoriel extrêmement performant pour dessiner les formulaires et contrôles : pour cela on utilise les WFP (Windows Presentation Foundation).

Pour cela : menu 'Fichier', 'Nouveau', 'Projet'.

On choisit 'Application WPF', on se retrouve dans un nouvel environnement :

Les formulaires et contrôles sont différents de ceux des Windows Forms, ainsi que les propriétés des objets graphiques.

Il y a le 'designer' en haut qui permet de dessiner l'interface que verra l'utilisateur. Le designer génère un fichier XAML en bas qui décrit en XML l'interface.

Dans la version Express, on peut dessiner des interfaces simples, les interfaces extrêmement élaborées (dégradé de couleur, animation…) peuvent être écrites en code XAML ou en utilisant un programme extérieur payant (Expression Blend). Voir le chapitre sir les WPF.

Si on double-clique sur un bouton, par exemple, on se retrouve dans la procédure événement correspondante :

On se rend compte que les événements là aussi ne sont pas les mêmes que pour les WindowsForm.

Il y a aussi d'autres modifications comme dans les propriétés du projet :

Voir le chapitre sur les WPF.

Quand on tape du code, VB affiche, des aides.

Dès que je tape une lettre VB propose dans une liste des mots.

Exemple, je tape 'd', il affiche 'Dim', 'Dir'… de plus si je me mets sur un des mots, il ouvre une petite fenêtre d'explication sur le mot avec sa syntaxe.

VB permet de choisir dans une liste une des propriétés d'un objet.

Exemple : je tape le nom d'un label nommé label1 puis je tape un point, cela me donne la liste des propriétés du label.

Quand je pointe dans la liste un des membres (propriété ou méthode) un carré jaune affiche la définition de la fonction avec ses paramètres et une explication.

VB aide à retrouver les paramètres d'une fonction.

Si on tape le nom d'une fonction et '(', VB affiche les paramètres possibles dans un cadre.

En plus il affiche les différentes manières d'utiliser les paramètres (les différentes signatures), on peut les faire défiler avec les petites flèches du cadre jaune.

VB aide à compléter des mots.

Si je tape App puis sur le bouton 'A->', Vb affiche la liste des mots commençant par App

AppActivate

AppDomain

VB fournit des exemples de code.

Les Extraits (Snippets, bride, morceau de code) permettent d'insérer du code tout fait.

Dans le code d'une procédure, le clic droit de la souris ouvre un menu.

Cliquer sur 'Insérer un extrait' (Insert Snipper). Puis par menu successif vous obtiendrez le code que vous cherchez.

Vb propose des solutions pour corriger les erreurs de code.

Si je veux afficher une valeur numérique (avec option Strict=On), il y a erreur, VB me propose la correction :

Il existe une abondante documentation.

Sur le Net: Msdn Framework 3.5

(http://msdn.microsoft.com/fr-fr/library/aa139616.aspx)

Dans l'IDE, VB donne accès à l'aide sur un mot-clé. Si le curseur passe sur un mot-clé, un carré affiche la définition de la fonction. Si je clique sur un mot et que je tape F1 l'aide s'ouvre et un long texte donne toutes les explications. VB donne accès à l'aide sur les contrôles. Si le curseur est sur un contrôle et que je tape F1 l'aide s'ouvre pour donner accès à la description des différents membres de cet objet. Enfin il est toujours possible de rechercher des informations par le menu '?'

Erreur dans l'écriture du code.

S'il existe une erreur dans le code au cours de la conception, celle-ci est soulignée en bleu ondulé. Un carré donne la cause de l'erreur si le curseur passe sur la zone où se trouve l'erreur.

Ici la propriété 'Text' a été mal orthographiée.

Si je lance le programme en mode 'Run' et qu'il y a des erreurs, Vb me le signale et répertorie les erreurs dans la liste des tâches en bas. Vb propose des solutions pour corriger les erreurs de code. (Voir plus haut.)

Mode débogage (mode BREAK)

Une fois lancée l'exécution (F5), puis stoppée (par Ctrl +Alt +Pause ou sur un point d'arrêt), on peut

- voir la valeur d'une propriété d'un objet en le pointant avec la souris :

Il s'affiche un petit cadre donnant la valeur de la propriété d'un objet ;

- voir la valeur d'une variable, simplement en positionnant le curseur sur cette variable.

F8 permet l'exécution pas à pas (y compris des procédures appelées).

F10 permet le pas à pas (sans détailler les procédures appelées).

Maj+F11 exécute jusqu'à la fin de la procédure en cours.

En cliquant sur le bouton droit de la souris, on peut exécuter jusqu'au curseur (Run To Cursor), voir la définition, la déclaration de ce qui est sous le curseur (Atteindree la définition : Go To Definition)…

Il y a un chapitre sur le débogage pour apprendre à trouver les erreurs de code.

On peut grâce au menu 'Affichage' avoir accès à plein de choses :

Choisir l'icône 'Application Windows forms', puis donner un nom au projet, enfin valider sur 'OK'.

(Le chemin de l'emplacement du projet n'est pas modifiable ici, il est par défaut ' C:\Documents and Settings\Nom Utilisateur\Mes documents\Visual Studio 2010\ Projects\MonProjet')
C:/Utilisateurs/Philippe/Mes document/ Visual Studio 2010/Projet sous Windows 7
Avec l'explorateur : Documents=> Visual Studio 2010=>Projet.

On remarque qu'on aurait pu choisir 'Application WPF', on y reviendra.

IV-B-1-a. Fenêtre Projet▲

On constate que les diverses fenêtres (pour chaque Form du projet ou chaque module de code) sont accessibles par des onglets.
À droite en haut il y a la fenêtre 'Explorateur de solution' ou se trouve les divers éléments du projet.
À droite en bas il y a la fenêtre 'Propriétés' contenant les propriétés de l'objet pointé à droite.
(Si on est sur un bouton à droite, ce sont les propriétés du bouton qui sont à gauche).

Vous pouvez ancrer les fenêtres correspondant aux onglets aux extrémités de la fenêtre de l'IDE ou les déplacer n'importe où sur le Bureau (sur un second moniteur aussi).
Ci-dessus la fenêtre de Form2 est détachée de l'IDE (il suffit de cliquer déplacer l'onglet).

Quand on déplace une fenêtre de l'IDE, une 'croix' s'affiche, il suffit de déplacer le curseur dans un élément de la croix qui symbolise une position dans l'IDE (en haut en bas, à droite…) et de lâcher le bouton de la souris pour que la fenêtre se positionne en haut, en bas, à droite… dans l'IDE.

IV-B-1-b. Créer ou ajouter une fenêtre 'WinForm'▲

IV-B-1-c. Le concepteur (Designer)▲

IV-B-1-d. Les procédures▲

Elles contiennent le code en visual basic. On se souvient que pour chaque événement de chaque objet visuel il existe une procédure.

Dans l'explorateur de solution à droite, cliquer sur Form1.vb puis sur l'icône 'Afficher le code' (survoler les petites icônes, c'est la 4^e), cela donne accès aux procédures liées à Form1.

Il est aussi possible en double-cliquant dans le formulaire ou un contrôle de se retrouver directement dans le code de la procédure correspondant à cet objet.

Dans toute fenêtre de code ou de texte, vous pouvez effectuer rapidement un zoom avant ou arrière (agrandir ou réduire la taille des caractères) en appuyant sur la touche CTRL tout en déplaçant la roulette de défilement de la souris.

On peut 'taper' du code dans les procédures. Dès que vous tapez quelques caractères Vb ouvre des listes vous proposant la suite (voir aide).

La liste déroulante de gauche au-dessus de la procédure donne la liste des objets, celle de droite, les événements correspondants à cet objet.

Ici on voit la procédure Button1_Click liée au Button1 de la fenêtre de Design :

Il est possible de faire de la saisie ou de l'insertion multiple.
Pour cela il faut appuyer sur ALT puis sélectionner à la souris une colonne sur plusieurs lignes:
Si ensuite on tape du code , il apparait sur toutes les lignes :
Insertion de texte : sélectionnez plusieurs lignes puis tapez dans la sélection de zone pour insérer le nouveau texte dans chaque ligne sélectionnée.
Collage : collez le contenu d'une sélection de zone dans une autre.
Zones de longueur nulle : effectuez une sélection verticale de zéro caractère de largeur pour créer un point d'insertion multiligne où insérer du texte sur toutes les lignes en même temps.

Quand on clique sur une variable, cette variable est surlignée dans l'ensemble du code :
CTL+MAJ+Flèche haut ou Flèche bas permet de passer à la variable surlignée suivante ou précédente.

Renommer un nom : modification automatique

On nomme cela 'Refactoring': cliquer sur une variable, puis bouton droit, dans le menu cliquer sur 'Renommer'. Modifier le nom de la variable, valider. Dans toute la Classe la variable est renommée.

Si une ligne de code est trop longue, on peut ajouter un caractère de continuation de ligne "_" et passer à la ligne. En VB 2010, après certains mots il peut y avoir continuation de ligne implicite (plus besoin de _ après la virgule, après &, après une parenthèse ouvrante, après { ou = ou + ou Is…).

 

Sélectionnez

Public Function GetUsername(ByVal username As String,
                            ByVal delimiter As Char,
                            ByVal position As Integer) As String

    Return username.Split(delimiter)(position)
End Function

En vb 2010, si dans le code, on utilise une classe qui n'existe pas, vb souligne le nom de la classe et vous propose (en cliquant sur le bouton dessous) de créer une classe, une structure ou un Enum vide :

. Cliquez sur 'générer un nouveau type".

Il existe une 'Recherche rapide' très puissante accessible par le menu 'Édition'.

Il y a bien sur les habituels boutons 'Couper', 'Copier', 'Coller', mais aussi le bouton qui transforme les lignes sélectionnées en commentaire (ou l'inverse).

Le menu 'Édition' puis 'IntelliSense' donne accès aux aides à l'écriture

IV-B-1-e. Ajouter des contrôles au formulaire▲

Ajouter un bouton par exemple.

Passer sur Boite à outils (Toolbox) à gauche, les contrôles apparaissent tous ou classés par ordre alphabétique.

Cliquer sur 'Button' dans la boite à outils, cliquer dans la Form, déplacer le curseur sans lâcher le bouton, puis lâcher : un bouton apparait.

Modifier les propriétés d'un contrôle ou du formulaire

Quand un formulaire ou un contrôle est sélectionné dans la fenêtre Design, ses propriétés sont accessibles dans la fenêtre de 'Propriétés' (Properties) à droite en bas: ici ce sont les propriétés du contrôle 'Button1' qui sont visibles (Text, Location…) on peut modifier directement les valeurs.

En bas de la fenêtre propriétés, il y a une explication succincte de la propriété sélectionnée (si elle n'apparait pas, clic droit sur la propriété puis dans le menu 'Description').

Exemple

Si au niveau de la ligne 'Text' des propriétés du bouton, j'efface 'Button1' et que je tape 'OK', dans le designer, le texte écrit sur le bouton deviendra 'OK'.

En haut de cette fenêtre de propriété, il y a un bouton avec un éclair donnant accès aux événements de l'objet.

Le déplacement des contrôles

Plus de croix ni de petite flèche pour déplacer le contrôle ou ouvrir un menu. Pour déplacer le contrôle, appuyer bouton gauche dedans puis déplacer.

L'alignement automatique des contrôles

Si on modifie la taille ou l'emplacement d'un contrôle, VB signale par un trait bleu que le contrôle modifié et le contrôle voisin sont alignés :

Disposition des contrôles

Le menu 'Outils', 'Personnaliser' permet d'ajouter une barre de disposition :

Cela permet (comme avec le menu Format) d'aligner les contrôles sur la grille, d'aligner les côtés, la taille, les espacements, d'uniformiser les tailles, de centrer dans la fenêtre…

IV-B-1-f. Voir tous les composants d'un projet▲

Pour cela il faut utiliser la fenêtre Explorateur de solutions en haut à droite, elle permet de voir et d'avoir accès au contenu du projet (pour voir tous les fichiers, il faut cliquer sur le deuxième bouton en haut) :

MyProjet : double-cliquer dessus, vous ouvrirez la fenêtre 'propriétés du projet'.

Références qui contient les dll chargées. Pour atteindre les références, on peut aussi passer par le menu 'Projet' puis 'Propriétés' ou double-cliquer sur 'MyProjet' puis choisir l'onglet 'Références.

Form1.vb est un formulaire (une fenêtre). Les formulaires, modules de classe ou standard sont tous des '.vb' il suffit de double-cliquer dessus pour les ouvrir.

Si on ouvre la sous-liste de Form1.vb (en cliquant sur le petit triangle), on voit :

Form1.Designer.vb (qui montre le code qui crée le formulaire, on n'a pas à y toucher) ;

Form1.resx (le fichier de ressources).

Il suffit de cliquer sur la ligne Form1 dans l'explorateur de solution pour voir apparaitre la Form1 dans la fenêtre principale.

Si on clique sur un espace de noms dans la liste Références, cela montre l'arborescence des Classes.

IV-B-1-g. Tester son logiciel▲

La Liste d' erreurs, en bas indique les erreurs de syntaxe (erreurs et avertissements).

On peut tester le projet grâce à : lancer l'exécution avec le premier bouton (mode 'Run'), le second servant à arrêter totalement l'exécution: Retour au mode 'Design' (ou 'Conception').

Pour arrêter le programme temporairement en mode 'Debug' il faut un point d'arrêt ou faire Ctrl+Pause (ce qui ouvre une autre fenêtre !!).
En cliquant sur (visible lors de l'exécution) on peut aussi suspendre l'exécution.
Par contre on peut mettre un point d'arrêt quand le programme tourne en cliquant dans la marge grise avant le code.

Quand on est en arrêt temporaire en mode 'Debug', la ligne courante, celle qui va être effectuée, est en jaune :

Si on tape la touche F8 (exécution pas à pas), la ligne est traitée et la position courante passe à la ligne en dessous.
F5 relance l'exécution.

En mode Debug, on peut modifier une ligne et poursuivre le programme qui tiendra compte de la modification (sauf pour les déclarations). On parle d''Edit and continue'.

IV-B-1-h. Sauvegarde, Projet, chemin▲

IV-B-1-i. Propriétés du projet▲

Toutes les propriétés de l'application peuvent être modifiées dans le 'Projet Designer' (Propriétés du projet), pour l'atteindre, il faut double-cliquer sur 'My Project' dans l'explorateur de solution.

Une autre manière d'ouvrir le 'Projet Designer' est de passer par les menus 'Projet' puis 'Propriétés de…'

On retrouve dans le projet designer :

Le nom de l'application, son icône, la fenêtre de démarrage, celle de fin. (Application)

Les Option Strict, Explicit compare et Option Infer.(Onglet Compiler).

Les références (dll liées au projet).

Les paramètres (valeurs liées à l'application).

Les ressources (texte, image, son) utilisées dans le programme.

La signature et la sécurité.

Les Extension My (nouveauté 2008).

Les paramètres relatifs à la publication (distribution et installation).

IV-B-1-j. Autre▲

On peut mettre des commentaires précédés de '.

 

Sélectionnez

' Commentaire non exécutable
'TODO ne pas oublier de modifier …

Si le premier mot du commentaire est TODO, comme ci-dessus, ce commentaire sera affiché dans la liste des tâches :
(Menu Affichage, Autres fenêtres, Liste des tâches).

C'est bien pratique pour ne pas oublier des modifications à faire.

Plutôt que de travailler avec les Windows Forms (formulaire habituel utilisant GDI+), en VB 2008 on peut utiliser un mode graphique vectoriel extrêmement performant pour dessiner les formulaires et contrôles : pour cela on utilise les WFP (Windows Presentation Foundation).

Pour cela : menu 'Fichier', 'Nouveau', 'Projet'.

On choisit 'Application WPF', on se retrouve dans un nouvel environnement :

Les formulaires et contrôles sont différents de ceux des Windows Forms, ainsi que les propriétés des objets graphiques.

Il y a le 'designer' en haut qui permet de dessiner l'interface que verra l'utilisateur. Le designer génère un fichier XAML en bas qui décrit en XML l'interface.

Dans la version Express, on peut dessiner des interfaces simples, les interfaces extrêmement élaborée (dégradé de couleur, animation…) peuvent être écrites en code XAML ou en utilisant un programme extérieur payant (Expression Blend). Voir le chapitre sur les WPF.

Si on double-clique sur un bouton, par exemple, on se retrouve dans la procédure événement correspondante.

On se rend compte que les événements là aussi ne sont pas les mêmes que pour les WindowsForm.

Il y a aussi d'autres modifications comme dans les propriétés du projet : voir le chapitre sur les WPF.

Quand on tape du code dans une procédure, VB affiche, des aides : dès que je tape une lettre VB propose dans une liste des mots.

Exemple, je tape 'di', il affiche 'Dim', 'Dir'…, de plus si je me mets sur un des mots, il ouvre une petite fenêtre d'explication sur le mot avec sa syntaxe.

VB permet de choisir dans une liste une des propriétés d'un objet.

Exemple : je tape le nom d'un label nommé label1 puis je tape un point, cela me donne la liste des propriétés du label.
Quand on pointe une propriété, un rectangle donne une explication sur cette propriété.

VB aide à retrouver les paramètres d'une fonction.

Si on tape le nom d'une fonction et '(', VB affiche les paramètres possibles dans un cadre.

En plus il affiche les différentes manières d'utiliser les paramètres (les différentes signatures), on peut les faire défiler avec les petites flèches du cadre blanc.

VB aide à compléter des mots.

Si je tape 'App' Vb affiche la liste des mots commençant par App: Objet, variables…

Dans le code, cliquez avec le bouton droit ouvre un menu et donne accès à :

VB fournit des exemples de code.

Les Extraits (Snippets, bride, morceau de code) permettent d'insérer du code tout fait.

Dans le code d'une procédure, le clic droit de la souris ouvre un menu.

Cliquer sur 'Insérer un extrait' (Insert Snipper). Puis par menu successif vous obtiendrez le code que vous cherchez.

Il existe une abondante documentation:
http://msdn.microsoft.com/fr-fr/library/dd831853%28v=VS.100%29.aspx

Dans l'IDE, VB donne accès à l'aide sur un mot-clé. Si je clique sur un mot et que je tape F1 l'aide s'ouvre et un long texte donne toutes les explications.
VB donne accès à l'aide sur les contrôles. Si le curseur est sur un contrôle et que je tape F1 l'aide s'ouvre pour donner accès à la description des différents membres de cet objet.
Enfin il est toujours possible de rechercher des informations par le menu '?'.

Si le curseur passe sur un mot-clé, un carré affiche la définition de la fonction, le type de la variable, sa déclaration.

Erreur dans l'écriture du code

Vb propose des solutions pour corriger les erreurs de code :

Si je fais une erreur Vb la souligne en ondulé bleu, si je mets le curseur dessus il m'explique l'erreur :

S'il y a un soulignement rouge, mettre le curseur dessus affiche un bouton avec un point d'exclamation qui ouvre une fenêtre donnant la correction de l'erreur :

Si je lance le programme en mode 'Run' et qu'il y a des erreurs, Vb me le signale et répertorie les erreurs dans la liste des tâches en bas.

Mode débogage (mode BREAK)

Une fois lancée l'exécution (F5), puis stoppée (par Ctrl +Pause ou sur un point d'arrêt), ou en cliquant sur on peut :

voir la valeur d'une propriété d'un objet, d'une variable en le pointant avec la souris :

Il s'affiche un petit cadre donnant la valeur de la propriété d'un objet.
Si on clique sur la punaise, l'affichage de la variable et de sa valeur devient permanent et la valeur est mise à jour.

Quand on clique sur une variable, cette variable est surlignée dans l'ensemble du code :

F8 permet l'exécution pas à pas (y compris des procédures appelées).

MAJ F8 permet le pas à pas (sans détailler les procédures appelées).

CTRL+F8 exécute jusqu'au curseur.

Il y a un chapitre sur le débogage pour apprendre à trouver les erreurs de code.

SharpDevelop 3.2 (version stable)

Si ce n'est pas fait, télécharger et installer le FrameWork 3.5. (Impérativement en premier).

Télécharger et installer le SDK.

C'est le Kit de Développement Microsoft .NET Framework : SDK du Framework 3.5.

Télécharger et installez SharpDevelop 3.2 (le 14/4/2010).

Télécharger SharpDevelop 3.2 (gratuit)

L'installer en exécutant le fichier d'installation.

Le Framework, le SDK et #develop suffisent pour faire des programmes.
La version 3.2 permet de travailler en VB avec les winforms.

SharpDevelop 4 (version beta)

Si ce n'est pas fait, télécharger et installer le FrameWork 4. (Impérativement en premier.)

Télécharger et installer le SDK.

C'est le Kit de Développement Microsoft .NET Framework : SDK du Framework 4.

Télécharger et installez SharpDevelop 4 bêta (le 14/12/2010).

Télécharger SharpDevelop 4 (gratuit)

L'installer en exécutant le fichier d'installation.

Le Framework, le SDK et #develop suffisent pour faire des programmes.

La version 4 bêta permet aussi de travailler avec WPF. Au 27/12/2010 elle n'est pas finalisée : impossible de créer facilement une Sub événement.

Lien

Site SharpDevelop

Didacticiel en anglais pour les Windows Forms : http://community.sharpdevelop.net/blogs/mattward/articles/FeatureTour.aspx.

Lancer SharpDevelop

Au lancement de l'application, on peut :

• ouvrir une solution existante: Bouton 'Ouvrir une solution' (ou cliquer sur le nom d'un projet récent en haut) ;
• créer un nouveau projet (une nouvelle solution).

Si l'on veut rajouter des fichiers à notre projet faire :
'Fichier'-'Ouvrir'-'Fichier' et catégorie VB

Détaillons la création d'un nouveau projet.

Bouton 'Nouvelle solution' ou

Menu 'fichier'-'Nouveau'-'Solution'

Sélectionner la catégorie 'VBNET' et choisir le type d'application à créer. (Dans le cas d'une création d'un projet Visual Basic, il faudra choisir dans les 'Modèles' : Application Windows.) On remarque que #Develop permet aussi d'écrire du C#, du C++ du ILAsm un setup du Python, Ruby….
On peut utiliser les Windows Forms (version 3.2) ou WPF (version 4).

Puis il faut donner un nom au projet (il n'y a pas de nom par défaut), modifier si nécessaire le chemin de l'emplacement du projet qui est par défaut ' C:\Documents and Settings\NomUtilisateur\Mes documents\SharpDevelop Projects' (cocher si nécessaire 'Créer le répertoire source') enfin valider sur le bouton 'Créer'. Une fenêtre 'MainForm' apparait.

Si, comme dans notre exemple, on a tapé 'Prog2', #develop crée une 'solution' nommée 'SolutionProg2' (ensemble, groupe de projets) contenant un projet (Prog2) contenant un formulaire nommé 'MainForm'.

L'écran principal se présente ainsi :

Au centre, sont visibles les écrans du code et des formulaires ; on peut changer d'écran grâce aux onglets du haut. Ici on voit 'MainForm'.

À gauche, les onglets du bas donnent accès au projet en cours (les solutions, projets, formulaires, autres fichiers : ressources, assembly…) ou aux outils : Table ascii, Presse papier et surtout (si on a un formulaire au centre et non du code) aux objets (bouton, texteBox, ListBox…).

À droite, en bas, les classes et surtout la fenêtre de Propriétés (Name, Text…) de l'objet sélectionné au centre.

En bas les fenêtres de 'sortie' (affichage de la console) liste des 'erreurs' des 'tâches', définitions', 'Résultat des recherches'…

IV-C-2-a. Dans un nouveau projet, créer une fenêtre▲

Pour ajouter une fenêtre (un formulaire) ouvrir le gestionnaire de projet et solution (Onglets en bas à gauche), il donne le nom de la solution (solutionprog2) et du projet (prog2 ici). Cliquer avec le bouton droit sur prog2 puis dans les menus sur 'Ajouter', 'Nouveau fichier'. Cela ouvre la fenêtre 'Nouveau fichier'.

Dans la fenêtre qui s'ouvre, à gauche, choisir 'VB' puis 'Application Windows', à droite 'Formulaire', taper un nom de formulaire (Form1 par exemple) puis 'Créer', une fenêtre 'Form1' apparait. La première fenêtre qui s'ouvre automatiquement quand on crée un projet se nomme 'MainForm'.

La zone de travail se trouve au centre de l'écran : on voit les onglets MainForm, Form1.vb pour chaque formulaire (fenêtre)

En bas les onglets 'Source' et 'Design' permettent de passer de l'affichage du code('Source') à la conception de l'interface utilisateur ('Design') : affichage de la fenêtre et de ses contrôles permettant de dessiner l'interface.

IV-C-2-b. Ajouter des contrôles au formulaire▲

Ajoutons un bouton par exemple :

Cliquer sur l'onglet 'Outils' à gauche en bas , bouton 'Windows Forms', puis sur 'Button', cliquer dans la MainForm, déplacer le curseur sans lâcher le bouton, puis lâcher le bouton :

IV-C-2-c. Modifier les propriétés d'un contrôle ou du formulaire▲

Quand une feuille ou un contrôle est sélectionné dans la fenêtre Design, ses propriétés sont accessibles dans la fenêtre de propriétés à droite en bas. (Si elles ne sont pas visibles, cliquer sur l'onglet 'Propriétés' en bas.)

Ici ce sont les propriétés du contrôle 'Button1' (BackColor, Image, Texte…).

Un petit texte d'aide concernant la propriété en cours apparait en bas.

(On peut modifier les propriétés directement.)

IV-C-2-d. Voir les procédures▲

L'onglet 'Source' en bas donne accès aux procédures (au code) liées à Form1.

La combo déroulante de droite donne la liste des objets. Si on en choisit un, le pointeur va sur les procédures liées à cet objet.

Malheureusement, contrairement à Visual Studio, la combo de gauche ne contient que les formulaires et pas les objets. Par exemple, on aura MainForm, mais pas Label1… Du coup la recherche se fait directement dans la combo de droite et c'est forcément beaucoup moins clair dès qu'il y a beaucoup de contrôles sur un formulaire…

Il est possible en double-cliquant dans le formulaire ou sur un contrôle de se retrouver directement dans le code de la procédure correspondant à cet objet.

Si la procédure n'existe pas (ButtonClick par exemple),double-cliquez sur le bouton pour la créer.

Pour créer les autres procédures événements, utiliser le bouton qui est sur la fenêtre des propriétés à droite, il fait apparaitre la liste des événements, double-cliquant sur un événement cela permet d'ouvrir la fenêtre de code et de créer les procédures.

IV-C-2-e. Voir tous les composants d'un projet, les classes▲

Pour cela il faut utiliser La fenêtre Projet à gauche (Si elles ne sont pas visibles, cliquer sur l'onglet 'Propriétés' en bas), elles permettent de voir et d'avoir accès au contenu du projet.

Le gestionnaire de projet et solution donne le nom de la solution (solutionprog2) et du projet (prog2 ici). Cliquer sur les '+' pour développer : vous verrez apparaitre les formulaires, les modules… et :

Références qui contient les espaces de nom ;

Assembly : info nécessaire pour générer le projet…

Le menu 'Fichier', 'Afficher les diagrammes de Classe' permet de voir les Classes du projet sous forme de diagramme :

IV-C-2-f. Remarque relative aux fenêtres de l'IDE▲

Interface WPF est présente à partir de la version 4.

Faire 'Fichier', 'Nouveau projet' :

Choisir 'VB', 'WPF' à gauche puis 'Application WPF' à droite, donner un nom en bas.

On se trouve dans l'environnement wpf :

L'onglet 'Window1.xaml' permet de voir le 'Designer'.
Le menu 'Affichage', 'Outils' permet d'avoir la liste des contrôles à gauche: On peut prendre un contrôle, un bouton par exemple, et le déposer dans la fenêtre centrale.
Si on clique sur un contrôle, on voit à droite ses propriétés.

En bas du designer l'onglet 'Source' permet d'avoir accès au code Xaml décrivant l'interface. Ici on voit le code xaml correspondant au bouton :

En bas à gauche, on peut cliquer sur l'onglet 'Projet'.
S'affiche les composants du projet, donnant accès à 'Windows.xaml.vb' contenant le code 'behind' visual basic.

Raccourcis clavier :

Ctrl+Entrée : Aller à la définition;
Ctrl + H: Rechercher;
Ctrl + G: Aller à.
Voir http://wiki.sharpdevelop.net/KeyboardShortcuts.ashx.

On peut compiler le projet avec le premier bouton ci-dessous. Créer le projet avec le second. Lancer l'exécution avec le bouton flèche verte (débogueur actif), le point d'exclamation lance l'exécution sans débogage, le rond à droite (qui devient rouge pendant l'exécution) sert à terminer l'exécution.

La liste déroutante permet de choisir la configuration des fenêtres de l'IDE :

Défaut : c'est les fenêtres habituelles précédemment décrites ;

Débogage : ouvre les fenêtres: variables locales, points d'arrêt, modules chargés… ;

Texte simple: uniquement les fenêtres centrales ;

Éditer : ouvre la fenêtre Edit Layout.

La sauvegarde du projet se fait comme dans tous les logiciels en cliquant sur l'icône du paquet de disquettes.

Avant, en #develop 1 :

.prjx est le fichier de projet.

.cmbw est le fichier solution.

Avec Sharpdevelop 2 c'est comme en VB : les solutions sont maintenant des fichiers .sln

.vb sont tous les fichiers Visual Basic (Feuille module…)

Les sources sont par défaut dans ' C:\Documents and Settings\NomUtilisateur\Mes documents\SharpDevelop Projects'

Si on compile le projet l'exécutable est dans un sous-répertoire \Bin\Debug ou \Bin\Realese.

Si vous avez plusieurs versions du framework sur votre machine (version 1.0, version 1.1, voire version 2.0 bêta), il vous est possible de choisir le compilateur dans les options du projet.

Visual Studio 2003 à version 1.1 du framework.

Visual Studio 2005 à version 2.0 du framework.

Menu 'Projet', 'Option du projet' permet l'accès aux propriétés du projet en cours.

Le quatrième onglet (Compiler) est le plus intéressant :

On peut :

compiler le programme en mode 'Debug' ou 'Release' ;

forcer le programmeur à travailler en Option Strict= On (empêcher les conversions automatiques) ;

Option Explicit=On (Forcer la déclaration des variables) ;

Choisir le Framework avec lequel on travaille (1 ou 2, pas le trois encore) ;

…

Dans l'onglet Import, on peut importer des espaces de noms.

La fenêtre d'aide à droite donne accès à des aides :

de #develop en anglais, non à jour !! ;

du Framework ;

de zipLib.

Si vous avez installé le SDK (SDK Framework .Net et/ou SDK Direct X), vous avez accès à l'aide (partie en haut à droite de l'écran), et donc également à l'intellisense, qui affiche les propriétés, les méthodes des objets, les paramètres des fonctions, des types… des différents objets.

Ici par exemple on a tapé MessageBox. , la liste des membres (Equals, Show…) est affichée.

Si on fait une faute dans le code, elle est détectée lorsque l'on lance l'exécution.

Ici on a tapé 'Texte' à la place de 'Text'.

La ligne en cause est soulignée en rouge et la fenêtre des erreurs située en bas s'ouvre, elle indique et décrit l'erreur :

L'aide dynamique à droite propose des liens en rapport avec le contexte.

S'il y a une erreur d'exécution (division par zéro par exemple), l'exécution s'arrête et la fenêtre d'exception s'ouvre :

On peut choisir d'arrêter le programme, de continuer, d'ignorer.

Le débogueur est maintenant intégré dans la version 2.

Une fois l'exécution lancée, on peut :

suspendre l'exécution par ALT+CTRL+B , reprendre par F6

Ajouter des points d'arrêt

Grâce à des points d'arrêt (pour définir un point d'arrêt en mode de conception, cliquez en face d'une ligne dans la marge grise, cela fait apparaitre un rond et une ligne rouge. Quand le code est exécuté, il s'arrête sur cette ligne).

(Recliquer sur le rond pour l'enlever).

Ajouter des marques pages

On peut ajouter des marques pages, en cliquant (quand on est sur la ligne à marquer) sur le petit carré bleu de la barre d'outils :

Ensuite, on peut se déplacer de marque en marque avec les 2 boutons qui suivent.

En mode 'Run', si on clique sur l'onglet 'Points d'arrêt' à droite, on voit la liste des points d'arrêt et des marques, on peut rendre inactif tous les points d'arrêt (3e bouton) ou un seul en le décochant dans la liste.

Voir la valeur d'une variable, simplement en positionnant le curseur sur cette variable.

En plus en mode Run, la fenêtre 'Variables locales' située en bas affiche la valeur de toutes les variables de la procédure. (Y compris 'e' et 'sender' qui sont les paramètres de la Sub.)

Enfin à droite on peut voir les modules chargés et les threads.

Exécution pas à pas

F11 permet l'exécution pas à pas (y compris des procédures appelées).

F10 permet le pas à pas (sans détailler les procédures appelées).

Maj+F11 exécute jusqu'à la fin de la procédure en cours.

On peut aussi utiliser les boutons :

Fonctions présentes dans #develop 1, mais pour l'instant absente dans #develop 2: C++ NProf Wix NAnt, générateur de MessageBox.

Créer un installateur (en anglais).

Programme permettant de faire du VB.net gratuitement (rapport qualité/prix infiniment élevé).

CONCLUSION D'UN UTILISATEUR

SharpDevelop est un IDE agréable à utiliser, pour le développement des programmes .NET, en mode WYSIWYG.

Il est possible d'atteindre un niveau de qualité équivalent à Visual Studio ou à Borland C# Builder en faisant une installation complète. Très ouvert, on peut lui rajouter des plugins. Certains programmes externes peuvent être utilisés également avec Visual Studio ou Borland C# Builder.

SharpDevelop est en perpétuelle évolution.

Un forum permet de déposer le descriptif des erreurs rencontrées, mais également de vos demandes de modifications, si vous pensez à une évolution qu'il serait bien que SharpDevelop possède. En plus vous pouvez récupérer le code source et pouvez donc modifier à loisir l'IDE.

Bien sûr, pour les débutants, il manque les assistants de Visual Studio (Crystal report, ADO .NET…). Le problème avec les assistants est qu'une fois qu'on pratique un peu, ils deviennent vite une gêne, et souvent, il faut repasser derrière eux, pour enlever le superflu de code qu'ils ont écrit (souvent ils n'optimisent pas le code).

Il manque également la partie UML de Visual Studio Architecte, mais là on attaque le haut du panier des développeurs.

Par contre, SharpDevelop apporte en plus :

• aide à la génération automatique des MessageBox ;
• aide à la conversion C# vers VB.NET et de VB.NET vers C# ;
• aide à la génération d'expression régulière.

Il fournit les logiciels :

• NDoc : permet de faire des fichiers d'aide compilée au format MSDN, à partir de lignes commentées dans le code ;
• NUnits : permet de faire des tests unitaires (!) ;
• SharpQuery : permet de se connecter aux bases de données .

Comment créer facilement un installateur (SetUp) avec #develop ? Certains utilisateurs utilisent Inno Setup, d'autres Excelcior delivery.

Comment utiliser NDoc NUnits ?

Comment utiliser simplement des ressources ?

Comment utiliser des bases de données ?

Qui utilise le menu 'Outils' et ses différentes options ?

Merci à Fabrice SAGE pour son aide.

Merci à Hubert WENNEKES, CNRS Institut de Biologie de Lille pour son aide.

Remarque pour les forts

On peut s'étonner qu'il n'y ait pas Handles Button1.Click à la fin de la ligne suivante (comme dans VB 2005) :

Sub Button1Click(ByVal sender As Object, ByVal e As EventArgs)

End Sub

En fait si on va voir dans InitializeComponent, il y a un AddHandler après la description du bouton.

Private Sub InitializeComponent()

….

AddHandler Me.button1.Click, AddressOf Me.Button1Click

Le Framework (un framework est un ensemble de classes) en est à sa version 4 en VB 2010.

Les classes du Framework permettront de créer des objets de toutes sortes: objet 'chaine de caractères', objet 'image', objet 'fichier'… On travaille sur ses objets en utilisant leurs propriétés, leurs méthodes.

Il existe des milliers de classes: les plus utilisées sont les classes 'String' (permettant de travailler sur des chaines de caractères), Math (permettant d'utiliser des fonctions mathématiques), Forms (permettant l'usage de formulaires, de fenêtres et donnant accès aux contrôles: boutons, cases à cocher, listes…).

Elles sont communes à tous les langages utilisant le FrameWork (VB, C#, C… ).

Ces classes ont de multiples méthodes (rappel de la syntaxe: Classe.Methode).

Exemple d'utilisation de la Class TextBox (contrôle contenant du texte) et de sa méthode Text :

TextBox1.Text="Hello"

'Affiche "Hello" dans le Textbox.

Parfois la Classe n'est pas chargée par défaut au démarrage de VB, il faut dans ce cas 'l'importer' en haut du module (au-dessus de Public Class…). Si par exemple, je veux utiliser Sin() de la classe Math, il faut écrire en haut du module :

Imports System.Math
Public Class Form1

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        'Je peux utiliser Sin
        Console.WriteLine(Sin(1).ToString)

End Sub
End Class

Si on n'a pas importé Math, on peut quand même utiliser Sin en tapant Math.Sin().

Vb permet d'utiliser des instructions Visual Basic; seul VB peut les utiliser et de lui seul (pas C#).

Il s'agit d'instructions, de mots-clés qui ont une syntaxe similaire au basic, mais qui sont du VB.Net.

Exemple :

A = Mid(MaString, 1, 3)

'Mid retourne une partie de la chaine de caractères.

Il y a aussi les Classes de compatibilité VB6. Elles ne dépayseront pas ceux qui viennent des versions antérieures de VB, car elles reprennent la syntaxe utilisée dans VB6 et émulent les fonctions VB6 qui ont disparu de VB.Net. Ce sont des fonctions VB6 qu'on ajoute à VB.net par souci de compatibilité, mais ce n'est pas du VB.Net. Il faut les oublier !

L'outil d'import automatique de VB6 vers VB.Net en met beaucoup dans le code. Il faut à mon avis éviter de les utiliser, car ce n'est pas vraiment du VB. Ce cours 'pur' VB.Net n'en contient pas.

Pour le moment cela peut paraitre un peu compliqué, mais ne vous inquiétez pas, cela va devenir clair.

Dans l'étude du langage VB, on s'occupe du code, on ne s'occupe pas de l'interface (les fenêtres, les boutons, l'affichage du texte…), mais parfois, on a besoin, pour faire fonctionner des exemples de code, de saisir des valeurs, de les afficher :

• Saisir une valeur, pour cela on utilise une InputBox, c'est une boite qui s'ouvre, l'utilisateur y tape un texte puis il clique sur 'OK' ; on retrouve ce qu'il a tapé dans la variable Réponse.

Réponse= InputBox()

• Afficher des résultats, pour le moment on affichera du texte de la manière suivante :

dans une fenêtre, dans des TextBox :

TextBox1.Text="TextBox1"

ou un label :

Label1.Text="Résultat"

sur la console :

Console.WriteLine ("Résultat")

ou

dans une Boite de message :

MsgBox("Bonjour")

'ou
MessageBox.Show ("Bonjour")

Pour écrire un programme, aller du problème à résoudre à un programme exécutable, il faut passer par les phases suivantes :

• Analyse du cahier des charges
  Il doit être clair, exhaustif, structuré.
• Analyse générale du problème
  Il existe des méthodes pour professionnels (MERISE, JACKSON…), nous utiliserons plutôt l'analyse procédurale: le problème global est découpé en sous-problèmes nommés fonctions. Chaque fonction ne contient plus qu'une partie du problème. Si une fonction est encore trop complexe, on itère le processus par de nouvelles fonctions à un niveau plus bas.
  Cela s'appelle la 'Conception structurée descendante'. La 'Conception ascendante' existe aussi: en assemblant des fonctions préexistantes, on résout le problème: attention, il faut que les fonctions préexistantes soient cohérentes. (Pour le moment on ne fait pas de programmation objet).
• Analyse détaillée
  Chaque fonction est mise en forme, la logique de la fonction est écrite dans un pseudo langage (ou pseudocode) détaillant le fonctionnement de la fonction. Ce pseudocode est universel, il comporte des mots du langage courant ainsi que des mots relatifs aux structures de contrôle retrouvées dans tous les langages de programmation.
• Codage
  Traduction du pseudocode dans le langage que vous utilisez.
• Test
  Car il faut que le programme soit valide.

Exemple simpliste

• Analyse du cahier des charges.
  Création d'un programme affichant les tables de multiplication, d'addition, de soustraction.
• Analyse générale du problème.
  Découpons le programme en diverses fonctions:
  Il faut créer une fonction 'Choix de l'opération', une fonction 'Choix de la table', une fonction 'TabledeMultiplication', une fonction 'TabledAddition', une fonction 'Affiche'…

• Analyse détaillée.
  Détaillons la fonction 'TabledeMultiplication'
  Elle devra traiter successivement (pour la table des 7 par exemple)
  1X7
  2X7
  3X7…
  
  Voici l'algorithme en pseudocode.

   

  Sélectionnez

  Début
  
      Pour i allant de 1 à 10
  
          Ecrire (i*7)
  
      Fin Pour
  
  Fin

  Exemple simpliste

• Codage.
  Traduction du pseudocode en Visual Basic, en respectant la syntaxe du VB.

   

  Sélectionnez

  Sub MultiplicationPar7
  
  Dim i As Integer
  
  For i=1 to 10
  
      Call Affiche(i*7)
  
  next i.
  
  End Sub

  Exemple simpliste

• Test
  Ici il suffit de lancer le programme pour voir s'il marche bien…

Pour des programmes complexes, il existe d'autres méthodes.

Un problème est traitable par informatique si :

• on peut parfaitement définir les données (entrées) et les résultats (sorties) ;
• on peut décomposer le passage de ces données vers ces résultats en une suite d'opérations élémentaires exécutables.

L'algorithme est une succession de tests, décisions et actions dans le but de décrire le comportement d'une entité (objet, programme, personne). Définition du Dicodunet.

On écrit bien 'algorithme' et non 'algorythme'.Le mot "algorithme" vient du nom du mathématicien arabe Al Khuwarizmi (latinisé au Moyen Âge en Algoritmi).

Pour représenter l'algorithme et ses opérations, on utilisait les organigrammes (dessins avec des cases et des flèches qui ne permettaient de visualiser que des problèmes très simples); maintenant on utilise du pseudocode (composé d'instructions généralistes).

La mise en œuvre de l'algorithme consiste en l'écriture de ces opérations dans un langage de programmation (le Visual Basic pour nous).
On utilise l'anglicisme implémentation pour désigner cette mise en œuvre.

Étudions cette logique valable pour tous les langages de programmation (ceux qui sont des langages impératifs).

Pour représenter n'importe quel algorithme, il faut disposer des trois possibilités suivantes :

• la séquence qui indique que les opérations doivent être exécutées les unes après les autres.

  

  Pour représenter n'importe quel algorithme, il faut disposer des trois possibilités suivantes :

• le choix qui indique quelles instructions doivent être exécutées en fonction de circonstances.

  

  Pour représenter n'importe quel algorithme, il faut disposer des trois possibilités suivantes :

• la répétition qui indique que des instructions doivent être exécutées plusieurs fois.

Pour représenter n'importe quel algorithme, il faut disposer des trois possibilités suivantes :

Pour i allant de 1 à 10
        Ecrire (i*7)
Fin Pour

Voyons cela en détail.

Le langage algorithmique et son pseudocode ne sont pas vraiment standardisés, chacun écrit le pseudocode à sa manière, aussi vous verrez des notations différentes dans les divers cours d'algorithme. Cela n'a pas d'importance, car un programme en pseudocode ne sera jamais exécuté sur une machine.

L'intérêt d'étude des algorithmes est didactique: elle permet de comprendre la logique d'un programme totalement indépendamment du langage: ce qui suit est valable en C++, Delphi, Java, Visual Basic, Assembleur… Comme on est dans un cours de VisualBasic, je donnerais pour chaque notion le pseudocode, mais aussi l'équivalent en Visual Basic.

Il y a les structures de données (dans quoi sont stockées les données?) dans des :
-Constantes ;
-Variables ;
-Tableaux ;
-Collections ;
-Listes, Graphe, Arbre…
Il y a les structures de contrôles (Comment fonctionne le code ?) :
-Séquence ;
-Condition ;
-Boucle.

V-B-3-a. Séquences▲

Au sein d'un programme, la structure est généralement séquentielle.

On fait de la programmation impérative, on travaille sur le modèle de la machine de Turing, avec une mémoire centrale et des instructions qui modifient son état grâce à des assignations successives.

Le code est fait d'une succession de lignes (ou instructions) qui seront lues et traitées les unes après les autres.

Instruction 1

Instruction 2

Instruction 3

…

Quand le programme s'exécute, il le fait de haut en bas, Instruction 1 sera exécuté puis instruction 2 puis instruction 3…

En VB on peut mettre plusieurs instructions sur la même ligne, séparées par ":"

Instruction1 : Instruction2

V-B-3-b. Variables, 'Type' de variable▲

V-B-3-c. Constantes▲

V-B-3-d. Affectation (ou Assignation)▲

    Z=X+1

V-B-3-e. Booléens▲

V-B-3-f. Choix : Si…Alors▲

Le programme doit pouvoir choisir parmi deux ou plusieurs possibilités en fonction d'une condition :

 

Sélectionnez

Si Condition Alors

      Action 1

Sinon

      Action 2

Fin Si

Si Condition est vraie Action 1 est effectuée, sinon Action 2 est effectuée.

Parfois il n'y a pas de seconde branche :

 

Sélectionnez

Si Condition Alors

      Action 1

Fin Si

ou sur une seule ligne :

 

Sélectionnez

    Si Condition Alors Action 1

Il peut y avoir plusieurs conditions imbriquées :

 

Sélectionnez

Si Condition 1 Alors
    Si Condition 2 Alors

            Action 1

    Sinon

            Action 2

    Fin Si

Sinon

      Action 3

Fin Si

Noter bien le retrait des lignes de la seconde condition afin de bien visualiser la logique du programme :

Action 2 est effectuée si la Condition 1 est remplie et la Condition 2 n'est pas remplie.

En VB cela correspond à l'instruction IF THEN

 

Sélectionnez

If Condition 1 Then

      Action 1

Else

      Action 2

End If

Remarque sur les conditions

Une condition contient deux valeurs et un opérateur :

Si C>2 Alors est correcte.

Si B=3 Alors est correcte.

Si 2<B<7 Alors est incorrecte, car il y a deux opérateurs, il faut dans ce cas utiliser plusieurs conditions et des opérateurs logiques.

Si B>2 Et B<7 Alors est correcte (If B>2 And B<7 Then en Visual Basic).

La condition est évaluée.

Exemple : soit l'expression Si C>2 Alors , elle sera évaluée, si C contient 3, C>2 est vérifié donc Vrai.

Exemple : trouver le plus grand nombre entre x et y et le mettre dans max

 

Sélectionnez

Variable x en Numerique

Variable y en Numerique

Variable max en Numerique

Si x>y Alors

    max<-x

Sinon

    Max<-y

Fin Si

En VB

 

Sélectionnez

Dim x As Integer

Dim y As Integer

DIm max As Integer

if x>y Then

    max=x

Else

    max=y

End if

V-B-3-g. Choix : Décider entre▲

Il est parfois nécessaire d'effectuer un choix parmi plusieurs solutions :

 

Sélectionnez

Décider Entre
      Quand Condition 1 Alors

            Action 1

      FinQuand
 

      Quand Condition 2 Alors

            Action 2

      FinQuand

      …

      …

      Autrement

            Action 4

      FinAutrement

FinDécider

Si la condition 1 est remplie, Action 1 est effectuée puis le programme saute après FinDécider.

Si la condition 1 n'est pas remplie, on teste la condition 2…

Si aucune condition n'est remplie, on saute à Autrement, on effectue Action 4.

On pourrait aussi parler de sélection :

 

Sélectionnez

Sélectionner.

      Le cas : condition 1

            Action 1

      Le cas : condition 2

            Action 2

      …

      Les autres cas

FinSélectionner

En VB cela correspond à

 

Sélectionnez

Select Case Valeur

      Case condition 1

            Action 1

      Case condition 2

            Action 2

      …

      Case Else

            Action 4

End Select

Si Valeur=Condition 1 Action 1 est effectuée,si Valeur=Condition 2 Action 2 est effectuée…

V-B-3-h. Répétitions : Pour…Répéter▲

Permet de répéter une séquence un nombre de fois déterminé :

Le cas le plus classique est :

 

Sélectionnez

Pour I variant de 0 à N Répéter

      Action

FinRépéter

I prend la valeur 0, 'Action' est effectuée,

puis I prend la valeur 1, Action est effectuée,

puis I prend la valeur 2…

cela jusqu'à N.

La boucle tourne N+1 fois (car ici on commence à 0 ).

Cela se nomme une itération.

Intérêts ?

Au lieu de faire :

Afficher (1*7)

Afficher (2*7)

Afficher (3*7)

Afficher (4*7)

…

on remarque qu'un élément prend successivement la valeur 1, 2, 3…

Une boucle peut faire l'itération :

 

Sélectionnez

Pour i allant de 1 à 10 Répéter

    Affiche (i*7)

Fin répéter

La variable dite 'de boucle' prend bien les valeurs 1 puis 2 puis 3… ; elle est utilisée dans le corps de la boucle.

Une instruction Sortir permet de sortir prématurément de la boucle.

En VB

 

Sélectionnez

For i=0 To N

      …

Next i

L'instruction Exit For permet de sortir prématurément de la boucle.

On peut aussi boucler en parcourant tous les éléments d'une collection.

(Une collection est une liste d'objets, liste de taille variable en fonction de ce qu'on ajoute ou enlève.)

 

Sélectionnez

Pour Chaque élément de la liste

      Action

Fin Pour

En VB :

 

Sélectionnez

For Each élément In list

 

Next

V-B-3-i. Répétitions : Tant que▲

Permet de faire une boucle sans connaitre le nombre d'itérations à l'avance.

 

Sélectionnez

Tant Que Condition

      Action

Fin Tant Que

L'action qui est dans la boucle doit modifier la condition afin qu'à un moment 'Tant que' ne soit pas vérifié et que l'on sorte de la boucle. Sinon la boucle tourne sans fin.

Pour plus cadrer avec la réalité :

 

Sélectionnez

Faire tant que condition

      Action

Boucler

En VB :

 

Sélectionnez

Do while Condition

      Action

Loop

Il existe une boucle équivalente :

 

Sélectionnez

Répéter

      Action

Jusqu'à Condition

 

En VB :

Do

      Action

Loop Until Condition

Une instruction Exit Do permet de sortir prématurément de la boucle.

V-B-3-j. Logique : Et, Ou, Non▲

V-B-3-k. Les Sauts▲

Variable A en Numérique

Variable B en Numérique

Variable C en Numérique

B<-12

A<-B  

Aller à Poursuivre

C=11

Étiquette Poursuivre

A<-A+1

MonEtiquette:

GoTo monetiquette

V-B-3-l. Programmation structurée▲

Variable A en Numérique
Variable B en Numérique
Variable C en Numérique

B<-12
A<-B  

Si A=B Aller à Poursuivre1
  C<-1
Étiquette Poursuivre1

Si A<>B Aller à Poursuivre2

C<-2

Étiquette Poursuivre2

Variable A en Numérique
Variable B en Numérique
Variable C en Numérique

B<-12
A<-B  

Si A=B Alors
    C<-1
Sinon
    C<-2
Fin Si

V-B-3-m. 'Sous-programme' ou 'procédure'▲

On a déjà vu cette notion.

Quand on appelle une procédure, le logiciel 'saute' à la procédure, il effectue celle-ci puis revient effectuer ce qui suit l'appel.

Dans un algorithme, une procédure commence par le mot Proc et se termine par End Proc.

Le programme effectuera les instructions 1, 2, 3, 10, 11, 4, 5.

Une opération complexe peut être découpée en plusieurs procédures ou sous-programmes plus petits et plus simples qui seront appelés. Chaque procédure résout un problème.

Et VB les sous-programmes (ou procédures) sont des Sub ou des Function. Pour appeler une procédure, on utilise Call NomProcedure() ou NomProcedure()

On peut fournir aux procédures des paramètres, ce sont des variables qui seront transmises à la procédure.

Exemple

Création d'une Procédure 'MaProcédure' recevant deux paramètres :

 

Sélectionnez

Sub MaProcédure(paramètre1, paramètre2)

…

End Sub

Exemple d'appel de la procédure 'Maprocédure' en envoyant deux paramètres :

Call MaProcédure(premierparamètre, secondparamètre)

Exemple : si j'écris Call MaProcédure(2,3)

dans la procédure MaProcédure paramètre1=2 et paramètre2=3.

Il est nécessaire de définir le type des paramètres :

Sub MaProcédure(paramètre1 As Integer, paramètre2 As Integer) indique que la procédure attend deux entiers.

Il y a deux manières d'envoyer des paramètres :

- Par valeur : (By Val)c'est la valeur, le contenu de la variable qui est envoyé.

- Par référence : (By Ref) c'est l'adresse (le lieu physique où se trouve la variable) qui est envoyée. Si la Sub modifie la variable, cette modification sera visible dans la procédure appelante après le retour.

Parfois on a besoin que la procédure appelée retourne une valeur, dans ce cas il faut créer une fonction :

 

Sélectionnez

Function MaFonction()  As Integer    'MaFonction qui retourne un entier

…

    Return Valeur

End Function

Pour appeler la fonction :

ValeurRetournée=MaFonction()

Donc ValeurRetournée est aussi un entier.

Exemple de fonction: créer une fonction qui retourne le plus petit nombre :

 

Sélectionnez

Fonction Minimum (x en Numerique, y en Numérique) en numérique
Si x<y Alors

    Retourner x

Sinon

    Retourner y

Fin Si

Fin Fonction

Pour l'utiliser :

 

Sélectionnez

Variable Min en Numerique

Min<-Minimum (5,7) 'Appelle la fonction en donnant les 2 paramètres 5 et 7.

Min contient maintenant 5

En Vb

 

Sélectionnez

Function Minimum(x As Integer, y As Integer) As Integer

    If x<y Then

        Return x

    Else

        Return y

    End If

End Function

Pour l'utiliser :

 

Sélectionnez

Dim Min As Integer

Min= Minimum (5,7)

La fonction résout un problème et plus précisément à partir de données, calcule et fournit un résultat.

V-B-3-n. Tableaux▲

A[2] <- 4

x <- A[2]

Dim  A(4) As Integer 'on déclare le tableau
A(2)=4

x = A(2)

début
          Pour i allant de 0 à n-1 Répéter
              écrire(tab[i])
          Fin Répéter
fin

       For i=0 to n-1

            Affiche ( tab(i))    'routine d'affichage

       Next i

V-B-3-o. Collection▲

Col.Ajouter("Lulu")

Col.Ajouter("Titi")

Col.Add    'Ajoute un élément

Col.Remove 'Enlève un élément

V-B-3-p. Pile et Queue▲

Une Pile (ou stack) est une collection de type LIFO (Last In, First Out). Dernier entré, premier sorti.

Ce type de stack (pile) est très utilisé en interne par les programmes informatiques : on stocke dans une stack les adresses de retour des procédures appelées, au retour on récupère l'adresse du dessus.

Push insère un objet en haut de la pile.

Pop enlève et retourne un objet en haut de la pile.

On peut utiliser une pile dans un programme pour gérer le déplacement de l'utilisateur dans un arbre, les éléments en cours sont stockés par Push, pour remonter en chemin inverse, on Pop.

Une 'Queue' est une collection de type FIFO (First In, First Out). Premier arrivé premier servi.

C'est la queue devant un cinéma, le premier arrivé, prend son billet le premier.

Les éléments stockés dans Queue sont insérés à une extrémité; les éléments extraits le sont à l'autre extrémité.

Le nombre d'éléments de la queue est géré automatiquement.

Généralement on a les possibilités suivantes :

DeQueue supprime et retourne l'objet de début de liste

EnQueue ajoute un objet en fin de liste

Peek retourne l'objet de début sans le supprimer

V-B-3-q. Liste chainée▲

Une liste chainée est une liste d'éléments non classée. Dans chaque enregistrement il y a, outre le contenu de l'enregistrement, la localisation, l'adresse, l'index de l'enregistrement précédent et de l'enregistrement suivant.

Ainsi on peut parcourir la liste en allant d'enregistrement en enregistrement. Il existe des algorithmes pour ajouter ou supprimer un enregistrement. La liste peut être ouverte ou fermée (le dernier enregistrement bouclant sur le premier).

V-B-3-r. Notion de Clé▲

Quand on classe une série importante de données, on peut utiliser la notion de clé/Valeur (Key/Value).

Ici on utilise comme clé le numéro du département et comme valeur, le nom du département.

Si on a la clé, on peut retrouver la valeur correspondante.

Autre exemple: La clé peut être le nom, prénom.

V-B-3-s. Notion de Hachage▲

Une fonction de hachage est une fonction qui fait subir une succession de traitements à une donnée fournie en entrée pour en produire une empreinte servant à identifier la donnée initiale.

Donnée d'entrée=> Fonction de hachage => Empreinte.

Le résultat d'une fonction de hachage peut être appelé selon le contexte empreinte, somme de contrôle (dans le cas de la CRC), résumé, condensé, condensat ou encore empreinte cryptographique (dans le cadre de la cryptographique). On l'appelait aussi autrefois aussi signature.

Les fonctions de hachage sont utiles en cryptographie où elles sont utilisées pour chiffrer une donnée initiale.

Mot de passe: "GftUi6h77"=> Fonction de hachage => Empreinte : "4587213399545684246847"

C'est l'empreinte qui va être enregistrée. Quand l'utilisateur rentre le mot de passe, on le 'hache" et on compare l'empreinte du mot de passe tapé par l'utilisateur avec l'empreinte enregistrée pour voir si le mot tapé est bon. Ainsi à aucun moment le mot de passe est en clair.

Ces fonctions de hachage sont aussi très utilisées pour accéder rapidement à une donnée contenue dans un grand nombre de données.

Ceci grâce aux tables de hachage (ou hash tables en anglais).

Un exemple classique et simpliste de fonction de hachage est la fonction modulo n : Si on dispose d'un grand nombre de données, à mettre dans un tableau de n cases, on pourra ranger l'élément numéro i dans la case i modulo n. Ainsi, pour aller chercher notre donnée, nous n'avons plus besoin de parcourir tous les éléments jusqu'à trouver l'élément i : Il suffit de parcourir les éléments contenus dans la case i modulo n. Si les données initiales étaient réparties uniformément, le temps de recherche en moyenne est divisé par n. En pratique, on utilise des fonctions de hachage bien plus complexes.

Le hachage est un nombre qui permet la localisation des éléments dans une table.

Exemple

Nous avons une série de noms et adresses, nous voulons rapidement trouver l'adresse correspondant à un nom sans avoir à faire une boucle qui compare le nom cherché avec chaque élément du tableau pour le trouver.

Pour chaque nom la fonction de hachage, va créer un numéro (empreinte).

On crée des enregistrements indexés par ledit numéro (empreinte), chaque enregistrement contenant l'adresse.

Si maintenant on cherche un nom, on calcule son empreinte, ce qui nous donne l'index de l'enregistrement que l'on trouve rapidement.

Si la fonction de hachage est uniforme, cela veut dire que pour des entrées différentes, il n'y a jamais la même empreinte. Ce qui est la plupart du temps impossible.

Deux noms peuvent donc donner la même empreinte parfois (on parle de collision). Dans ce cas, on range les enregistrements ayant la même empreinte les uns à la suite des autres (sous forme de liste chainée). Si le premier enregistrement n'est pas le bon, on regarde le suivant.

V-B-3-t. Arbre▲

Structure de données. Désigne une forme de diagramme qui modélise une hiérarchie.

Un arbre est constitué d'un ensemble de nœuds et de branches reliant les nœuds. On peut parler de feuilles pour les éléments, les objets qui sont en bout de branches.
Le premier nœud d'un arbre (celui sans branche entrante) se nomme la racine.
Un arbre est unidirectionnel et sans boucle.

Un exemple de données en 'arbre' : sur un disque dur, les répertoires, sous-répertoires et fichiers ont une structure en arbre.

V-B-3-u. Erreur d'exécution : Notion de 'Sécurisation' du code▲

Si Y <> 0 Alors
    Z= X/Y
Fin Si

V-B-3-v. Récursivité▲

Sub Calcul()

'…

    Calcul()

'…

End Sub

V-B-3-w. Flag et variables d'état▲

flagSortir=Faux 

Tant que  flagSortir =Faux

      Si on doit sortir de la boucle, on met la valeur de flagSortir à Vrai

Boucler

flagSortir=Faux 

Do while flagSortir =Vrai

     ' Si on doit sortir de la boucle, on met la valeur de flagSortir à Vrai

Loop

V-B-3-x. Compilation, interprétation▲

Pour trouver des réponses à un problème, on va choisir une grande stratégie et utiliser des structures élémentaires pour l'exécuter.

Algorithme direct ou explicite
Ici l'algorithme utilise la seule voie possible, évidente mathématiquement.
Exemple : pour calculer les racines d'une équation du second degré, l'algorithme calcule le déterminant puis en fonction de sa valeur (plusieurs cas), il calcule les racines.
Il est possible de découper un problème complexe en plusieurs problèmes plus simples.

Algorithme glouton
Un algorithme glouton suit le principe de faire, étape par étape, un choix optimum local, dans l'espoir d'obtenir un résultat optimum global.
Par exemple, dans le problème du rendu de monnaie (rendre une somme avec le moins possible de pièces), l'algorithme consiste à répéter le choix de la pièce de plus grande valeur qui ne dépasse pas la somme restante; c'est un algorithme glouton.
Nous faisons beaucoup d'algorithmes gloutons !

Diviser pour régner
Diviser pour régner est une technique algorithmique consistant à diviser un problème de grande taille en plusieurs sous-problèmes analogues.
Les algorithmes Diviser pour régner appliquent deux stratégies principales. La première est la récursivité sur les données: on sépare les données en deux parties, puis on résout les sous-problèmes (par la même fonction), pour enfin combiner les résultats. La seconde stratégie, la récursivité sur le résultat, consiste elle à effectuer un prétraitement pour bien découper les données, puis à résoudre les sous-problèmes, pour que les sous-résultats se combinent d'eux-mêmes à la fin.
Exemple : les algorithmes de tri (trier un tableau par exemple).

Recherche exhaustive
Cette méthode utilisant l'énorme puissance de calcul des ordinateurs consiste à regarder tous les cas possibles.
Exemple : rechercher une clé pour pénétrer dans un site (c'est mal !!): on teste à l'aide d'une boucle toutes les clés possibles, on parle de 'force brute'.

Algorithme aléatoire, approches successives
Certains algorithmes utilisent des recherches aléatoires, ou par approches successives donnant de meilleurs résultats que des recherches directes ou explicites. Exemple : ceux dits de Monte-Carlo et de Las Vegas.

Les heuristiques
Pour certains problèmes, les algorithmes ont une complexité beaucoup trop grande pour obtenir un résultat en temps raisonnable. On recherche donc une solution la plus proche possible d'une solution optimale en procédant par essais successifs. Certains choix stratégiques doivent être faits. Ces choix, généralement très dépendants du problème traité, constituent ce qu'on appelle une heuristique. Les programmes de jeu d'échecs, de jeu de go fonctionnent ainsi.

Les algorithmes les plus étudiés sont :
- Algorithmes simples :
…Inversion de variables,
…Recherche d'une valeur dans un tableau,
…Tri,
…Problème du voyageur de commerce ;
- Algorithmes utilisant la récursivité ;
- Algorithmes mathématiques ;
- Algorithmes informatiques complexes :
…Compression,
…Cryptage,
…Graphisme,
….

V-B-5-a. Recherche dans un tableau▲

Pour I variant de 0 à 3 Répéter

      …

FinRépéter

Pour I variant de 0 à 3 Répéter

      Si A(I)= 4 Alors…

FinRépéter

flagTrouvé<-Faux

Pour I variant de 0 à 3 Répéter

      Si A(I)= 4 Alors flagTrouvé<-Vrai

FinRépéter

flagTrouve=False

For I=0 To 4

    If A(I)=4 Then flagTrouve=True

Next I

V-B-5-b. Tri de tableau▲

Pour i allant de 0 à N-1

    Pour j allant de 0 à N-1

        Si T(j)>T(j+1) Alors 

            Temp<-T(j) 

            T(j)<-T(j+1)

            T(j+1)<-Temp

        Fin Si

    Fin Pour

 Fin Pour

Dim i, j , N  As Integer    'Variable de boucle i, j ; N= nombre d'éléments-1

Dim Temp  As String

N=4  'tableau de 5 éléments.

Dim T(N) As String  'élément de 0 à 4

For i=0 To N-1

    For j=0 To N-1

        If T(j)>T(j+1) then 

            Temp=T(j): T(j)=T(j+1):T(j+1)=Temp

        End if

    Next j

 Next i

If = Si.

Then= Alors

Step=Pas

Do (To)= faire

While= tant que

Until= Jusqu'à ce que.

Loop= boucle

On peut utiliser dans les noms de variable des majuscules ou des minuscules, mais pour VB il n'y a pas de différence.

Exemple

On ne peut pas déclarer une variable VB et une variable vb.

Si on déclare une variable nommée 'VB' et si ultérieurement on tape 'vb', le logiciel le transforme automatiquement en 'VB'.

• On peut mettre des chiffres et des lettres dans les noms de variable, mais pas de chiffres en premier caractère.
  2A n'est pas un nom valide
  Nom2 l'est.
• Certains caractères de ponctuation ('…) ne peuvent pas être utilisés, d'autres "_" et "-" sont permis :
  nom_Utilisateur est valide.
  L'espace n'est pas permis.
• Bien sur, les mots clé de VB ne peuvent pas être utilisés : On ne peut pas nommer une variable Form ou BackColor

Il est conseillé de donner des noms explicites qui rappellent ce que contient la variable :

nom_Utilisateur est explicite, pas NU.

Parfois on indique en début de nom, par une lettre, le type de variable ou sa portée (la zone de code où la variable existe).

s_Nom 'Le s indique qu'il s'agit d'une variable String (chaine de caractères)

iIndex 'Le i indique qu'il s'agit d'une variable Integer (Entier)

gNomUtilisateur 'g indique que la variable est globale

Il est possible de 'forcer' le type de la variable en ajoutant un caractère spécial à la fin du nom de la variable.

Dim c$ = "aa" ' $ force c à être une variable String.

De même % force les Integer, & les long…

Cette notation est moins utilisée et non recommandée.

Voir en annexe, en bas de page des recommandations supplémentaires.

Nommage

Exemple

nom_Utilisateur

Avant d'utiliser une variable, il faut la déclarer, la créer, pour cela on utilise l'instruction Dim :

Dim a As Integer    'Déclare une variable nommée 'a' de type Entier

Avant la ligne, a n'existait pas, après le DIM, a existe et contient 0.

L'instruction Dim crée la variable et lui alloue un espace de stockage.

Il faut aussi parfois l'initialiser, c'est-à-dire lui donner une valeur de départ : a=3

On peut déclarer et initialiser en même temps :

Dim a As Integer =3

Rien n'empêche d'utiliser une expression, une fonction pour initialiser.

Dim a As Integer = CalculMaVariable(4,3)

Ici pour initialiser la variable, on appelle une fonction CalculMaVariable qui retourne une valeur pour a.

On peut déclarer plusieurs variables en même temps; il faut les séparer par des virgules :

Dim a, b, c As Integer        'a, b et c sont maintenant des variables de type integer.

Bien sûr, on ne peut pas déclarer plusieurs fois un même nom de variable :

Dim a As Integer
Dim a As String' <= non accepté

On peut affecter à une variable une valeur de même type que le type de la variable :

Dim a As Integer
 a=2  'OK
 a= "Philippe"  'Non, car on ne peut pas mettre une chaine de caractères dans une variable de type Integer

Les variables après avoir été déclarées, vont servir à stocker des données, à effectuer des calculs, on peut afficher ensuite leur valeur.

Exemple simpliste d'utilisation de variables :

    Dim varA As Integer        'Création d'une variable varA
                    
    Dim varB As Integer        'Création d'une variable varB
                    
    Dim total As Integer       'Création d'une variable total

                    
    varA=3                     'Mettre '3' dans a 

                    
    varB=2                     'Mettre '2' dans b

                    
    total=varA + varB          'Mettre dans la variable 'total' la valeur de varA et de varB  

                    
    LabelTotal.Text= total.ToString    'Afficher le total dans un label

Un label est une zone permettant d'afficher du texte, pour afficher dans un label il faut transformer la variable total qui est un entier en chaine de caractères (à l'aide de ToString) puis mettre la string dans le texte du label.

Noter bien la différence entre :

Dim total As Integer

total= 123 'Total est une variable numérique (Integer ou Entier) contenant le nombre 123

et

Dim total2 As String

total2= "123" 'Total2 est une variable string contenant la chaine de caractères "123" c'est-à-dire les caractères "1" , "2" et "3"

Il faudra donc parfois convertir le contenu d'une variable d'un type dans un autre type ( convertir une variable numérique en String pour l'afficher par exemple ou convertir une variable String en numérique pour faire un calcul). On apprendra cela plus loin.

L'exemple simpliste juste au-dessus le montre: il faut convertir total qui est un entier en string pour l'afficher.

Concernant les variables numériques

Les variables numériques peuvent être signées (accepter les valeurs négatives ou positives) ou non signées (Comme le Type 'Byte' qui ne contient que des valeurs positives). Les variables numériques peuvent contenir des entiers(comme les Integer) ou des réels (comme les Single). Pour les réels dans le code, le séparateur est le point:

En Visual Basic :

Contient une valeur booléenne : True ou False (Vrai ou Faux pour les sous doués en anglais!).

Exemple :

Dim myBoolean As Boolean

myBoolean = True

Après déclaration un Boolean a la valeur False.

Pour une variable entière il n'y a pas de possibilité de virgule!! attention, une division de 2 entiers donne un entier.

Pour le mathématicien, les Integer correspondent aux nombres entiers naturels : Entiers positif ou négatif et 0 (…-3 -2 -1 0 1 2 3…), mais avec une limite.

Plus on augmente le type (Long au lieu de Integer) plus on peut y mettre des grands nombres. Mais cela prend aussi plus de place et le traitement des opérations est plus long.

Les processeurs travaillant sur '32 bits', utilisez plutôt les Integer (qui sont codés sur 32 bits aussi), c'est plus rapide, que les short.

On utilise largement les 'Integer' comme variable de boucle, Flag, là ou il y a besoin d'entier…(Les calculs sur les réels en virgule flottante sont beaucoup plus lent.)

Exemple:

Dim i As Integer

i=12

Après déclaration une variable numérique contient 0.

Le type de données Byte est utilisé pour contenir des données binaires (octet codant de 0 à 255) non signé.

Un réel peut avoir une partie fractionnaire: 1,454 est un réel.

Pour le mathématicien, les Single, Double… correspondent aux nombres réels ou fractionnaires: mais avec des limites ( sur la précision et le fait qu'ils ne sont pas infinis).

Single, Double, Decimal.

Single Nombre réel en virgule flottante (-1,401298 *10^-45 à 1,401298 10^45)

Double Nombre réel en virgule flottante double précision. (-1,79769313486231570E+308 et -4,94065645841246544E-324 pour les valeurs négatives et entre 4,94065645841246544E-324 et 1,79769313486231570E+308 pour les valeurs positives)

Decimal Nombre réel en virgule fixe grande précision sur 16 octets: Avec une échelle 0 (aucune décimale), la plus grande valeur possible correspond à +/-79 228 162 514 264 337 593 543 950 335. Avec 28 décimales, la plus grande valeur correspond à +/-7,9228162514264337593543950335

Les variables en virgule flottante ou notation scientifique

(Single, Double)

La variable peut être positive ou négative.

Le 'Double' est, bien sûr, plus précis et peut atteindre des nombres plus grands que le 'Single'.

Le 'Single' comporte 7 chiffres significatifs maximum.

Le 'Double' comporte 18 chiffres significatifs maximum.

Le nombre est codé en interne sous forme scientifique, exemple:1,234568E+008.

Mais en pratique, on travaille et on les affiche de manière habituelle, en notation normale avec un point comme séparateur décimal :

Dim poids As Single
                    
poids=45.45

Format scientifique, mantisse et exposant

Voici 3 nombres :

14500000
0,145
0,0000145

Ils comportent tous les 3, deux informations :

• le nombre entier 145
• la localisation du premier chiffre par rapport à la virgule

8
-1
-5 dans nos exemples.

Donc un réel peut être stocké sous la forme d'un couple :

• partie entière ;
• localisation de la virgule.

Il est codé en interne avec une mantisse (la partie entière) et un exposant (position de la virgule), sous la forme mmmEeee, dans laquelle mmm correspond à la mantisse (chiffres significatifs: partie entière) et eee à l'exposant (puissance de 10).

En fait, en notation scientifique (en codage interne) un chiffre précède toujours la virgule: 1,234568E+008.

Quand on travaille avec des nombres ayant beaucoup de chiffres significatifs, il peut y avoir des erreurs d'arrondi. Le type 'Single' comporte par exemple une mantisse de 7 chiffres significatifs seulement. Si on utilise des nombres (même petit: avec un exposant négatif par exemple)avec 8 chiffres significatifs il peut y avoir des erreurs d'arrondi.

Le type en Virgule fixe.

Le type en Virgule fixe (Decimal) prend en charge jusqu'à 29 chiffres significatifs et peut représenter des valeurs jusqu'à 7,9228 x 10^28. Ce type de données est particulièrement adapté aux calculs (par exemple financiers) qui exigent un grand nombre de chiffres, mais qui ne peuvent pas tolérer les erreurs d'arrondi.
Il est codé sur 128 bits sous forme d'un entier et une puissance de 10.

Les Calculs en Decimal sont 10 fois plus lents que les calculs en Single, mais il n'y a pas d'erreur d'arrondi avec les décimals.

Pour les variables de boucle, les index, on utilise habituellement des Integers.

Le type 'String' peut contenir une 'chaine de caractères' (alphanumérique) comme du texte. La longueur de la chaine n'est pas fixe et une String peut avoir un nombre de caractères allant de 0 jusqu'à environ 2 milliards de caractères.

Les chaines de longueur fixe n'existent pas (plus).

Le Type 'Char' contient un seul caractère. On utilise souvent des tableaux de 'Char'.

Pour information Char et String contiennent en interne le code des caractères au format Unicode (dans la variable,chaque caractère est codé sur 2 octets) et pas de l'ASCII ou de l'ANSI…(ancien codage où chaque caractère était codé sur un octet).

Les premiers caractères ont le même code Unicode et Ascii.

Exemple :

Il y a aussi des caractères non affichables :

Pour passer à la ligne, on utilise les codes 13 puis 10. Il y a une constante toute faite pour cela: ControlChars.CrLf.

Les types de variables ont un nom en VisualBasic et un nom dans le Framework.

Exemple

Integer et System.Int32 sont équivalents pour designer le type 'entier', Integer est le type VB, System.Int32 est le type 'NET' correspondant. On peut utiliser l'un ou l'autre.

Exemple de place occupée par une variable (et le nom de sa Classe dans NET).

La méthode GetType permet de savoir de quel type, de quelle Classe est une variable.

Dim x As String ="a"

MessageBox.Show(x.GetType.ToString)    'Affiche: Systeme.String

Prend le type de x, le transforme en String, l'affiche dans une MessageBox (Noter qu'il faut initialiser x avec une valeur avant de faire GetType).

Mise à part Objet, Structure, Class tous les autres types sont dit 'Primitif'( Byte, Boolean, Short, Integer, Long, Single, Double, Decimal, Date, Char, String).

• Tous les types primitifs permettent la création de valeurs par l'écriture de littéraux. Par exemple, i=123 ou i=123I (le I force 123 a être entier) est un littéral de type Integer.
• Il est possible de déclarer des constantes des types primitifs.
• Lorsqu'une expression est constituée de constantes de type primitif, le compilateur évalue l'expression au moment de la compilation. C'est plus rapide.

Un littéral: c'est une donnée utilisée directement; une valeur numérique ou en toutes lettres par opposition à une variable.

Dim i As Integer
i=4   '4 est un littéral, c'est ici un integer

On voit que le littéral est un Integer en passant la souris dessus.

Dim i As Integer
i=100000000  'valeur non acceptée, car trop grande pour un littéral integer
Dim j As Long
j=100000000  'accepté, car le littéral est un Long

Attention, si je tape :

i=1.4

1.4 est un Double, il sera converti en Integer pour être affecté à i est on aura dans i la valeur 1.
Le signe entre la partie entière et fractionnaire est le '.' dans un littéral et cela force le littéral à être un Double.

On peut forcer le type d'un littéral en ajoutant une lettre :

i= 42L   'le 'L' indique que 42 est un Long
i= 42I   'le 'I' indique que 42 est un Integer
i= 42D   'le 'D' indique que 42 est un Decimal
i= 42S   'le 'S' indique que 42 est un Single
C = "A"c  'le 'c' force "A" à être une Char et non une String

Type Nullable

Les types Par Valeur peuvent être étendus afin d'accepter une valeur normale habituelle ou une valeur Null (Nothing en VB). On peut déclarer un type Nullable de 3 manières :

Dim MyInteger As Nullable (Of Integer)

Mais aussi :

Dim MyInteger? As Integer

Dim MyInteger As Integer?

C'est le '?' qui force la variable Nullable.

Sur la seconde déclaration, la variable est MyInteger

Autre exemple :

Dim MyBol As Boolean?

MyBol pourra prendre la valeur True, False et Nothing.

Cela a de l'intérêt quand on travaille avec les bases de données qui ont des champs qui contiennent un Null et avec Linq.

La propriété HasValue permet de voir si la variable a une valeur autre que Nothing (Valeur retrouvée dans Value).

Dim a? As Integer
        If a.HasValue = True Then
            MsgBox(a.Value.ToString)
        End If

• La plupart des noms sont une concaténation de plusieurs mots, utilisez des minuscules et des majuscules pour en faciliter la lecture.
• Pour distinguer les variables et les routines (procédures), utilisez la casse Pascal (CalculTotal) pour les noms de routine (la première lettre de chaque mot est une majuscule).
• Pour les variables,la première lettre des mots est une majuscule, sauf pour le premier mot (documentFormatType).
• Le nom des variables booléennes doit contenir Is qui implique les valeurs Yes/No ou True/False, Exemple fileIsFound.
• Même pour une variable à courte durée de vie qui peut apparaitre uniquement dans quelques lignes de code, utilisez un nom significatif. Utilisez des noms courts d'une seule lettre, par exemple i ou j, pour les index de petite boucle uniquement.
• N'utilisez pas des nombres ou des chaines littérales telles que For i = 1 To 7. Utilisez plutôt des constantes nommées, par exemple For i = 1 To Nombre_jour_dans_semaine, pour simplifier la maintenance et la compréhension.
• Utilisez des paires complémentaires dans les noms de variables telles que min/max, begin/end et open/close ou des expressions min max si nécessaire en fin de nom.

Il faut déclarer une variable avant de l'utiliser, pour cela on utilise l'instruction Dim.

Dim MyString As String

Déclare une variable nommée MyString et qui peut contenir une chaine de caractères.

Cette variable peut être utilisée pour contenir une chaine de caractères.

MyString= "TOTO"

'On met la chaine de caractères "TOTO" dans la variable MyString.

On peut afficher le contenu de la chaine dans un label (zone présente dans une fenêtre et où on peut afficher du texte) par exemple :

      Label.text = MyString

Cela affiche 'TOTO' dans le label.

Remarquons que pour définir une chaine de caractères il faut utiliser des "" : Ce qui est entre" et " est la chaine de caractères. On parle ici de chaine littérale: une représentation textuelle d'une valeur particulière.

Dim str As String    'str contient Nothing 
'Testons si str contient Nothing
If IsNothing(str) then Console.Write ( "contient Nothing")

(pas le texte "Nothing"!! mais la valeur Nothing qui signifie qu'elle ne pointe sur rien.

str= ""              'str contient "" : chaine vide de longueur 0

str= "TOTO"          'str contient "TOTO"

Notez bien l'importance des guillemets :

A est la variable A

"A" est une chaine de caractères contenant le caractère "A"

Exemple :

Dim A As String= "Visual"

Dim B As String= "Basic"

Label.text = "A+B"  affiche bêtement la chaine  "A+B"

Label.text =  A+B    affiche "VisualBasic" 'on affiche les variables.

Notez enfin que " ", l'espace est un caractère à part entière.

Si je veux inclure un caractère " dans la chaine, il faut le doubler pour qu'il ne soit pas considéré comme caractère de fin de chaine :

A=" Bonjour ""Monsieur"" "    'Cela affiche :  Bonjour "Monsieur"

On peut initialiser la variable en même temps qu'on la déclare.

Dim Chaine as string = "Toto"

On peut déclarer plusieurs variables d'un même type sur une même ligne.

Dim x, y, z As String    'Déclare 3 variables 'String'

On utilise GetType pour connaitre le type d'une variable.

x.GetType.ToString

y.GetType.ToString

z.GetType.ToString

donne

System.String

System.String

System.String

Ce qui prouve que les 3 variables sont bien des Strings.

V-E-1-a. La Classe System.String▲

Le type System.String ou String (chaine de caractères) est une Classe du Framework, qui a des méthodes.

Pas besoin de connaitre toutes les méthodes, il suffit de déclarer la String par 'Dim réponse As String') de taper réponse puis "." et vous voyez apparaitre toutes les propriétés et méthodes :

Voyons par exemple la méthode .ToUpper

Elle retourne la chaine de caractères en majuscules.

 

Sélectionnez

      str=str.ToUpper()

Si str contenait "abc" il contiendra "ABC"

.ToLower transforme par contre la chaine en minuscules.

Quel intérêt ?

Exemple

Je dois comparer 2 String pour savoir si elles sont égales, la première a été saisie par l'utilisateur et je ne sais pas si l'utilisateur a tapé en majuscules ou en minuscules.

Si je compare A = "Vb" et B= "vb" elles sont différentes.

Si je compare A.ToLower et B.ToLower elles sont égales.

.Trim

Permet de supprimer des caractères en début et fin de chaine.

 

Sélectionnez

Dim a As String = "#@Informatique@#"

Dim b As Char() = {"#", "@"}    'b est un tableau de Char contenant les caractères à supprimer.

a=a.Trim(b)  Donne a= "Informatique"

Attention : Bien utiliser Char() qui est un tableau de caractères pour définir les caractères à supprimer.

(Dim b As String= "#@" est déconseillé, car produisant des résultats curieux.)

Pour enlever les espaces avant et après la chaine (cas le plus fréquent) :

 

Sélectionnez

s=" Bonjour "

s=s.Trim(" ")    'donne s="Bonjour"

Attention avec Option Strict= On, s=s.Trim("") n'est pas accepté, car le paramètre de Trim doit être une Char, la String" "n'est pas transformée (castée) en char. Il faut écrire s=s.Trim(" "c) ou s=s.Trim(CChar("")).

Il existe aussi TrimStart et TrimEnd pour agir seulement sur le début ou la fin de la chaine.

Length

Length : Taille d'une chaine en nombre de caractères.

Afficher la taille de la chaine "VB"

 

Sélectionnez

Dim s As String= "VB"

MsgBox(s.Length.ToString) 'Affiche 2

Concat

Concaténation de plusieurs chaines : mise bout à bout :

 

Sélectionnez

s=String.Concat(a,b)

Il est plus rapide de faire : s= a & b

(s= a+b fait la même chose, mais est déconseillé, on réserve '+' pour l'addition de numériques).

Concat est très pratique quand on veut mettre bout à bout tous les éléments d'un tableau :

 

Sélectionnez

Dim s() As String = {"hello ", "my ", "friend ", "to "}
Dim c As String = String.Concat( s())

Insert

Insère une chaine dans une autre.

 

Sélectionnez

Dim s As String= "VisualBasic"

s= s.Insert(6,"  " ) 'Donne s= "Visual  Basic"

Noter : le premier caractère a la position 0.

Remove

Enlève des caractères à une certaine position dans une chaine.

 

Sélectionnez

Dim s As String = "VisualBasic"

s = s.Remove(2, 7) 'Donne s= "Viic"

Replace

Remplace dans une chaine de départ, toutes les occurrences d'une chaine par une autre.

Resultat=ChaineDépart.Replace(chaineARemplacer,chaineQuiRemplace)

 

Sélectionnez

Dim s As String= "Visual_Basic"

s= s.Replace("_"," " ) 'Donne s= "Visual  Basic"

Autre exemple

L'utilisateur a tapé une date, mais avec comme séparateur des ".", comme on le verra plus loin, il est nécessaire d'utiliser plutôt les "/", pour cela on utilise Replace

 

Sélectionnez

Dim ladate as string= "12.02.1990"

ladate= ladate.Replace(".","/" ) 'Donne ladate= "12/02/1990"

Split

Découpe en plusieurs sous chaines une chaine de départ, cela par rapport à un séparateur.

Exemple

Je récupère dans un fichier une chaine de mots ayant pour séparateur ";", je veux mettre chaque mot dans un tableau.

chaine contenant les mots séparés par ";"

 

Sélectionnez

Dim s As String= "Philippe;Jean ;Toto"  

Dim separateur As Char = ";"

Dim nom() As String

nom=s.Split(separateur)

Donne :

 

Sélectionnez

      nom(0)= "Philippe"

      nom(1)= "Jean"

      nom(2)= "Toto"

Remarque : quand on déclare le tableau nom(), on ne donne pas le nombre d'éléments, c'est Split qui crée autant d'éléments qu'il faut.

En Framework 2, on peut utiliser plusieurs séparateurs différents :

 

Sélectionnez

nom=s.Split( New Char() {" "c, ","c, "."c }) 'ici on a 3 séparateurs: l'espace, la virgule et le point.

le ci-après chaque séparateur veut dire Char, car les séparateurs sont des caractères.

On peut ajouter 2 paramètres permettant d'indiquer le nombre de lignes maximum et forcer l'élimination des lignes vides.

 

Sélectionnez

Dim sep() As Char={" "c, ","c, "."c}

Dim nom() As String = S.Split ( sep, 100, StringSplitOptions.RemoveEmptyEntries )

Allons encore plus loin: avant et après le séparateur, il peut y avoir des espaces.

Il faut dans ce cas utiliser la méthode Split de la classe Regex :

 

Sélectionnez

Imports System.Text.RegularExpressions

Dim S As String = "abc ; def ; ghi"

' On crée un Regex

Dim R As New Regex("\s*;\s*")

' décomposition de ligne en champs

Dim Nom As String() = R.Split(S)

.Join

Concatène tous les éléments d'un tableau et peut ajouter des séparateurs.

Si myLines() est un tableau de String, je veux ajouter ces lignes bout à bout en les séparant d'un retour à la ligne.

 

Sélectionnez

Dim myText As String = String.Join ( ControlChars.CrLf, myLines)

.IndexOf .LastIndexOf

Indique le numéro du caractère, la position (la première occurrence) ou une chaine à chercher est trouvée dans une autre. Recherche en commençant par la fin avec LastIndexOf.

 

Sélectionnez

Dim a As String= "LDF.EXE"

Dim r As Char()={"."}

a.IndexOf(r)  retourne 3

Se souvenir : le premier caractère est en position 0 en .Net.

.LastIndexOf retourne la dernière occurrence.

.IndexOfAny .LastIndexOfAny (Framework 2)

Indique le numéro du caractère, la position (la première occurrence) ou une chaine à chercher est trouvée dans une autre avec en plus possibilité d'indiquer la position de départ.

 

Sélectionnez

Dim a As String= "LDF.EXE"

Dim r As Char()={"."}

a.IndexOfAny(r)  recherche à partir du début de chaine.

a.IndexOfAny(r,2)  recherche à partir du deuxième caractère.

Autre exemple: On recherche ici plusieurs caractères (en fait un tableau de Char)

 

Sélectionnez

Dim str As String ="gfdjzak;,vdqsygeak"

Dim start As Integer =2

Dim at As Integer 

Dim count As Integer =5

Dim target As String = "ou" 'chaine à chercher 

Dim anyOf As Char() = target.ToCharArray() 'on transforme la chaine en tableau de char 

at = str.IndexOfAny(anyOf, start, count) 
'on cherche le tableau de Char anyOf dans str à partir de la position start et sur count caractères.

.Compare

Compare 2 chaines :

 

Sélectionnez

Dim rep As Integer

rep=String.Compare(a,b)

Retourne un entier.

 

Sélectionnez

      -1 si a<b

      0 si a=b

      1 si a>b

On peut comparer des sous-chaines et indiquer la sensibilité à la casse (Framework 2) :

 

Sélectionnez

Dim myStr1 As [String] = "My Uncle Bill"
Dim myStr2 As [String] = "My uncle bill"
Dim r As Integer = String.Compare(myStr1, 2, myStr2, 2, 10, StringComparison.CurrentCultureIgnoreCase)

Ici on compare 10 caractères en commençant par le deuxième caractère de chaque chaine en mode insensible à la casse (majuscules=minuscules).
Voir ci-dessous, le chapitre comparaison.

.Equals

Permet de comparer 2 chaines. Retourne True si elles sont égales.

 

Sélectionnez

Dim b As Booleen= String.Equals("aaa", "AAA")
'b=False

On peut ajouter un paramètre pour signifier la culture ou indiquer de ne pas tenir compte de la case comme ici :

 

Sélectionnez

Dim b As Booleen= String.Equals("aaa", "AAA", StringComparison.CurrentCultureIgnoreCase)
'b=True

.Contains

Permet de savoir si une chaine apparait dans une autre: (Framework 2)

 

Sélectionnez

Dim trouve As Boolean

trouve = a.Contains( "123")

Retourne True ou False

.Substring

Extrait une partie d'une chaine.

Le premier paramètre indique la position de départ; le second, le nombre de caractères à extraire.

 

Sélectionnez

Dim a As String= "Informatique"

MessageBox.show(a.Substring(2,3)) 'Affiche  for

Le premier paramètre indique la position du caractère où doit commencer la sous-chaine, en commençant à la position 0. (les caractères sont comptés 0, 1, 2, 3….

Le second paramètre la longueur de la sous-chaine.

Exercice 1: comment obtenir les 4 caractères de droite :

 

Sélectionnez

Dim a As String= "Informatique"

MessageBox.show(a.Substring(A.Length-4)) 'Affiche  ique

Ici on omet le second paramètre,la longueur de la sous-chaine, va jusqu'a la fin de la chaine.

Exercice 2 : comment obtenir les 3 caractères de gauche :

 

Sélectionnez

Dim a As String= "Informatique"

MessageBox.show(a.Substring(0, 3)) 'Affiche  inf

.Chars

Une chaine peut être perçue comme un tableau de caractères (instances Char) ; vous pouvez extraire un caractère particulier en faisant référence à l'index de ce caractère par l'intermédiaire de la propriété Chars. Par exemple :

 

Sélectionnez

Dim maString As String = "ABCDE"
Dim monChar As Char
monChar = maString.Chars(3) ' monChar = "D"

On peut créer des chaines avec la Classe String :

 

Sélectionnez

myString = New String(" ", 15)    'Créer une chaine de 15 espaces

.PadRight

Aligne les caractères de cette chaine à gauche et remplit à droite en ajoutant un caractère Unicode spécifié pour une longueur totale spécifiée.

 

Sélectionnez

Dim str As String
Dim pad As Char
str = "Nom"
pad = Convert.ToChar(".") 
Console.WriteLine(str.PadRight(15, pad)) ' Affiche Nom………………

PadLeft fait l'inverse.

.StartsWith() et EndsWith()

Permettent de tester si une string commence ou se termine par une string, retourne True ou False.

Tester si la String s commence par "abc" et se termine par "xyz" :

 

Sélectionnez

If s.StartWith ("abc") And s.EndWith ("xyz") Then

En VB 2005, on peut ajouter un argument gérant la culture ou la casse.

Voir aussi String.Format dans le chapitre : Afficher correctement du texte.

.IsNull , IsNullOrEmpty() Framework 2

Il est parfois nécessaire de vérifier si une chaine est égale à Nothing ou de longueur égale à 0 (vide).

 

Sélectionnez

If S Is Nothing AndOr S.length=0 Then

Ou

 

Sélectionnez

If String.IsNullOrEmpty( S) Then

À partir de vb 2010 existe aussi String.IsNullOrWhiteSpace qui est égal à True si la chaine est Null Empty ou ne contient que des espaces :

 

Sélectionnez

If String.IsNullOrWhiteSpace(value) Then…
'Est équivalent à (mais plus rapide): 
If String.IsNullOrEmpty(value) OrElse value.Trim().Length = 0 Then….

V-E-1-b. Les instructions 'Visual Basic'▲

MaString = "Mid Demonstration" 
a = Mid(MaString, 1, 3) ' Retourne "Mid".

a = Mid(MaString, 14)

Mid(MaString, 1, 3) = "Fin"

a=Right(MaString,2)

a=Microsoft.VisualBasic.Left(MaString,2)

MyLen = Len(MaString)

    a=LTrim("  RRRR")

n=InStr(1,"aaaaRaa","R")        'retourne 5

maString = StrDup(5, "P") ' Retourne "PPPPP"

    x=Asc("A")

x=Asc("ABCD")

Chr(65)

Chr(&H20)

Dim maString As String = "AIDE"
Dim monChar As Char
monChar = GetChar(maString, 3) ' monChar = "D"

Lowercase = LCase(UpperCase)

Dim maString As String = "gauche"
Dim r As String
r = LSet(maString, 2) ' Retourne "ga" 

Si la chaine de départ est plus courte que la longueur spécifiée, des espaces sont ajoutés.
r = LSet(maString, 8) ' Retourne "gauche  "

Dim maString As String = "STRESSED"

Dim revString As String

revString = StrReverse(maString)    ' Retourne "DESSERTS"

TableauResultat= Filter( TableauChaine, Match, Include, Compare)

Dim TestStrings(2) As String
TestStrings(0) = "Ici"
TestStrings(1) = "Si"
TestStrings(2) = "si"
Dim subStrings() As String    'chaine des résultats

subStrings = Filter(TestStrings, "i", True, CompareMethod.Text)
'Retourne "Ici","Si","si"

subStrings = Filter(TestStrings, "si", True, CompareMethod.Binary)
' Retourne "si".

subStrings = Filter(TestStrings, "si", False, CompareMethod.Binary)
'Retourne "Ici","Si"

Dim R As Boolean
R = "D" Like "D" ' Est-ce que "D" est égal à "D"? => True.


R = "F" Like "f" ' Est-ce que "F" est égal à "f"? => False.


R = "F" Like "FFF" ' Est-ce que "F" est égal à "FFF"? => False.


R = "cBBBc" Like "c*c" ' Est-ce que "cBBBc" répond au pattern (avoir un "c" au 
'début, un  "c" à la fin, et des caractères au milieu? Retourne True.


R = "J" Like "[A-Z]" ' Est-ce que "J" est contenu dans les caractères allant de
'  A à Z? Retourne True.


R = "I" Like "[!A-Z]" ' Est-ce que "I" n'est PAS dans les caractères allant de
'  A à Z? Retourne  False.


R = "a4a" Like "a#a" ' Est-ce que "a4a" commence et finit par un
' "a" et à un nombre entre les 2? Retourne True.


R = "bM6f" Like "b[L-P]#[!c-e]" ' Est-ce que "bM6f" 

'commence par  "b",

'a des caractères entre L et P

'un nombre

'se termine par un caractère non compris entre c et e

'retourne True

V-E-1-c. Un exemple▲

Dim X As Integer = 2

Label1.Text= "Le carré de " & X & "  est " & X * X

Dim X As Integer

X=2

Label1.Text= "Le carré de " & X & "  est " & X * X

V-E-1-d. Comparaison de caractères (Option Compare)▲

les instructions '=', '>', '<':

Dim s1 As String ="ABCD"

Dim s2 As String ="XYZ"

V-E-1-e. Comparaison avec Equals et String.Compare▲

Dim myStr1 As [String] = "My Uncle Bill"
Dim myStr2 As [String] = "My uncle bill"
Dim r A Boolean= myStr1.Equals(MyStr2)

'Autre syntaxe:
Dim r A Boolean= String.Equals(MyStr1, MyStr2)

'Avec la première syntaxe, on peut ajouter des options de comparaison :
Dim r A Boolean= myStr1.Equals(MyStr2, CurrentCultureIgnoreCase)

Dim myStr1 As [String] = "My Uncle Bill"
 Dim myStr2 As [String] = "My uncle bill"
        Dim r As Integer = String.Compare(myStr1, myStr2)
        MessageBox.Show(r.ToString)

'Affiche 1, car "A"<"a"
 MessageBox.Show(String.Compare("A", "a").ToString)

Dim myStr1 As [String] = "My Uncle Bill"
 Dim myStr2 As [String] = "My uncle bill"
        Dim r As Integer = String.Compare(myStr1, myStr2, ignoreCase:=True)
        MessageBox.Show(r.ToString)

'Autre syntaxe: on a 2 options
Dim r As Integer = String.Compare(myStr1, myStr2, CompareOptions.IgnoreCase And CompareOptions.IgnoreSymbol)

Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
Dim r As Integer= myComp.Compare(myStr1, myStr2))

Dim myStr1 As [String] = "My Uncle Bill"
Dim myStr2 As [String] = "My uncle bill"
Dim r As Integer = String.Compare(myStr1, 2, myStr2, 2, 10, StringComparison.CurrentCultureIgnoreCase)

V-E-1-f. Unicode▲

Les variables 'String' sont stockées sous la forme de séquences de 16 bits (2 octets) non signés dont les valeurs sont comprises entre 0 et 65 535. Chaque nombre représente un caractère Unicode. Une chaine peut contenir jusqu'à 2 milliards de caractères.

L'Unicode est donc un codage de caractères sur 16 bits qui contient tous les caractères d'usage courant dans les langues principales du monde.

Les premiers 128 codes (0-127) Unicode correspondent aux lettres et aux symboles du clavier américain standard. Ce sont les mêmes que ceux définis par le jeu de caractères ASCII (ancien codage sur un octet). Les 128 codes suivants (128-255) représentent les caractères spéciaux, tels que les lettres de l'alphabet latin, les accents, les symboles monétaires et les fractions. Les codes restants sont utilisés pour des symboles, y compris les caractères textuels mondiaux, les signes diacritiques, ainsi que les symboles mathématiques et techniques.

Voici les 255 premiers :

Le petit carré indique un caractère non imprimable (non affichable), certains caractères sont des caractères de contrôle comme le numéro 9 qui correspondant à tabulation, le numéro 13 qui correspond au retour à la ligne…

Les variables Char contiennent un caractère et un seul, un caractère est stocké sous la forme d'un nombre de 16 bits (2 octets) non signé dont les valeurs sont comprises entre 0 et 65 535. Chaque nombre représente un seul caractère Unicode. Pour les conversions entre le type Char et les types numériques, il y a les fonctions AscW et ChrW qui peuvent être utilisées…

L'ajout du caractère 'c' à un littéral de chaine force ce dernier à être un type Char. À utiliser surtout si Option Strict (qui force à être strict…) est activé.

Exemple:

Option Strict On
'…
Dim C As Char
C = "A"c

'Autre manière de faire:
C=CChar("A")
'On convertit la String "A" en Char

Après déclaration une variable Char contient '' c'est-à-dire un caractère vide.

String.ToCharArray: Permet de passer une string dans un tableau de Char :

Dim maString As String = "abcdefghijklmnop"
Dim maArray As Char() = maString.ToCharArray

La variable maArray contient à présent un tableau composé de Char, chacun représentant un caractère de maString.

Pour mettre le tableau de Char dans une String :

Dim maNewString As String (maArray)
 
String.Chars():

vous pouvez extraire un caractère particulier en faisant référence à l'index de ce caractère par l'intermédiaire de la propriété Chars. Par exemple :

Dim maString As String = "ABCDE"

Dim monChar As Char

monChar = maString.Chars(3) ' monChar = "D"

Un caractère est-il numérique ? un chiffre ? une lettre ? un séparateur ? un espace ?

    Dim chA As Char
        chA = "A"c
        Dim ch1 As Char
        ch1 = "1"c
        Dim str As String
        str = "test string"

        Console.WriteLine(chA.CompareTo("B"c))          ' Output: "-1" '  A est plus petit que B
        Console.WriteLine(chA.Equals("A"c))             ' Output: "True" ' Egal?
        Console.WriteLine(Char.GetNumericValue(ch1))    ' Output: 1     'Convertir en valeur numérique (double)
        Console.WriteLine(Char.IsControl(Chr(9)))       ' Output: "True"'  Est une caractère de contrôle?
        Console.WriteLine(Char.IsDigit(ch1))            ' Output: "True"'  Est un chiffre
        Console.WriteLine(Char.IsLetter(","c))          ' Output: "False"' Est une lettre
        Console.WriteLine(Char.IsLower("u"c))           ' Output: "True" ' Est en minuscules
        Console.WriteLine(Char.IsNumber(ch1))           ' Output: "True" ' Est un nombre
        Console.WriteLine(Char.IsPunctuation("."c))     ' Output: "True" ' Est un caractère de ponctuation
        Console.WriteLine(Char.IsSeparator(str, 4))     ' Output: "True" ' Est un séparateur
        Console.WriteLine(Char.IsSymbol("+"c))          ' Output: "True" ' Est un symbole
        Console.WriteLine(Char.IsWhiteSpace(str, 4))    ' Output: "True" ' Est un espace
        Console.WriteLine(Char.ToLower("M"c))           ' Output: "m"     ' Passe en minuscules

Existe aussi IsLetterOrDigit, IsUpper.

Bien sûr, si 'Option Strict= On', il faut ajouter .ToString à chaque ligne :

Console.WriteLine(Char.ToLower("M"c).ToString)

On note que l'on peut tester un caractère dans une chaine : Char.IsWhiteSpace(str, 4)

Autre manière de tester chaque caractère d'une String :

Dim V as string

For Each C As Char in V    'Pour chaque caractère de V…

      C…

Next

Ici la String est considérée comme une collection de Char. (C'est aussi une collection de String)

Mais on verra plus loin les collections et les boucles For Each.

Conversions Char <->Unicode

On rappelle que l'Unicode est le mode de codage interne des caractères.

Dim monUnicode As Short = Convert.ToInt16 ("B"c) ' le code Unicode  de B est 66.
Dim monChar As Char = Convert.ToChar (66) '   monChar="B"

Pour savoir si un caractère a un code Unicode précis il y a 2 méthodes :

if MyChar=Convert.ToChar(27) then…

ou

if AscW(MyChar)=27 then…

Si vous souhaitez utiliser Asc et Chr de VisualBasic :

Dim monAscii As Short = Asc("B") 'Asc donne le code ASCII ou l'Unicode (Ascw fait de même ?)
Dim monChar As Char= Chr(66) 'Char retourne le caractère qui a le code ASCII donné.

Débutant s'abstenir.

On a vu que les chaines de longueur fixe n'existent pas en VB.NET (compatibilité avec les autres langages oblige), ET ON S'EN PASSE TRÈS BIEN, mais il y a moyen de contourner le problème si nécessaire.

On peut créer une chaine d'une longueur déterminée (comme paramètres pour appeler une API par exemple) par :

Dim Buffer As String
Buffer = New String(CChar(" "), 25)
'appel
UserName = Left(Buffer, InStr(Buffer, Chr(0)) - 1) 'on lit jusqu'au caractère 
'chr(0) qui est en interne le dernier caractère de la chaine

On peut aussi utiliser la Classe de compatibilité VB6: à éviter++

(Il faut charger dans les références du projet Microsoft.VisualBasic.Compatibility et Compatibility Data)

Dim MaChaineFixe As New VB6.FixedLengthString(100)

'pour l'initialiser en même temps:
Dim MaChaineFixe As New VB6.FixedLengthString(100, "hello")

Pour afficher la chaine fixe, utilisez MaChaineFixe.ToString.

Mais pour mettre une chaine dans cette chaine de longueur fixe!! galère pour trouver!!!

MaChaineFixe.Value="ghg"

Enfin ce type de chaine fixe ne peut pas être utilisé dans les structures, mais il y a un autre moyen pour les structures. On verra cela plus loin.

Donc les chaines fixes sont à éviter.

Débutant s'abstenir.

Les expressions régulières sont une manière de rechercher (de remplacer, d'extraire) une sous-chaine ou un modèle d'une chaine de caractères.

On a un modèle, on veut voir si une chaine contient des parties répondant à ce modèle. Simplement pour voir ou pour séparer des sous-chaines, remplacer…

Exemple: une chaine ne contient-elle que les lettres 'abc', commence-t-elle par 'hello' ou 'HELLO', est-elle une adresse mail valide, un code postal valide? Comment découper une chaine ayant comme séparateur des chiffres? Comment remplacer tous les caractères 'wxyz' par des '-'?….

V-E-4-a. Principe du regex▲

Imports System.Text.RegularExpressions

Dim rg As New Regex("[0-9]")

rg.IsMatch("4545896245")  'retourne True, car il n'y a que des chiffres.

MsgBox(rg.IsMatch("45gdGRj1"))  'Affiche False dans une Box

Dim rg As New Regex("^([\w]+)@([\w]+)\.([\w]+)$")

MsgBox(rg.IsMatch("philippe@lasserrelyon.fr")) 'affiche True

V-E-4-b. Caractères pour modèle regex▲

V-E-4-c. Exemples▲

V-E-4-d. Divers utilisations de Regex▲

Funtion  SiValideMail (Adresse As String) As Boolean

Dim rg As New Regex("^([\w]+)@([\w]+)\.([\w]+)$")
Return rg.IsMatch(Adresse) 

End Function

Funtion  Remplace (Chaine As String) As String

Dim rg As New Regex("hello|salut|buenas dias")
Return rg.Replace(Chaine, "bonjour") 

End Function

Dim ch As String ="az45er78ty"

Dim rg As New Regex("\d+")
Dim t() As String= rg.Split(ch)

Dim ch As String ="az,er,ty"

Dim rg As New Regex("[a-z]{2}")
Dim mac As MatchCollection = rg.Matches(ch)

For Each m As Match In mac 
 MsgBox( m.Value &" en position " & m.Index)
Next

Dim ch As String ="Ceci est un cours vb"

Dim rg As New Regex("(\p{Lu}|\p{Ll})+")
Dim mac As MatchCollection = rg.Matches(ch)

For Each m As Match In mac 
 MsgBox( m.Value &" en position " & m.Index)
Next

Funtion  Remplace (Chaine As String) As String

Return Regex.Replace("salut", "bonjour") 

End Function

Funtion  Remplace (Chaine As String) As String

Return Regex.Replace("salut", "bonjour" , RegexOptions.IgnoreCase Or RegexOptions.Compiled) 

End Function

Dim rg As New Regex("salut", RegexOptions.IgnoreCase Or RegexOptions.Compiled)

Débutant s'abstenir.

Les opérations sur les Strings peuvent être accélérées, il faut pour cela utiliser les StringBuilder.

Exemple d'une opération coûteuse en temps :

Dim s As String = "bonjour"
     
s += "mon" + "ami"

Le Framework va créer 3 chaines en mémoire avec toutes les pertes en mémoire et en temps que cela implique. (il crée une chaine "bonjour" puis il crée une chaine "bonjour mon" puis…
On dit que le type String est immutable.
Pour l'exemple précédent, cela ralentit peu, mais dans une boucle qui concatène 10 000 chaines !!

Pour effectuer des opérations répétées sur les string, le framework dispose donc d'une classe spécialement conçue et optimisée pour ça : System.Text.StringBuilder.

Pour l'utiliser, rien de plus simple :

Dim sb As new System.Text.StringBuilder()

    sb.Append("bonjour")

    sb.Append("mon ami")

    Dim s As String

    s = sb.ToString()

Il y a création et utilisation d'une seule chaine : sb La méthode ToString de la classe StringBuilder renvoie la chaine qu'utilise en interne l'instance de StringBuilder.

Pour comparer 2 StringBuilder utiliser la méthode Equals plutôt que =.

À partir de vb 2010 il existe StringBuilder.Clear.

Pour qu'elle soit disponible, il faut d'abord importer l'espace de noms 'Math' du FrameWork :

Pour cela il faut taper en haut de la fenêtre (au-dessus de public Class) :

Imports System.Math

Si on n'a pas importé l'espace de nom, il faut ajouter Math. avant le nom de la fonction. Exemple :

R=Math.Abs(N)

On verra plus loin ce que cela signifie.

Dim N As Single

Dim R As Single

 

R=Abs(N)    'retourne la valeur absolue

            'Si N=-1.2  R=1.2

R=Sign(N)   'retourne le signe

            'Si N=-1.2  R=-1 (négatif) ; retourne 1 si nombre positif

 

R=Round(N)  'retourne le nombre entier le plus proche

            ' N=1.7     R=2

            ' N=1.2     R=1

            ' N=1.5     R=2

Pour Round, si nombre <0.5 retourne 0 si > ou = à 0.5 retourne 1; c'est la manière d'arrondir les nombres en Euros, comme sur la feuille d'impôts.

On peut donner en second paramètre le nombre de digits : Math.Round(Valeur, 2)donne 2 décimales après la virgule.

R=Truncate(N)

Retourne la partie entière (enlève les chiffres après la virgule, arrondie à l'entier le plus proche en allant vers zéro).

'N=1.7 R=1

R=Floor(N)

Retourne le plus grand entier égal ou inférieur (arrondi à l'entier inférieur le plus proche en allant vers l'infini négatif).

N=1.7 R=1

R=Ceiling(N)

Retourne le plus petit entier égal ou supérieur. (arrondi à l'entier supérieur le plus proche en allant vers l'infini positif).

N=1.2 R=2

R=Max(2,3)

Retourne le plus grand des 2 nombres.

Retourne 3

R=Min(2,3)

Retourne le plus petit des 2 nombres.

Retourne 2

R=Pow(2,3)

Retourne 2 puissance 3.

Retourne 8

R=Sqrt(9)

Retourne la racine carrée.

Retourne 3

longResult = Math.BigMul(int1, int2) 'BigMul donne le résultat de la multiplication de 2 entiers sous forme d'un long.

intResult = Math.DivRem(int1, int2, Reste) DivRem donne le résultat (intResult) de la division de int1 par int2 et retourne le reste (Reste), cela pour des entiers.

Il existe aussi Log, Log10, Exp.

Bien sur il y a aussi Sin Cos Tan, Sinh Cosh Tanh (pour hyperbolique) Asin Acos Atan Atan2.

Prenons un exemple :

Imports System.Math
Dim MonAngle, MaSecant As Double
MonAngle = 1.3 '  angle en  radians.
MaSecant = 1 / Cos(MonAngle) ' Calcul la sécante.