Le tableau suivant présente les types de données reconnus en précisant la taille des enregistrements et la plage des valeurs.

Type de données	Taille en mémoire	Plage
Byte	1 octet	0 à 255
Boolean	2 octets	True ou False
Integer	2 octets	-32 768 à 32 767
Long (entier long)	4 octets	-2 147 483 648 à 2 147 483 647
Single (à virgule flottante en simple précision)	4 octets	-3,402823E38 à -1,401298E-45 pour les valeurs négatives ; 1,401298E-45 à 3,402823E38 pour les valeurs positives
Double (à virgule flottante en double précision)	8 octets	-1,79769313486232E308 à -4,94065645841247E-324 pour les valeurs négatives ; 4,94065645841247E-324 à 1,79769313486232E308 pour les valeurs positives
Currency (entier à décalage)	8 octets	-922 337 203 685 477,5808 à 922 337 203 685 477,5807
Decimal	14 octets	+/-79 228 162 514 264 337 593 543 950 335 sans séparateur décimal ; +/-7,9 228 162 514 264 337 593 543 950 335 avec 28 chiffres à droite du séparateur décimal  ; le plus petit nombre différent de zéro est +/-0.0000000000000000000000000001.
Date	8 octets	1er janvier 100 au 31 décembre 9999
Object	4 octets	Toute référence à des données de type Object
String (longueur variable)	10 octets + longueur de la chaîne	0 à environ 2 milliards
String (longueur fixe)	Longueur de la chaîne	1 à environ 65  400
Variant (nombres)	16 octets	Toute valeur numérique, avec la même plage de valeurs qu’une donnée de type Double
Variant (caractères)	22 octets + longueur de la chaîne	Même plage de valeurs qu’une donnée de type String de longueur variable
Type défini par l’utilisateur (avec Type)	En fonction des éléments	La plage de valeurs de chaque élément correspond à celle de son type de données.

Note Quel que soit le type de données, les tableaux nécessitent 20 octets de mémoire, auxquels viennent s’ajouter quatre octets pour chaque dimension et le nombre d’octets occupés par les données. L’espace occupé en mémoire par les données peut être calculé en multipliant le nombre d’éléments par la taille de chacun d’eux. Par exemple, les données stockées dans un tableau unidimensionnel constitué de quatre éléments de type Integer de deux octets chacun occupent huit octets. Ajoutés aux 24 octets d’espace mémoire de base, ces huit octets de données portent la mémoire totale nécessaire pour le tableau à 32 octets.

Une variable de type Variant contenant un tableau nécessite 12 octets de plus qu’un tableau seul.

2 - Règles de nommage Visual Basic

Les noms d'objets doivent comporter un préfixe cohérent, permettant d'identifier facilement leur type. Vous trouverez ci-dessous la liste des conventions relatives à certains objets pris en charge par Visual Basic.

2.1 - choix des préfixes de contrôles.

 

1. Objet	Nom	Prefixe	Exemple
   Barre de défilement verticale	(VscrollBar)	vsb	vsbRate
   Bouton animé	(AniPushButton)	ani	aniMailBox
   Bouton de commande	(CommandButton)	cmd	cmdExit
   Cadre	(Frame)	fra	fraLanguage
   Case à cocher	(CheckBox)	chk	chkReadOnly
   Boites de dialogue communes	(CommonDialog)	dlg	dlgFileOpen
   Communications	(MSComm)	com	comFax
   Plan	(Outline)	out	outOrgChart
   Contrôle	(Control) (type spécifique inconnu)	ctr	ctrCurrent
   Contrôle de données	(Data)	dat	datBiblio
   État	(CrystalReport)	rpt	rptQtr1Earnings
   État de la touche	(Mhstate)	key	keyCaps
   Étiquette	(Label)	lbl	lblHelpMessage
   Feuille	(Form)	frm	frmEntry
   Feuille MDI fille	(MDI child form)	mdi	mdiNote
   Forme	(Shape)	shp	shpCircle
   Graphique	(Graph)	gra	graRevenue
   Grille	(Grid)	grd	grdPrices
   Grille dépendante	(DBGrid)	dbgrd	dbgrdQueryResult
   Image		img	imgIcon
   Image	(Picture)	pic	picVGA
   Liste d’images	(ImageList)	ils	ilsAllIcons
   Indicateur	(Gauge)	gau	gauStatus
   Ligne	(Line)	lin	linVertical
   Liste de fichiers	(FileListBox)	fil	filSource
   Liste de dossiers	(DirListBox)	dir	dirSource
   Liste de lecteurs	(DriveList Box)	drv	drvTarget
   Liste modifiable dépendante	(DBCombo)	dbcbo	dbcboLanguage
   Affichage de listes	(ListView)	lvw	lvwHeadings
   Multimédia MCI		mci	mciVideo
   Menu		mnu	mnuFileOpen
   Message MAPI	(MAPI message)	mpm	mpmSentMessage
   Minuterie	(Timer)	tmr	tmrAlarm
   MS Flex grid		msg	msgClients
   Onglet	(MSTab)	mst	mstFirst
   OLE		ole	oleWorksheet
   Panneau 3D	(3D Panel)	pnl	pnlGroup
   Pen Bedit		bed	bedFirstName
   Pen Hedit		hed	hedSignature
   Pen ink		ink	inkMap
   Jeu d’image	(PictureClip)	clp	clpToolbar
   Barre de progression	(ProgressBar)	prg	prgLoadFile
   Éditeur RTF	(RichTextBox)	rtf	rtfReport
   Session MAPI	(MAPI session)	mps	mpsSession
   Curseur	(Slider)	sld	sldScale
   Compteur	(SpinButton)	spn	spnPages
   Barre d’état	(StatusBar)	sta	staDateTime
   Barre d’onglets	(TabStrip)	tab	tabOptions
   Barre d’outils	(Toolbar)	tlb	tlbActions
   Affichage de l’arborescence	(TreeView)	tre	treOrganization
   Barre de défilement	(UpDown)	upd	updDirection
   Zone de liste	(ListBox)	lst	lstPolicyCodes
   Zone de liste dépendante	(Dblist)	dblst	dblstJobType
   zone de liste déroulante	(ComboBox)	cbo	cboEnglish
   Zone de texte	(TextBox)	txt	txtLastName

2.2 - Choix des préfixes d’objets d’accès aux données (DAO)

Utilisez les préfixes suivants pour signaler des objets d’accès aux données.

Objet de base de données	Préfixe	Exemple
Container	con	conReports
Database	db	dbAccounts
DBEngine	dbe	dbeJet
Document	doc	docSalesReport
Field	fld	fldAddress
Group	grp	grpFinance
Index	idx	idxAge
Parameter	prm	prmJobCode
QueryDef	qry	qrySalesByRegion
Recordset	rec	recForecast
Relation	rel	relEmployeeDept
TableDef	tbd	tbdCustomers
User	usr	usrNew
Workspace	wsp	wspMine

Exemples :

Dim dbBiblio As Database
Dim recPubsInNY As Recordset, strSQLStmt As String
Const DB_READONLY = 4’ Définit la constante.
‘Ouvre la base de données.
Set dbBiblio = OpenDatabase(" BIBLIO.MDB ")
‘ Définit le texte de l’instruction SQL.
StrSQLStmt = " SELECT * FROM Publishers WHERE State =‘NY’ "
‘ Crée l’objet Recordset.
Set recPubsInNY = db.OpenRecordset(strSQLStmt, dbReadOnly)

2.3 - Choix des préfixes de menus

Les applications utilisent généralement de nombreux contrôles de menus ; il est donc utile d'adopter pour ces contrôles un ensemble unique de conventions d'affectation de noms. Nous vous conseillons d'ajouter à l'étiquette initiale "mnu " des préfixes de contrôles de menus un préfixe supplémentaire pour chaque niveau d'imbrication, le libellé de menu final figurant à la fin de la chaîne de nom. Le tableau suivant fournit quelques exemples.

Séquence de libellés de menu	Nom du gestionnaire de menu
Fichier Ouvrir	mnuFileOpen
Fichier Envoyer Email	mnuFileSendEmail
Fichier Envoyer télécopie	mnuFileSendFax
Format caractère	mnuFormatCharacter
Index d'Aide	mnuHelpContents

Si vous utilisez cette convention d'affectation de noms, tous les membres d'un menu donné figurent les uns à côté des autres dans la fenêtre Propriétés de Visual Basic. De plus, les noms de contrôles de menus permettent d'identifier facilement les éléments de menu auxquels ils sont associés.

 

2.4 - Choix de préfixes pour les autres contrôles

Pour les contrôles qui ne figurent pas ci-dessus, utilisez un préfixe standard, constitué de deux ou trois caractères. Utilisez plus de trois caractères uniquement si cela s’impose pour des raisons de clarté.

Pour les contrôles dérivés ou modifiés, par exemple, ajoutez des lettres aux préfixes ci-dessus afin d’éviter toute confusion quant au contrôle réellement utilisé. Pour les contrôles provenant de fournisseurs tiers, ajoutez au préfixe une abréviation en minuscules du nom du fournisseur. Par exemple, une instance d’un contrôle créé à l’aide du cadre 3D Visual Basic Édition Professionnelle peut être signalée par le préfixe fra3d afin d’éviter toute confusion quant au contrôle réellement utilisé.

Outre les objets, les constantes et les variables nécessitent également l’adoption de conventions d’affectation de noms standard. Cette section présente les conventions prises en charge par Visual  Basic que nous vous recommandons d’utiliser. Elle traite également des problèmes d’identification du type de données et de la portée.

Il est conseillé de toujours définir les variables avec la plus petite portée possible. Les variables globales (Public) peuvent entraîner des situations d’une complexité extrême et rendre la logique d’une application très difficile à comprendre. Elles peuvent également rendre la réutilisation et la gestion de votre code beaucoup plus délicates.

 

2.5 - Portée des variables

Dans Visual Basic, les variables peuvent être dotées de la portée suivante :

Portée de la Déclaration	Visible dans
De niveau procédure ‘Private’ dans la procédure, la Sub ou la Fonction	La procédure dans laquelle elle est déclarée
De niveau module ‘Private’ dans la section des déclarations d’une feuille ou d’un module de code (.frm, .bas)	Toute procédure dans la feuille ou le module de code
Déclarations Globale’Public’ dans la section des déclarations d’un module de code	Partout dans l’application

Dans une application Visual Basic, il est conseillé de n’utiliser des variables globales que s’il n’existe aucun autre moyen adéquat de partager des données entre des feuilles. Si vous devez utiliser des variables globales, il est recommandé de les déclarer toutes dans un seul module, regroupées par fonction. Attribuez au module un nom évocateur, indiquant son but, tel que Public.bas.

Il est conseillé d’écrire un code modulaire chaque fois que cela est possible. Par exemple, si votre application affiche une boîte de dialogue, placez la totalité des contrôles et du code nécessaires à la tâche prévue pour la boîte de dialogue dans une feuille unique. Vous pouvez ainsi organiser le code de l’application en composants significatifs et gagner du temps au moment de l’exécution.

À l’exception des variables globales (qui ne doivent pas être passées), les procédures et les fonctions ne doivent traiter que des objets qui leur sont transmis. Les variables globales utilisées dans des procédures doivent être indiquées dans la section des déclarations au début de la procédure. De plus, il est conseillé de transmettre des arguments aux procédures Sub et aux fonctions à l’aide du mot clé ByVal, à moins que vous ne soyez obligé de modifier explicitement la valeur de l’argument transmis.

 

2.6 - Préfixes de portée de variables

Plus le projet grandit, plus il est important de déterminer rapidement la portée des variables. Un préfixe de portée constitué d'une lettre précédant le préfixe de type permet d'arriver à ce résultat sans pour autant augmenter de manière significative la taille des noms de variables.

Portée	Préfixe	Exemple
Globale	g	gstrUserName
De niveau module	m	mblnCalcInProgress
Locale à une procédure	Aucun	dblVelocity

Une variable est dotée d'une portée globale si elle est déclarée comme Public dans un module standard ou un module de la feuille. Une variable est dotée d'une portée de niveau module si elle est déclarée comme Private, respectivement dans un module standard ou un module de feuille.

Note : Pour que cette technique vous apporte tous les avantages escomptés, il est absolument nécessaire d'être cohérent ; en effet, le vérificateur de syntaxe de Visual Basic ne s'arrêtera pas sur des variables de niveau module commençant par la lettre "p".

2.7 - Constantes

Le corps des noms de constantes doit être constitué de lettres de casse différente, chaque mot commençant par une lettre majuscule. Bien que les constantes Visual Basic standard ne comprennent pas d'informations sur le type de données et la portée, des préfixes tels que i, s, g et m peuvent s'avérer très utiles pour comprendre la valeur et la portée d'une constante. Pour les noms de constantes, respectez les mêmes conventions que pour les variables. Exemple :

mintUserListMax'Limite d'entrée maximale de la liste des utilisateurs (nombre entier, local à un module)

gstrNewLine'Caractère de saut de ligne (chaîne, globale à une application)

 

2.8 - Variables

Le fait de déclarer toutes les variables réduit le temps de programmation en limitant le nombre d'erreurs causées par des fautes de frappe (par exemple : aUserNameTmp, sUserNameTmp et sUserNameTemp). Dans l'onglet Éditeur de la boîte de dialogue Options, cochez l'option Requiert la déclaration de variables. L'instruction Option Explicit vous oblige à déclarer toutes les variables dans votre programme Visual Basic.

Les variables doivent comporter un préfixe indiquant leur type de données. Ce préfixe peut éventuellement être complété pour indiquer la portée de la variable, en particulier dans le cas de programmes volumineux.

 

2.9 - Type de données des variables

Utilisez les préfixes suivants pour indiquer le type de données d’une variable.

Type de données	Préfixe	Exemple
Boolean	bln	blnFound
Byte	byt	bytRasterData
Collection (Objet)	col	colWidgets
Currency	cur	curRevenue
Date (Time)	dtm	dtmStart
Double	dbl	dblTolerance
Error	err	errOrderNum
Integer	int	intQuantity
Long	lng	lngDistance
Object	obj	objCurrent
Single	sng	sngAverage
String	str	strFName
Type défini par l’utilisateur	udt	udtEmployee
Variant	vnt	vntCheckSum

 

2.10 - Noms de procédures et de variables descriptifs

Le corps d'un nom de variable ou de procédure doit comporter des lettres de casse différente et être aussi long que la description de sa fonction le demande. De plus, les noms de fonction doivent commencer par un verbe, tel que InitNameArray ou CloseDialog.

Pour les termes fréquemment utilisés ou particulièrement longs, nous vous recommandons d'utiliser des abréviations standard afin de réduire la longueur des noms. En règle générale, des noms de variables supérieurs à 32 caractères peuvent devenir difficiles à lire en affichage VGA.

Si vous utilisez des abréviations, vérifiez qu'elles sont cohérentes dans la totalité de l'application. Par exemple, l'utilisation de Cnt et Count indifféremment dans un projet risque de semer la confusion.

 

2.11 - Types définis par l'utilisateur

Dans un gros projet comportant de nombreux types définis par l'utilisateur, il est très utile d'attribuer à chacun d'entre eux un préfixe de trois caractères distincts. Si ces préfixes commencent par la lettre "u", ils seront aisément identifiables lorsque vous travaillerez avec un type défini par l'utilisateur. Par exemple, le préfixe "ucli" peut être utilisé pour les variables dotées du type défini par l'utilisateur Client.

 

 3- Tableaux et Boucles

3.1 - Structure d'un tableau.

On a souvent besoin de travailler sur un ensemble de données.

Un exemple : les températures moyennes des 12 mois de l'année.
On pourrait déclarer 12 variables identiques :
Dim Temp1, Temp2, Temp3, Temp4, … … …, Temp12 as Single

On dispose d'une structure de données appelée Tableau qui permet de conserver dans une seule "entité" plusieurs valeurs de même type.
Le nom du tableau est une variable qu'il est recommandé de préfixer par Tab.
Le nombre de valeurs de types identiques est à déclarer entre parenthèses.

Exemple de déclaration d’un tableau à une dimension :
Dim TabTemp(12) As Single

Numéro	1	2	3	4	5	...
Température	6	5.5	7	11.5	15	...

L'accés à la case numéro 3 se fait par TabTemp(3) qui vaut 7.

Exemple de déclaration d’un tableau à deux dimensions :
Dim TabMajMin(1 to 2,65 to 90) As String

Numéro	65	66	67	...	89	90
1	A	B	C	...	Y	Z
2	a	b	c	...	y	z

L'accés à la case qui contient le petit "c"se fait grâce à la syntaxe suivante : TabMajMin(2,67) qui vaut "c".

3.2 - Boucles.

La Boucle "For Next" :

Cette boucle est utilisée lorsqu’on connaît à l’avance le nombre de fois qu’elle sera parcourue.
Syntaxe :
For Compteur = Début To Fin [Step Incrément]

Instructions

[ ... Exit For]

[Instructions]

Next [Compteur]

Le test est effectué au début de la boucle.
La variable numérique Compteur est incrémentée à chaque fin de boucle du nombre indiqué par l’incrément. Si l’incrément n’est pas spécifié il est fixé à 1.
Si la valeur de Fin est inférieure à la valeur de Début l’incrément est négatif.
La valeur de Compteur peut être utilisée (par exemple pour numéroter le passage dans la boucle) mais ne doit pas être modifiée dans le corps de la boucle.

Exemple :

Pour remplir un tableau on le balaye avec une boucle For … To … Next (car le nombre de cases est connu à l'avance).

For i = 1 To 50

TabInitial(i) = 0 ‘ Initialisation de chaque case à 0

Next i

La Boucle "tant que" :

Syntaxe première version :
Do While Condition

Instructions

[... Exit Do]

[Instructions]

Loop

La condition est ici testée au début c'est à dire à l’entrée de la boucle.
Avec While (tant que) la boucle est répétée tant que la condition est vraie.
Si la condition n’est pas vraie au départ les instructions de la boucle ne sont pas exécutées.

Exemple :
Do While MotProposé <> MotDePasse

MotProposé = InputBox("Donnez votre mot de passe")

Loop

Cela présuppose MotProposé initialisé par une valeur autre que MotDePasse (par exemple la valeur par défaut "").

Syntaxe deuxième version :
Do

Instructions

[... Exit Do]

[Instructions]

Loop While Condition

La condition est alors testée à la fin de la boucle.
Avec While (tant que) la boucle est répétée tant que la condition est vraie.
Les instructions de la boucle sont donc exécutées au moins une fois.

Exemple :
Do

MotProposé = InputBox("Donnez votre mot de passe")

Loop While MotProposé <> MotDePasse

Cet exemple ne présuppose aucune initialisation de MotProposé.

Les boucles "Tant que", "Jusqu’à" :

Syntaxe :
Do

Instructions

[... Exit Do]

[Instructions]

Loop Until Condition

La condition est alors testée à la fin de la boucle.
Les instructions de la boucle sont donc exécutées au moins une fois.
Avec Until ("Jusqu'à") la boucle est répétée jusqu'à ce que la condition soit vraie.

Exemple :
Do

MotProposé = InputBox("Donnez votre mot de passe")

Loop Until MotProposé = MotDePasse

Cet exemple ne présuppose aucune initialisation de MotProposé.

Boucle For … Each … Next :

C’est une extension de la boucle For ... To … Next. Elle est utilisée pour parcourir les collections(ensembles).

Syntaxe :
For Each Elément In Ensemble

Instructions

[ ... Exit For]

[Instructions]

Next [Elément]

Ensemble est le plus souvent un tableau.

Exemple :
Dim TabHasard(100) As Integer
Dim Cellule As Integer
Dim Réponse As String
Randomize
For Each Cellule In TabHasard

Cellule = Rnd * 100 + 1

Next
For Each Cellule In TabHasard

Réponse = Réponse & Cellule & " "

Next
MsgBox (Réponse)

 4- Chaînes de charactères

Les données manipulées par un programme sont essentiellement des nombres (type numérique) ou du texte (chaîne de caractères).
Une variable chaîne de caractères se déclare avec le type String.

Exemple 1 :
Dim MotProposé As String
La variable contient alors une chaîne de longueur variable selon l'affectation qui suivra.

Exemple 2 :
Dim Lettre As String * 1
La variable contient alors une chaîne de longueur 1 c'est à dire un seul caractère.

Exemple 3 :
Dim Adresse As String * 30
La variable contient alors une chaîne de longueur 30. Si l'on n'affecte que 18 caractères dans une telle chaîne, le reste est rempli d'espaces. Si l'on affecte plus de 30 caractères le surplus est tronqué.

4.1 - Comparaison de chaînes de charactères.

Longueur d'une chaîne :
La longueur d'une chaîne est donnée par la fonction Len.
Exemple :
Phrase = "Visual Basic”
La fonction Len(Phrase) retournera la valeur 12.
Il est évident que si deux chaînes de caractères n'ont pas la même longueur elles sont différentes. Par contre deux chaînes de même longueur ne sont pas forcément identiques.

Comparaison binaire :
On compare deux chaînes par la fonction StrComp.
Elle renvoie la valeur numérique 0 si les deux chaînes sont rigoureusement identiques et la valeur numérique 1 si les chaînes diffèrent même par un seul octet.
Exemple :
Phrase1 = "Visual Basic."
Phrase2 = "Visual basic."
Phrase3 = " Visual Basic.”
La fonction StrComp(Phrase1,Phrase2) retournera la valeur …
La fonction StrComp(Phrase1,Phrase3) retournera la valeur …

Recherche d'une chaîne de caractères :
La fonction InStr permet de rechercher si une chaîne de caractères existe à l'intérieur d'une autre chaîne de caractères. Si c’est le cas, elle retourne la position de la première occurrence de la chaîne recherchée.
Syntaxe :
InStr(Chaîne1, Chaîne2)
Chaîne1 est la chaîne de caractères à traiter (sur laquelle porte la recherche).
Chaîne2 est la chaîne de caractères recherchée dans Chaîne1.
Exemple :
Chaîne1 = "Visual Basic et ses fonctions"
Chaîne2 = "Basic"
Chaîne3 = "Basics"
La fonction InStr(Chaîne1,Chaîne2) retournera la valeur 8
La fonction InStr(Chaîne1,Chaîne3) retournera la valeur 0.

Autres fonctions utiles :
La fonction Ucase met tout le texte en majuscules et permet de rechercher indépendamment une lettre minuscule ou majuscule.

La fonction Lcase met tout le texte en minuscules et permet…

La fonction Right donne la partie droite d'une chaîne de caractères. Le nombre de caractères de cette partie doit être précisé.
Exemple :
Chaîne = "Visual Basic et ses fonctions"
La fonction Right(Chaîne,5) retournera la valeur "tions"

La fonction Left donne la partie gauche d'une chaîne de caractères. Le nombre de caractères de cette partie doit être précisé.
Exemple :
Chaîne = "Visual Basic et ses fonctions"
La fonction Left(Chaîne,5) retournera la valeur "Visua"

La fonction Mid extrait une partie d'une chaîne de caractères.
Le nombre de caractères de cette partie doit être précisé ainsi que la position du premier caractère extrait.
Syntaxe :
Mid(Texte, Position, Nombre)
Texte est la chaîne de caractère à traiter.
Position est la position du caractère à partir duquel il faut extraire une sous-chaîne de caractères.
Nombre est le nombre de caractères à extraire.
Exemple :
Chaîne = "Visual Basic et ses fonctions"
La fonction Mid(Chaîne,8,5) retournera la valeur "Basic"
La fonction Mid(Chaîne,21) retournera la valeur "fonctions"

Exemple pour Rechercher un mot dans une chaîne de caractères :
Dim Chaine, Mot As String
Dim Position As Integer
Chaine = "Visual Basic et ses fonctions."
Mot = InputBox("Taper le mot à rechercher")
Position = InStr(Chaine, Mot)
If Position = 0 Then

MsgBox "Le mot '" & Mot & "'" & " n'a pas été introuvé !")

Else

MsgBox("Le mot '" & Mot & "'"&" a été trouvé à la position "_
& Position)

End If

Exemple pour Compter le nombre d'espaces dans une chaîne :
Dim Phrase, Caractère As String
Dim Compteur, Longueur, i As Integer
Phrase = InputBox("Tapez votre phrase")
Longueur = Len (Phrase)
For i = 1 To Longueur

Caractère = Mid(Phrase, i, 1)
If Caractère = " " Then Compteur = Compteur + 1

Next i
MsgBox("Cette phrase contient " & Compteur & " espaces.")

 5- Fonctions Utiles

La fonction Date donne la date système.
La fonction Time donne l'heure système.
La fonction Day() donne le numéro du jour dans le mois.
La fonction Month() donne le numéro du mois dans l'année.
La fonction Year() donne le numéro de l'année.
La fonction WeekDay() donne le numéro du jour dans la semaine sachant que le dimanche porte le numéro 1.
La fonction FormatDateTime(date [, constante vb]) donne Retourne une expression formatée sous forme de date ou d’heure. Où constante vb peut prendre les valeurs suivantes : [, vGeneralDate ou vbLongDate, vbShortDate, vbShortTime, …]

Get Déclare le nom, les arguments et le code formant le corps d'une procédure Property, qui lit la valeur d'une propriété.
Syntaxe:
[Public | Private | Friend] [Static] Property Get NomPropriété [(arglist)] [As type]
[instructions]
[Exit Property]
[instructions]
End Property

Let : Déclare le nom, les arguments et le code formant le corps d'une procédure Property Let, qui attribue une valeur à une propriété.
Syntaxe
[Public | Private | Friend] [Static] Property Let name ([arglist,] value)
[instructions]
[Exit Property]
[instructions]
End Property

Exemple :
Private dblBalance As Double

Public Property Get Balance() As Double

Balance = dblBalance

End Property

Property Let Balance(dblNewBalance As Double)

dblBalance = dblNewBalance

End Property

CallByName : cette fonction permet d’obtenir ou de définir une propriété ou d’invoquer une méthode pendant l’exécution.
Syntaxe :
CallByName(Objet, NomProcédure,CallType)
Où :
- Objet(objet variant) est le nom de l’objet sur lequel on souhaite exécuter la fonction CallByName.
- NomProcédure (variant) désigne le nom de la propriété ou de la méthode de l’objet .
- CallType est une constante qui représente le type de procédure appelée(vbGet, VbLet,vbMethod).

Exemple :
- Obtenir le contenu de la propriété NomGroupe de l’objet objGroupe :
Resulat = CallByName(objgroupe, “NomGroupe”, VbGet)
- Définir la propriété NomGroupe de l’objet objGroupe :
CallByName(objgroupe, ObjField.Name, VbLet)
- Exécuter la méthode "InitialisationObj" de l’objet objGroupe :
CallByName(objgroupe, “InitialisationObj”, Vbmethod)

 

 6- Procédures et Fonctions

Les procédures :

Une procédure est un ensemble d'instructions qui traite une tâche donnée.
Elle débute par le mot réservé Sub et se termine par End Sub.

Exemple de procédure événementielle :
Private Sub cmdQuitter_Click
End
End Sub

Si un bloc d'instructions doit être utilisé à plusieurs endroits (par exemple dans plusieurs procédures événementielles) il est préférable d'en faire une procédure publique qui sera pourra être appelée dans n’importe quel autre sous-programme du module.

Exemple de procédure publique :
Public Sub SaisieNote()
Do
Note = InputBox("Tapez une note")
Loop Until Note>=0 And Note<=20
End Sub
Pour utiliser cette procédure il suffira de l'appeler par son nom : SaisieNote

Les fonctions :

Une fonction débute par le mot réservé Function et se termine par End Function.
Elle a un type et peut retourner une valeur contenue dans le nom même de la fonction. Cette valeur pourra être utilisée par la suite dans une autre expression.

Exemple de fonction :
Public Function Carré(x) As Single
Carré = x * x
End Function
Par exemple Carré(7) retournera la valeur 49.

Les procédures Property :

Elles servent à définir les propriétés d’un objet par exemple dans un module, dans une classe ou dans une feuille. Elles sont délimitée par les mots clés Property et End Property.

Exemple de propriété :
Public Property Let Nom(ByVal parametre As String)
mvarNom = parametre
End Property
Remarques :
ByVal Indique que l'argument est passé par valeur.
ByRef(valeur par défaut). Indique que l'argument est passé par référence

1 - Créer un programme standard (sans DLL).

Ajouter ou retrancher un nombre à un autre (deux fonctions <> deux boutons)

Créer un nouveau projet VB5 "EXE Standard".

Ajouter dans la form (feuille) trois TextBox : Text1, Text2, Text3
et deux boutons : Command1 et Command2 (un pour chaque fonction).

Puis saisissez le code suivant :

Private Sub Command1_Click()
Text3.Text = CLng(Text1.Text) + CLng(Text2.Text)
End Sub

Private Sub Command2_Click()
Text3.Text = CLng(Text1.Text) - CLng(Text2.Text)
End Sub

Exemple1 : Le programme standard sans DLL.

Testez le programme (rien d'extraordinaire, c'est une calculatrice deux fonctions)

2 - Créer un programme standard et une DLL.

Dans le même projet ajouter un nouveau projet ActiveX DLL. (Fichier - Ajouter projet).
Dans le projet DLL vous trouverez une Class destinée à recevoir le code des fonctions, ouvrer la Class et saisissez le code suivant :

Public Function Ajouter(Op1 As Long, op2 As Long) As Long
Ajouter = Op1 + op2
End Function

Public Function Oter(Op1 As Long, op2 As Long) As Long
Oter = Op1 - op2
End Function

Exemple 1 : Le code de la DLL.

Nous retrouvons ici le source de nos deux fonctions Ajouter et Oter, ces fonctions sont déclarés "public" afin que les programmes appelants puissent les "voir".
Si nous les avions déclarés "private", elles ne serait pas visible depuis les programmes appelants, se sont alors des fonctions internes à la DLL qui sont par exemple utilisées par les fonctions "public"

3 - Le code de notre programme appelant.

Remplacer le code du premier programme par celui-ci

Puis saisissez le code suivant :

Private MesFonctions As Class1

Private Sub Command1_Click()
Set MesFonctions = New Class1
Text3.Text = MesFonctions.ajouter(CLng(Text1.Text), CLng(Text2.Text))
Set MesFonctions = Nothing
End Sub

Private Sub Command2_Click()
Set MesFonctions = New Class1
Text3.Text = MesFonctions.oter(CLng(Text1.Text), CLng(Text2.Text))
Set MesFonctions = Nothing
End Sub

Depuis votre projet EXE aller dans le Menu Projet-Références sélectionner (cocher) votre DLL dans la liste pour la référencer dans votre projet (noter au passage que de nombreuse DLL sont ici accessible comme Microsoft Excel, Word, DAO pour les accés bases de données ...).

Si votre Dll n'apparait pas dans la liste compilez-la (file-make MaDll.dll)

Lancez le programme, le resultat est le même que dans l'exemple initial, mais les fonctions sont en DLL, elle sont donc réutilisable à souhait et cela apporte des gains enorme dans les développements (ecrire une fois, utiliser dans plusieurs programmes).

Autre avantage et de taille :

Set MesFonctions = Nothing

Cette instruction libère la mémoire réservée par la DLL ainsi vous verrez la taille de votre exécutable fondre mais aussi la place mémoire occupée par le programme.

Ainsi lorsque je fixe un valeur à MaPropriété, je peux ajouter tous les testes possibles, mais je peux aussi retirer la possibilité de mettre à jour MaPropriété (en retirant Public Property Let MaPropriété(valeur as String).....End Property)

1 - Une DLL C simple avec Visual C++ 5.

Avec VC++5.0 créer un nouveau projet Win32 Dynamic-Link Library.
Créer un nouveau fichier de définition (.def) :

LIBRARY MaDLL


EXPORTS
AjouteDouble @1
OteDouble @2

Exemple1 : Le fichier .DEF.

AjouteDouble et OteDouble sont les deux fonctions que nous allons retrouver dans notre source C. Pour ajouter de nouvelle fonctions, les inscrirent dans le fichier .def et augmenter le numéro de fonction : DiviseDouble @3

Puis créer un nouveau fichier contenant les fonctions de la DLL (.c) :

#include <windows.h>
#include <ole2.h>

double _stdcall AjouteDouble(double a, double b)
{
return (a + b);
}

double _stdcall OteDouble(double a, double b)
{
return (a - b);
}

Exemple 1 : Le source.

Nous retrouvons ici le source de nos deux fonctions AjouteDouble et OteDouble et le code qui leurs est associés.

Enfin construire la DLL (Rebuild All).
La DLL devrat enfin être copiée dans le répertoire system de Windows (c:\WinNt\System32 pour NT)

2 - Utilisation de la DLL dans VB 5.

Créer un nouveau projet VB5 "EXE Standard".

Ajouter dans la form (feuille) trois TextBox : Text1, Text2, Text3
et deux boutons : Command1 et Command2 (un pour chaque fonction).

Puis saisissez le code suivant :

Option Explicit

' Déclaration de la fonction externe AjouteDouble
Private Declare Function AjouteDouble _
Lib "MaDLL.dll" ( _
ByVal a as double, _
ByVal a as double _
) as double

' Déclaration de la fonction externe OteDouble
Private Declare Function OteDouble _
Lib "MaDLL.dll" ( _
ByVal a as double, _
ByVal a as double _
) as double

___________________________________________________________________________

Private Sub Command1_Click()

' Text3 contient la valeur de retour (le resultat) de la fonction AjouteDouble
' alors que Text1 et Text2 sont les deux paramètres de la fonction
' La fonction retourne un double, pour cette raison, nous devons le convertir en texte (Str)
' Les paramètres de la fonction C sont des double, nous devons donc convertir Text1 et Text2 en double (Clng)

Text3.text = Str(AjouteDouble(Clng(Text1.Text), Clng(Text2.Text)))
End Sub

__________________________________________________________________________

Private Sub Command2_Click()

' Text3 contient la valeur de retour (le resultat) de la fonction OteDouble
' alors que Text1 et Text2 sont les deux paramètres de la fonction
' La fonction retourne un double, pour cette raison, nous devons le convertir en texte (Str)
' Les paramètres de la fonction C sont des double, nous devons donc convertir Text1 et Text2 en double (Clng)

Text3.text = Str(OteDouble(Clng(Text1.Text), Clng(Text2.Text)))
End Sub