[PDF] Introduction au développement des application avec Visual Basic | Formation informatique

(1)

Chapitre 3 Nouveautés et concepts utiles du langage et de l’environnement

57

Figure 3.24 La conversion s’est bien déroulée.

Figure 3.25 Modification du Framework cible.

Innovations du langage Visual Basic 2010

De nombreuses améliorations ont été apportées au langage Visual Basic 2010. Nous allons passer en revue les plus importantes dans cette section.

Continuation de ligne implicite

Jusqu’à la version 2010 de Visual Basic, les lignes trop longues devaient être prolongées par l’intermédiaire du caractère de continuation "_".

(2)

58

Visual Basic 2010

Désormais, il est tout à fait possible d’écrire quelque chose comme ceci sans provoquer d’erreur de syntaxe :

Private Sub Button1_Click(

ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles Button1.Click End Sub

Implémentation automatique des propriétés

Pour définir une propriété à l’aide de code Visual Basic 2008 ou inférieur, vous deviez utiliser quelque chose comme ceci :

Private _nombre As Integer = 0 Public Property MonNombre As Integer ‘ Récupération de "_nombre" Get Return _nombre End Get ‘ Affectation à "_nombre" Set _nombre = valeur End Set End Property

Désormais, avec Visual Basic 2010, la syntaxe est bien plus simple :

Property MonNombre as Integer

Pour affecter une valeur par défaut à une propriété, vous utiliserez la syntaxe suivante :

Property Ville As String = "Paris"

Pour instancier un objet, vous utiliserez la syntaxe suivante :

Property Villes As New List(Of String)

Initialiseurs de collections

En Visual Basic 9, l’instruction With simplifiait l’accès aux différents membres d’un objet (collection, tableau). À titre d’exemple, le code ci-après crée un tableau de capitales et l’initialise avec quatre lignes de données :

Partial Class pays Public Nom As String Public Pays As String

(3)

59

End Class

Dim Capitales = New Ville() { _ New Ville With { _

.Nom = "Paris", _ .Pays = "France"}, _ New Ville With { _ .Nom = "Londres", _ .Pays = "Royaume-Uni"}, _ New Ville With { _

.Nom = "Madrid", _ .Pays = "Espagne"}, _ New Ville With { _ .Nom = "Washington", _ .Pays = "Etats-Unis"} _ }

Grâce à l’instruction With, l’écriture des éléments "Ville.Nom" et "Ville.Pays" est simplifiée en ".Nom" et ".Pays".

L’initialisation d’objets fonctionne également pour les objets créés dans les classes du projet.

À titre d’exemple, nous allons créer un nouveau projet de type Application Windows Forms. Nous ajoutons une nouvelle classe dans ce projet que nous nommons Ville. Nous ajoutons deux propriétés à la classe Ville que nous nommons Nom et Pays :

Public Class Ville

Private intNom As String Public Property Nom() As String Get

Return intNom End Get

Set(ByVal value As String) intNom = value

End Set End Property

Private intPays As String Public Property Pays() As String Get

Return intPays End Get

(4)

60

intPays = value End Set

End Property End Class

Pour créer une propriété dans une classe, il suffit de taper Property, d’appuyer sur la touche Tab du clavier et de changer les valeurs à la suite des mots Private

et Property.

Retournons au code de la classe principale du projet.

Pour créer et manipuler un objet de classe Ville en Visual Basic 9, vous faisiez quelque chose comme ceci :

Dim Capitale As New Ville Capitale.Nom = "Paris" Capitale.Pays = "France"

En Visual Basic 2010, le code deviendra :

Dim Capitale = New Ville With _ {.Nom = "Paris", .Pays = "France"}

Il n’est pas nécessaire d’initialiser toutes les propriétés dans les accolades : elles pourront être définies dans la suite du code.

En Visual Basic 10, l’initialisation de collections est encore plus simple, grâce au mot-clé

From.

Dim capitales = New List (Of Capitale) From {

New Capitale With {.Nom = "Paris", .Pays = "France"}, New Capitale With {.Nom = "Londres", .Pays = "Royaume-Uni"}, New Capitale With {.Nom = "Madrid", .Pays = "Espagne"}, New Capitale With {.Nom = "Washington", .Pays = "Etats-Unis"} }

Syntaxe simplifiée pour déclarer des tableaux

L’inférence de type simplifie grandement la déclaration des tableaux :

Dim tab1 = {12, 25, 19} Dim tab2 = {12.2, 6.5}

Info

(5)

61

Dim tab3 = {1, tab2, "texte"}

Dim tab4 = {"texte 1", "texte 2", "texte 3"}

Console.WriteLine("Type de tab1 : " & tab1.ToString()) Console.WriteLine("Type de tab2 : " & tab2.ToString()) Console.WriteLine("Type de tab3 : " & tab3.ToString()) Console.WriteLine("Type de tab4 : " & tab4.ToString())

Voici l’affichage dans la fenêtre Sortie

Type de tab1 : System.Int32[] Type de tab2 : System.Double[] Type de tab3 : System.Object[] Type de tab4 : System.String[]

Cette syntaxe s’étend également aux tableaux multidimensionnels.

Expressions Lambda multilignes et sous-routine

Une expression Lambda est une fonction sans nom qui renvoie une valeur unique. À titre d’exemple, l’expression Lambda suivante consiste en une fonction qui admet un argument entier et qui renvoie un calcul réel basé sur cet argument :

Dim monExpressionLambda = Function(nombre As Integer) (nombre + 7) / 3

Pour appeler l’expression Lambda, il suffit de préciser son nom et son argument. Par exemple :

Console.WriteLine(monExpressionLambda(12))

Visual Basic 2010 permet désormais d’écrire une expression Lambda sur plusieurs lignes. Considérez le code suivant :

Dim monExpressionLambda = Function(nombre As Integer) As String If (nombre > 10) Then

Return "est supérieur à 10" Else

Return "est inférieur ou égal à 10" End If

End Function

Dans cet exemple, le code de la fonction lambda repose sur une structure If Then Else. Si nécessaire, il peut être bien plus complexe et compter autant de lignes que nécessaires.

(6)

62

Cette possibilité n’est pas la seule nouveauté liée aux expressions Lambda : désormais, le compilateur de Visual Basic 2010 autorise également les expressions Lambda de types Sub. Le code suivant est donc tout à fait licite :

Dim monExpressionLambda = Sub(nombre As Integer) If (nombre > 10) Then TextBox1.Text = "Argument > 10" Else TextBox1.Text = "Argument <= 10" End If End Sub

Il est également possible de définir une expression Lambda de type Sub sur une seule ligne de code, comme dans le code suivant :

Dim monExpressionLambda = Sub(nombre As Integer) TextBox1.Text = nombre monExpressionLambda(12)

Dans cet exemple, l’appel de l’expression Lambda provoquera l’affichage de l’argument dans la zone de texte TextBox1.

Covariance et contravariance génériques

Dans les versions antérieures de Visual Basic, les génériques se comportaient de façon invariante en ce qui concerne le sous-typage. Les conversions entre les types génériques présentant différents arguments de types n’étaient donc pas autorisées.

Considérez le code suivant :

Dim textboxCollection As IEnumerable(Of TextBox) = New List(Of TextBox) From

„ {New TextBox}

Dim ctrlCollection As IEnumerable(Of Control) = textboxCollection

Dans Visual Basic 2008, ce code produit une erreur :

IEnumerable(Of TextBox) ne peut pas être converti en IEnumerable (Of Control)

Et pourtant, une valeur de type TextBox peut tout à fait être convertie en un contrôle ! De même, le code suivant n’est pas autorisé dans Visual Basic 2008 :

Dim tbCollection As IList(Of TextBox) = New List(Of TextBox) From {New TextBox} Dim ctrlCollection As IList(Of Control) = tbCollection

Il produit une erreur de type InvalidCastException, car la deuxième ligne convertit un

IList(Of TextBox) en un IList(Of Control).

Si vous tentez d’écrire les deux codes précédents dans un programme Visual Basic 2010 qui cible le Framework .NET 4, le premier code sera autorisé mais pas le second. En effet les

(7)

63

IEnumerable(Of T) sont des interfaces "de sortie" alors que les IList(Of T) sont des inter-faces "d’entrée-sortie". Dans les premiers, il n’est possible que de faire sortir des contrôles alors que dans les seconds, il est possible de faire sortir, mais aussi entrer des contrôles. Dans Visual Studio 2010, l’infrastructure a été réécrite de la façon suivante :

Interface IEnumerable(Of Out T) …

End Interface

Interface IList(Of T) …

End Interface

Le mot Out dans IEnumerable(Of Out T) indique que si une méthode dans IEnumerable

mentionne T, elle ne le fera qu’en sortie. Il est donc désormais possible d’effectuer un cast d’un IEnumerable(Of dérivé) en un IEnumerable(Of base) sans générer d’excep-tion InvalidCastException. Cette nouvelle fonctionnalité porte le nom de covariance générique.

Dans le même ordre d’idées, il est possible de retreindre "en entrée" un IComparer :

Interface IComparer(Of In T) …

End Interface

Il est donc possible de considérer un IComparer(Of Object) comme un IComparer(Of String) ! En effet, si un IComparer(Of T) peut comparer deux objets quelconques de type

Object, il peut également comparer deux objets de type String. Cette nouvelle fonction-nalité porte le nom de contravariance générique.

Prise en charge d’équivalence de type

Avec Visual Basic 2010, vous pouvez désormais déployer une application dotée d’informa-tions de type incorporé (et non de type importé) à partir d’un assembly PIA (Primary

Inte-rop Assembly). En utilisant des informations de type incorporé, l’application peut utiliser les types d’un runtime sans nécessiter de référence à l’assembly de runtime. Si différentes versions de l’assembly de runtime sont publiées, l’application peut fonctionner avec les différentes versions sans avoir à être recompilée.

Prise en charge dynamique

Visual Basic crée une liaison avec les objets de langages dynamique tels que IronPython et IronRuby. Cette liaison se fait à l’aide de l’interface IDynamicMetaObjectProvider. Les classes DynamicObject et ExpandoObject constituent des exemples de classes qui implé-mentent l’interface IDynamicMetaObjectProvider.

(8)

64

Si un appel à liaison tardive est effectué vers un objet qui implémente l’interface IDynamic-MetaObjectProvider, Visual Basic utilise cette interface pour créer une liaison avec l’objet dynamique.

Si un appel à liaison tardive est effectué vers un objet qui n’implémente pas l’interface

IDynamicMetaObjectProvider, ou si l’appel à l’interface IDynamicMetaObjectProvider

échoue, Visual Basic crée une liaison avec l’objet à l’aide des fonctions de liaison tardive de l’exécution Visual Basic.

Vous en saurez plus à ce sujet en consultant le site CodePlex, à l’adresse http://dlr.code-plex.com/.

Programmation parallèle

Aujourd’hui, le microprocesseur de la plupart des ordinateurs personnels et des stations de travail est doté de 2 ou 4 cœurs qui permettent à plusieurs threads de s’exécuter simulta-nément. Pour tirer parti de ces processeurs, vous pouvez paralléliser le code Visual Basic. Ainsi, le travail effectué par vos applications est distribué sur plusieurs cœurs et l’exécution du code est bien plus performante. N’ayez crainte, le code reste compatible avec les micro-processeurs dotés d’un seul cœur !

Visual Studio 2010 et le .NET Framework 4 améliorent grandement la prise en charge de la programmation parallèle en fournissant de nouvelles bibliothèques de classes. Par leur intermédiaire, il est "assez simple" d’écrire un code parallèle efficace. En particulier, la classe Parallel permet de répartir l’exécution de boucles For et For Each sur les différents cœurs disponibles. Vous pouvez également utiliser des tâches pour affecter des blocs de code à des cœurs différents.

Vous en saurez plus à ce sujet en consultant le Chapitre 13.

Concepts avancés issus des versions précédentes

de Visual Basic

Cette section regroupe quelques innovations et concepts apparus dans les versions précé-dentes de Visual Basic (en particulier dans Visual Basic 2008) qu’il est bon d’avoir en tête pour utiliser Visual Basic 2010 aussi efficacement que possible.

Inférence de type

Lorsque l’on parle de Visual Basic, on le qualifie souvent de "langage fortement typé". Cela signifie que les types de données utilisés décrivent de façon explicite les données

(9)

65

manipulées. À titre d’exemple, le langage PHP n’est pas fortement typé. Les instructions PHP suivantes sont ainsi tout à fait correctes :

$maVariable = "mon texte"; // Un texte est affecté à la variable maVariable $maVariable = 5; // Puis la valeur entière 5 est affectée à cette même variable

Visual Basic n’autorise pas ce genre de largesse. Par contre, le compilateur de Visual Basic 2010 est en mesure de définir une variable typée de façon implicite, en examinant l’expres-sion qui sert à l’initialiser.

Ainsi, par exemple, ces deux instructions sont équivalentes :

Dim monEntier = 3276

Dim monEntier as Integer = 3276

De même, les deux instructions suivantes sont équivalentes :

Dim nom = "Michel"

Dim nom As String = "Michel"

L’inférence de type est initialisée par défaut. Si vous voulez la désactiver, utilisez l’instruction Option Infer Off.

Notez que l’inférence de type est également applicable aux tableaux. Par exemple, pour définir et initialiser un tableau contenant des Integer, vous écrirez quelque chose comme ceci :

Dim Tableau = New Integer() {12, 25, 2}

Comme le montre la Figure 3.26, le compilateur affecte automatiquement à l’objet tableau le type tableau d’entiers.

Figure 3.26

L’objet tableau a pour type tableau d’Integer.

Enfin, l’inférence de type peut être utilisée sur un retour d’appel de méthode (voir Figure 3.27).

Figure 3.27

L’inférence de type va bien plus loin que la simple recon-naissance du type

d’une donnée.

(10)

66

Le compilateur a vu que le retour de la fonction GetProcesses() était un tableau de Process. Ce type a donc été affecté à la variable mesprocesses.

Initialiseurs d’objets

L’instruction With simplifie l’accès aux différents membres d’un objet (collection, tableau). À titre d’exemple, le code ci-après crée un tableau de capitales et l’initialise avec quatre lignes de données :

Partial Class pays Public Nom As String Public Pays As String End Class

Dim Capitales = New Ville() { _ New Ville With { _

.Nom = "Paris", _ .Pays = "France"}, _ New Ville With { _ .Nom = "Londres", _ .Pays = "Royaume-Uni"}, _ New Ville With { _

.Nom = "Madrid", _ .Pays = "Espagne"}, _ New Ville With { _ .Nom = "Washington", _ .Pays = "Etats-Unis"} _ }

Grâce à l’instruction With, l’écriture des éléments "Ville.Nom" et "Ville.Pays" est simplifiée en ".Nom" et ".Pays".

L’initialisation d’objets fonctionne également pour les objets créés dans les classes du projet.

À titre d’exemple, nous allons créer un nouveau projet de type Application Windows Forms. Nous ajoutons une nouvelle classe dans ce projet que nous nommons Ville. Nous ajoutons deux propriétés à la classe Ville que nous nommons Nom et Pays :

Public Class Ville

Private intNom As String Public Property Nom() As String Get

Return intNom End Get

(11)

67

Set(ByVal value As String) intNom = value

End Set End Property

Private intPays As String Public Property Pays() As String Get

Return intPays End Get

Set(ByVal value As String) intPays = value End Set

End Property End Class

Pour créer une propriété dans une classe, il suffit de taper Property, d’appuyer sur la touche Tab du clavier et de changer les valeurs à la suite des mots Private

et Property.

Retournons au code de la classe principale du projet.

Pour créer et manipuler un objet de classe Ville en Visual Basic 2008, vous faisiez quelque chose comme ceci :

Dim Capitale As New Ville Capitale.Nom = "Paris" Capitale.Pays = "France"

En Visual Basic 2010, le code deviendra :

Dim Capitale = New Ville With _ {.Nom = "Paris", .Pays = "France"}

Il n’est pas nécessaire d’initialiser toutes les propriétés dans les accolades : elles pourront être définies dans la suite du code.

Types anonymes

Les déclarations d’objets contenant un ou plusieurs membres peuvent se faire sans spécifier leur type. Dans ce cas, un type anonyme, basé sur les types et noms des membres est créé.

Info

(12)

68

Considérez le code suivant :

Dim Employes = New With {.Nom = "Pierre Ledoyen", .Age = 27}

Étant donné qu’aucun type n’est précisé lors de la création de l’objet Employes, ce dernier sera de type anonyme. Il héritera de la classe Object et possèdera les propriétés spécifiées dans l’accolade (ici Nom et Age).

Dès qu’un nouveau type anonyme a été défini, vous pouvez utiliser l’intellisense pour accéder à ses propriétés (voir Figure 3.28).

Figure 3.28 Intellisense est actif.

Les types anonymes ont un défaut : il est impossible d’y faire référence en tant que types, puisqu’ils n’ont pas de nom.

Méthodes d’extension

Visual Basic 2010 permet d’étendre une classe, même si vous ne possédez pas le code de cette classe. Voyons comment procéder sur un exemple concret. Nous allons ajouter une méthode à la classe Ville (voir la section intitulée "Initialiseurs d’objets") pour connaître le nombre d’habitants de la ville spécifiée.

Ajoutez un module à la solution avec la commande Ajouter un module dans le menu Projet. Donnez le nom MethExtensions.vb à ce module. Définissez enfin la fonction Population()

comme suit :

Public Function Population(ByVal uneVille As Ville) As Integer Select Case uneVille.Nom

Case "Paris" Return 2153600 Case "Madrid" Return 3162304 Case Else Return 0 End Select End Function Info

(13)

69

Pour transformer ce code en une méthode d’extension de la classe Ville, il suffit de faire précéder l’instruction Function par <Extension()>. Comme vous pouvez le voir à la Figure 3.29, le terme Extension ne convient pas au compilateur.

Figure 3.29

La fonction a été transformée en une extension de la classe Ville.

Pointez le terme souligné. Un point d’exclamation apparaît. Cliquez dessus et choisis-sez Modifiez ‘Extension’ en ‘Runtime.CompilerServices.Extension’ dans la liste (voir Figure 3.30) pour ajouter le NameSpace adéquat.

Figure 3.30

Définition in extenso du terme Extension.

Cette fois-ci, la fonction est réellement devenue une extension de la classe Ville.

Retournez dans le code du formulaire. La méthode Population est maintenant accessible par Intellisense (voir Figure 3.31).

Figure 3.31

La méthode Population

est bien accessible.

Génériques

Les types génériques permettent de créer des classes, des procédures, des structures, des interfaces et des délégués qui manipulent des données dont le type n’est pas défini au départ.

(14)

70

Pour comprendre le fonctionnement des génériques, examinez le code ci-après :

Private Sub echange(Of TypeDeDonnee)(ByRef donnee1 As TypeDeDonnee,

„ ByRef donnee2 As TypeDeDonnee)

Dim tampon As TypeDeDonnee tampon = donnee2

donnee2 = donnee1 donnee1 = tampon

Console.Write("Après echange, donnee1 = ") Console.Write(donnee1) Console.Write(" et donnee2 = ") Console.WriteLine(donnee2) End Sub Sub Main() Dim int1 = 1 Dim int2 = 2 Dim st1 = "premier" Dim st2 = "deuxieme"

echange(Of Integer)(Int1, int2) echange(Of String)(st1, st2) Console.Read()

End Sub

La procédure echange est définie de façon générique (Of TypeDeDonnee), et deux para-mètres génériques lui sont passés :

Private Sub echange(Of TypeDeDonnee)(ByRef donnee1 As TypeDeDonnee,

„ ByRef donnee2 As TypeDeDonnee)

Dans cette procédure, la variable générique tampon va permettre d’échanger les deux données passées en entrée :

Dim tampon As TypeDeDonnee

Une fois l’échange effectué, les deux données s’affichent dans la fenêtre de texte :

Console.Write("Après echange, donnee1 = ") Console.Write(donnee1)

Console.Write(" et donnee2 = ") Console.WriteLine(donnee2)

La procédure principale appelle successivement la procédure echange en lui transmettant deux valeurs entières puis deux valeurs chaînes. Remarquez comment le type des variables est spécifié lors de l’appel :

echange(Of Integer)(Int1, int2) echange(Of String)(st1, st2)

(15)

71

En utilisant une technique similaire, vous pouvez définir des classes, des structures, des interfaces et des délégués génériques.

Les génériques offrent plusieurs avantages :

∑

ils sont fortement typés ;

∑

ils sont compatibles avec la fonctionnalité Intellisense de Visual Studio ;

∑

à l’exécution, ils sont plus rapides que des Objects ;

∑

les éventuelles erreurs sont détectées à la compilation et non à l’exécution.

Types Valeur Nullable

Le type générique Nullable permet d’étendre les types valeur en vue d’accepter une valeur traditionnelle ou une valeur Null. Considérez le bloc de code suivant :

Module Module1

Dim monInteger As Nullable(Of Integer) Sub Main()

monInteger = Nothing

Console.Write("monInteger.HasValue avant initialisation: ") Console.WriteLine(monInteger.HasValue)

monInteger = 57

Console.Write("monInteger.HasValue après initialisation: ") Console.WriteLine(monInteger.HasValue)

Console.Read() End Sub

End Module

La variable monInteger est déclarée de type Integer Nullable :

Dim monInteger As Nullable(Of Integer)

Si la valeur Nothing est affectée à la variable monInteger, la propriété HasValue renverra la valeur False. Si, par contre, une valeur non nulle est affectée à cette variable, la propriété

HasValue renverra la valeur True (voir Figure 3.32).

Figure 3.32

Illustration de type Valeur

(16)

72

Dans Visual Basic 2010, trois syntaxes permettent de déclarer un type Nullable :

Dim monInteger? As Integer Dim monInteger As Integer?

Dim monInteger As Nullable(Of Integer)

Vous utiliserez :

∑

la propriété HasValue pour savoir si une variable de type Nullable n’est pas affectée ;

∑

la propriété Value pour récupérer la valeur de la variable Nullable.

Opérateur IIf

L’opérateur IIf (Immediate If) affecte une valeur ou une autre en fonction du résultat d’un test :

Dim Variable As Type = IIf(Condition, Valeur si vrai, Valeur si faux)

Par exemple, l’instruction suivante affecte la valeur 5 à la variable Resultat si a est supé-rieur à 0 et la valeur 6 dans le cas contraire :

Dim Resultat as Integer = IIf(a > 0, 5, 6)

Dans Visual Basic 2010, vous pouvez indifféremment utiliser les opérateurs If et IIf pour parvenir au même résultat. L’instruction précédente devient donc :

Dim Resultat as Integer = If(a > 0, 5, 6)

En combinant cette nouvelle écriture avec l’inférence de type, l’expression est encore simplifiée :

Dim Resultat = IIf(a > 0, 5, 6)

Support étendu du code XML

Visual Basic 2010 vous permet de définir des objets XML en exprimant littéralement leur contenu dans le code :

Dim livres = <Livres>

<livre Nom="Le programmeur Visual Basic 2010"> <Auteur>Michel Martin</Auteur> <Editeur>CampusPress</Editeur> </livre> <Livre Nom="Ajax et PHP"> <Auteur>Ralph Steyer</Auteur> <Editeur>CampusPress</Editeur> </Livre> </Livres>

(17)

73

Comme vous pouvez le remarquer, aucun caractère terminateur de ligne n’est nécessaire lorsque vous définissez un objet contenant du code XML littéral.

Quelques termes de vocabulaire qu’il est bon d’avoir à l’esprit avant de poursuivre la lecture sur le code XML :

∑

Les marqueurs XML sont appelés éléments ou nœuds.

∑

La racine d’un objet XML est l’élément le plus extérieur (<Livres> dans l’exemple précédent).

∑

Un attribut est une valeur incorporée à l’intérieur d’un élément (dans l’exemple précé-dent, Nom dans l’élément <Livre>).

∑

Les propriétés d’axe XML permettent d’accéder aux nœuds enfants, aux nœuds descendants et aux attributs des littéraux XML :

– l’axe enfant nomLittéral.<NomElément> donne accès à tous les enfants NomElément

du littéral XML nomLittéral ;

– l’axe d’attribut nomLittéral.@NomAttribut donne accès aux attributs NomAttribut

du littéral XML nomLittéral ;

– l’axe descendant nomLittéral…<NomElément> donne accès aux descendants <Nom-Elément> du littéral XML nomLittéral, et ce, quel que soit leur niveau d’imbrication dans la structure XML :

– l’indexeur d’extension nomLittéral…<NomElément>(i) donne l’élément de rang i du descendant <NomElément> du littéral nomLittéral ;

– la valeur nomLittéral…<NomElément>.Value donne la valeur String du premier élément <NomElément> du littéral XML nomLittéral.

Intellisense a été étendu pour fonctionner dans les éléments XML.

Délégués non stricts

Pour ceux qui ne seraient pas encore familiers avec les délégués, nous allons commencer par introduire ces entités. Un délégué est un élément qui fait référence à une méthode (un pointeur de méthode en quelque sorte). Une fois initialisé, il suffit de l’invoquer pour appeler la méthode afférente.

Voici un exemple de création et d’utilisation d’un délégué :

Module Module1

Delegate Sub monDelegue()

(18)

74

Sub MaProcedure()

System.Console.WriteLine("Ce texte est affiché par la Sub MaProcedure") System.Console.ReadLine()

End Sub Sub Main()

Dim Mondelegue As New monDelegue(AddressOf MaProcedure) Mondelegue()

End Sub End Module

La première instruction crée le délégué MonDelegue :

Delegate Sub monDelegue()

Le bloc d’instructions suivant définit la procédure MaProcedure() sur laquelle pointera le délégué. Cette procédure se contente d’afficher un texte en mode console et d’attendre l’appui sur la touche Entrée du clavier.

Sub MaProcedure()

System.Console.WriteLine("Ce texte est affiché par la Sub MaProcedure") System.Console.ReadLine()

End Sub

La procédure principale initialise le délégué avec l’adresse de la procedure :

Dim Mondelegue As New monDelegue(AddressOf MaProcedure)

Puis elle exécute la procédure via le délégué :

Mondelegue()

De façon native, Visual Basic utilise des délégués pour lier les événements aux méthodes de traitement des objets. Ainsi par exemple, lorsque vous double-cliquez sur un bouton dans l’interface de conception de Visual Studio, un gestionnaire d’événements est automati-quement créé et associé à l’événement clic par l’intermédiaire d’un délégué.

Dans Visual Basic 2010, les paramètres transmis à une méthode événementielle pointée par un délégué peuvent être omis. Ainsi, par exemple, les deux instructions suivantes sont équivalentes :

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

Private Sub Button1_Click() Handles Button1.Click

(19)

75 Expressions Lambda

Par définition, une expression Lambda est une fonction sans nom qui renvoie une valeur unique.

À titre d’exemple, l’expression Lambda suivante consiste en une fonction qui admet un argument entier et qui renvoie un calcul réel basé sur cet argument :

Dim monExpressionLambda = Function(nombre As Integer) (nombre + 7) / 3

Pour appeler l’expression Lambda, il suffit de préciser son nom et son argument. Par exemple :

Console.WriteLine(monExpressionLambda(12))

Un autre exemple, un peu plus complexe :

Sub ExecuteExpressionLambda(ByVal data As Integer, ByVal maFonction As Func

„ (Of Integer, Boolean))

If maFonction(data) Then

Console.WriteLine("L’expression Lambda a reçu la valeur 7") Else

Console.WriteLine("L’expression Lambda n’a pas reçu la valeur 7") End If

End Sub Sub Main()

ExecuteExpressionLambda(7, Function(num) num = 7) Console.ReadLine()

End Sub

Le premier bloc d’instructions définit la procédure ExecuteExpressionLambda() :

Sub ExecuteExpressionLambda(ByVal data As Integer, ByVal maFonction As Func

„ (Of Integer, Boolean))

Cette procedure admet deux arguments : la valeur entière data et la fonction maFonction

(c’est l’expression Lambda), qui admet un argument entier et renvoie un argument booléen. Le code de maFonction() est élémentaire. Selon la valeur booléenne renvoyée, un message ou un autre s’affiche sur la console :

If maFonction(data) Then

Console.WriteLine("L’expression Lambda a reçu la valeur 7") Else

Console.WriteLine("L’expression Lambda n’a pas reçu la valeur 7") End If

(20)

76

Il ne reste plus qu’à appeler la procédure ExecuteExpressionLambda() en lui transmettant la valeur et la fonction :

ExecuteExpressionLambda(7, Function(num) num = 7)

Ici, la fonction se contente de tester si la valeur passée en argument est égale à 7.

Méthodes partielles

Dans Visual Basic 2010, la définition d’une classe (ou d’une structure) peut être divisée en plusieurs déclarations partielles. À titre d’exemple, les deux instructions Partial Class

ci-après définissent partiellement la classe maClasse. La première implémente la méthode

meth1, et la deuxième la méthode meth2

Partial Public Class maClasse Public Sub meth1() End Sub

End Class …

Partial Public Class maClasse Public Sub meth2() End Sub

End Class

Les différents éléments Partial peuvent se trouver dans le même fichier ou dans des fichiers différents.

Le langage LINQ

LINQ est l’acronyme de Language INtegrated Query (langage d’interrogation intégré). Cette fonctionnalité est un véritable pas en avant : en utilisant une syntaxe proche de celle du langage SQL, il est désormais possible de manipuler des objets IEnumerable, du code XML, des Datasets et des bases de données SQL Server. Reportez-vous au Chapitre 27 pour savoir comment tirer parti de ces évolutions à travers les quatre principales techno-logies associées :

∑

LINQ to Objects ;

∑

LINQ to XML ;

∑

LINQ to Dataset ;

∑

LINQ to SQL.

Dans ce chapitre, vous verrez que LINQ présente de nombreux avantages. Entre autres, il :

(21)

77 ∑

utilise une syntaxe indépendante de la source de données ;

∑

facilite la vie du développeur ;

∑

gère les erreurs lors de la compilation (et non à l’exécution) ;

∑

supporte l’Intellisense et le débogage dans Visual Studio.

Techniques évoluées de Visual Studio 2005/2008

toujours d’actualité dans Visual Studio 2010

Cette section recense un certain nombre de techniques évoluées de Visual Studio 2005-2008/ Visual Basic 2005-2008, toujours utilisables dans Visual Studio 2010/Visual Basic 2010.

Alignement des contrôles

Lorsque vous placez plusieurs contrôles sur une feuille, il est très simple de les aligner entre eux : cliquez sur le contrôle que vous voulez aligner, maintenez le bouton de la souris enfoncé et déplacez le contrôle horizontalement et/ou verticalement jusqu’à l’apparition des marques d’alignement (snap lines). Relâchez le bouton de la souris ; le contrôle est aligné (voir Figure 3.33).

Figure 3.33

Alignement sur la partie infé-rieure d’un contrôle Label et d’un contrôle TextBox.

Menus

Les contrôles MenuStrip et ContextMenuStrip remplacent les contrôles MainMenu et

ContextMenu. Ces deux contrôles ont fait leur apparition dans la version 2 du Framework. Les menus peuvent désormais être composés de commandes traditionnelles (MenuItem), mais également de listes déroulantes (ComboBox) et de zones de texte (TextBox), et ce, à un quelconque niveau d’indentation (voir Figure 3.34).

(22)

78

Visual Basic 2010 Figure 3.34

Les trois types d’entrées d’un menu Visual Basic.

Pour définir rapidement les menus standard d’une application, il suffit désormais de cliquer doit sur la barre d’un contrôle MenuStrip et de sélectionner Insérer des éléments standard dans le menu contextuel (voir Figure 3.35).

Figure 3.35

Cette commande augmentera sensiblement votre produc-tivité.

Les commandes de menu que l’on rencontre le plus traditionnellement sont alors automa-tiquement ajoutées (voir Figure 3.36). Il ne vous reste plus qu’à jouer de la touche Suppr pour supprimer les commandes inutiles et à ajouter vos propres commandes.

Les menus et commandes de menu peuvent apparaître horizontalement ou verticalement en utilisant les valeurs (Horizontal, Vertical90 ou Vertical270) de la propriété Text-Direction (voir Figure 3.37).

(23)

79

Figure 3.36

Les menus traditionnels ont été mis en place d’un simple clic de souris.

Figure 3.37 Affichage vertical de la commande de menu Fichier.

Lorsque vous cliquez sur un contrôle MenuStrip dans la feuille, une petite flèche apparaît dans sa partie supérieure droite. Il suffit de cliquer dessus pour accéder aux propriétés les plus courantes (voir Figure 3.38).

Figure 3.38 Cette nouveauté se révèle très pratique à l’utilisation.

(24)

80

Pour terminer, signalons qu’il est très simple d’associer une icône à chaque commande de menu :

1. Sélectionnez la commande dans la feuille de conception.

2. Cliquez sur la propriété Image dans la fenêtre des propriétés pour faire apparaître un bouton contenant trois points de suspension.

3. Cliquez sur ce bouton et désignez l’image en utilisant les ressources locales ou le fichier de ressources associé au projet (voir Figure 3.39).

Figure 3.39

Association d’une icône à une commande de menu.

Vous trouverez un exemple d’utilisation des contrôles MenuStrip et ContextMenuStrip au Chapitre 6.

Barres d’outils

Le contrôle ToolStrip succède dignement au contrôle ToolBar. Il manipule des éléments bien plus diversifiés que son prédécesseur (voir Figure 3.40).

Pour ajouter les icônes que l’on retrouve traditionnellement dans une barre d’outils, cliquez droit sur le contrôle ToolStrip puis cliquez sur la commande Insérer des éléments standard (voir Figure 3.41).

Le contrôle StatusStrip est le pendant Visual Basic 2010 du contrôle StatusBar. Il peut contenir un ou plusieurs StatusLabel, ProgressBar, DropDownButton et/ou SplitButton.

Les contrôles StatusLabel peuvent être transformés en des liens hypertextes grâce à la propriété IsLink. Vous les utiliserez par exemple pour mettre à jour l’application d’un simple clic de l’utilisateur.

(25)

81

Figure 3.40 De nombreux types d’éléments peuvent être insérés dans un ToolStrip.

Figure 3.41 Cette barre d’outils a été complétée en deux clics de souris.

Vous trouverez un exemple d’utilisation des contrôles ToolStrip et StatusStrip au Chapitre 7.

Info-bulles

Le contrôle NotifyIcon fait son apparition. Grâce à lui, vous pouvez afficher une info-bulle dans la barre de notification de Windows (également appelée Systray). Pour cela, vous devez, dans un premier temps, renseigner quelques propriétés :

∑

Icône dans la zone de notification :

NotifyIcon1.Icon = SystemIcons.Asterisk

∑

Titre de l’info-bulle :

(26)

82 ∑

Texte affiché dans l’info-bulle :

NotifyIcon1.BalloonTipText = "texte du ballon"

∑

Icône dans l’info-bulle :

NotifyIcon1.BalloonTipIcon = ToolTipIcon.Info

Ces propriétés étant initialisées, rendez l’info-bulle visible :

NotifyIcon1.Visible = True

Puis appelez la méthode ShowBalloonTip() en précisant le nombre de secondes d’affichage de l’info-bulle :

NotifyIcon1.ShowBalloonTip(20)

La Figure 3.42 présente le résultat de l’exécution de ces quelques lignes de code.

Figure 3.42

Quelques instructions suffisent pour afficher cette info-bulle.

Zone de texte avec marque de saisie

Le contrôle MaskedTextBox facilite la saisie de données en utilisant un masque de saisie. Il suffit pour cela de choisir un des masques prédéfinis ou de créer le vôtre en cliquant sur le bouton contenant trois points de suspension de la propriété Mask (voir Figure 3.43).

Figure 3.43

Masque de saisie de date, au format court.

(27)

83 Fenêtre des tâches

Lorsque vous insérez un contrôle "complexe" dans une feuille, une petite flèche orientée vers la droite s’affiche dans sa partie supérieure droite. En cliquant dessus, vous avez directement accès aux propriétés et tâches les plus courantes associées à ce contrôle (voir Figure 3.44).

Figure 3.44

Propriétés et tâches associées au contrôle DataGridView.

Navigateur web

Le contrôle WebBrowser fait partie du jeu de composants par défaut (il n’est plus néces-saire d’importer le composant AxWebBrowser. Vous trouverez un exemple d’utilisation de ce contrôle au Chapitre 21.

Refactoring

Le refactoring est une fonctionnalité très utile pour les programmeurs. Il permet d’extraire un code, de déclarer automatiquement des variables, de modifier le nom d’un symbole (et bien d’autres choses encore) en quelques clics de souris. Voyons comment mettre en œuvre cette fonctionnalité en raisonnant sur le code suivant :

Public Class Form1

Sub calcul(ByVal i As Integer) ‘une ou plusieurs lignes de code End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.

„ EventArgs) Handles Button1.Click

Dim i As Integer For i = 1 To 10 calcul(i) Next End Sub End Class

(28)

84

Ce code est un modèle de simplicité : la procédure événementielle Button1_Click() appelle dix fois de suite une procédure de calcul. Supposons que vous vouliez modifier le nom de la procédure. Placez le pointeur au-dessus d’un des mots "calcul", cliquez droit et choisissez Renommer dans le menu contextuel (voir Figure 3.45). Il ne vous reste plus qu’à choisir le nouveau nom dans la boîte de dialogue Renommer (voir Figure 3.46).

Figure 3.45

Accès à la commande Renommer.

Figure 3.46

Choix du nouveau nom de la procédure.

Extraits

En quelques clics de souris, les extraits (snippets) permettent d’insérer des blocs de code prédéfinis dans l’éditeur. Fini les recherches interminables pour retrouver l’extrait de code qui vous aidera à définir l’action que vous voulez accomplir !

Pour insérer un extrait, cliquez du bouton droit dans l’éditeur de code et sélectionnez la commande Insérer un extrait (voir Figure 3.47).

Figure 3.47

(29)

85

Choisissez un dossier, un sous-dossier, puis un extrait. Le code est alors inséré dans la feuille de l’application, à l’emplacement du point d’insertion (voir Figure 3.48).

Figure 3.48

Insertion du snippet Notions de base/Mathématiques/ Calculer le remboursement mensuel d’un emprunt.

Les amateurs de raccourcis clavier peuvent également appuyer sur Ctrl+K, puis sur Ctrl+X pour simuler la commande Insérer un extrait dans le menu contextuel de la fenêtre de code.

Pour terminer la définition de l’extrait, il vous suffit de modifier les paramètres qui appa-raissent en caractères surlignés.

Même s’ils représentent une base de départ intéressante, les extraits proposés dans Visual Studio sont assez restreints ; tôt ou tard, vous éprouverez le besoin de définir vos propres extraits de code. Pour cela, il vous suffit de définir un fichier XML contenant la description de l’extrait de code. Voyons comment procéder.

Par défaut, Visual Basic 2010 stocke ses extraits dans le dossier Program Files\Micro-soft Visual Studio 10.0\VB\Snippets\1036. Voici, à titre d’exemple, le contenu du fichier CalculateaMonthlyPaymentonaLoan.snippet, utilisé dans les lignes précédentes pour insérer l’extrait Calculer le remboursement mensuel d’un emprunt :

<?xml version="1.0" encoding="utf-8"?>

<Title>Calculer le remboursement mensuel d’un emprunt</Title> <Author>Microsoft Corporation</Author>

<Description>Calcule le montant des remboursements mensuels

„ d’un emprunt.</Description> <Shortcut>mathPayLoan</Shortcut> </Header> <Snippet> <Imports> <Import> <Namespace>System</Namespace> </Import> Astuce

(30)

86

Visual Basic 2010 <Import> <Namespace>Microsoft.VisualBasic</Namespace> </Import> </Imports> <Declarations> <Literal> <ID>annualInterestRate</ID> <Type>Double</Type>

<ToolTip>Remplacez par un Double pour le taux d’intérêt annuel

„ (p. ex. 0,05 pour 5 %).</ToolTip>

<ID>numberOfPayments</ID> <Type>Double</Type>

<ToolTip>Remplacez par le code qui retourne un Double pour le nombre

„ total de versements mensuels.</ToolTip>

<ID>loanAmount</ID> <Type>Double</Type>

<ToolTip>Remplacez par le code qui retourne un Double pour le montant

„ de l’emprunt.</ToolTip>

</Declarations>

<Code Language="VB" Kind="method body"><![CDATA[Dim futureValue As Double

„ = 0

Dim payment As Double

payment = Pmt($annualInterestRate$ / 12, $numberOfPayments$, -$loanAmount$,

„ futureValue, DueDate.EndOfPeriod)]]></Code>

</Snippet> </CodeSnippet> </CodeSnippets>

Examinons les éléments contenus dans ce code :

∑

Le nom de l’extrait apparaît entre les balises <Title> et </Title> :

<Title>Calculer le remboursement mensuel d’un emprunt</Title>

∑

La description de l’extrait apparaît entre les balises <Description> et </Description> :

<Description>Calcule le montant des remboursements mensuels d’un emprunt.

(31)

87 ∑

Le bloc de code situé entre les balises <Imports> et </Imports> définit les Assembly

utilisés par l’extrait. Ainsi, le cas échéant, une clause Imports sera ajoutée au début du code : <Imports> <Import> <Namespace>System</Namespace> </Import> <Import> <Namespace>Microsoft.VisualBasic</Namespace> </Import> </Imports>

Le bloc de code situé entre les balises <Declarations> et </Declarations> définit les variables qui doivent être ajustées par le programmeur (identificateur, type, info-bulle et valeur par défaut) :

<ID>annualInterestRate</ID> <Type>Double</Type>

<ToolTip>Remplacez par un Double pour le taux d’intérêt annuel

„ (p. ex. 0,05 pour 5 %).</ToolTip>

<Default>.05</Default> </Literal>…

</Declarations>

Enfin, les dernières instructions définissent le code de l’extrait (les différentes variables sont repérées par leur champ ID et sont encadrées par des caractères "$") :

<Code Language="VB" Kind="method body"><![CDATA[Dim futureValue As Double = 0 Dim payment As Double

payment = Pmt($annualInterestRate$ / 12, $numberOfPayments$, -$loanAmount$,

„ futureValue, DueDate.EndOfPeriod)]]></Code>

Vous avez maintenant tous les éléments nécessaires pour créer vos propres extraits. Pour les rendre accessibles, donnez-leur l’extension .snippet et stockez-les dans le dossier Program Files\Microsoft Visual Studio 10.0\VB\Snippets\1036.

Dans les versions précédentes de Visual Studio, les snippets n’étaient dis-ponibles que dans les éditeurs de code C# et Visual Basic. Désormais, cette fonctionnalité est étendue au code HTML/ASP.NET et au JavaScript.

(32)

88 Documenter le code en XML

Il est fondamental de bien documenter votre code si vous travaillez en équipe ou que vous développiez un projet de grande envergure dont le temps d’écriture dépasse les six mois. Visual Basic automatise la création de documentation au format XML. Voyons comment mettre en œuvre cette fonctionnalité.

Sur la ligne qui précède une déclaration Sub ou Function, insérez trois apostrophes consé-cutives. Un bloc XML est automatiquement créé (voir Figure 3.49). Il ne reste plus qu’à remplir les différents champs pour obtenir une documentation XML digne de program-meurs professionnels.

Figure 3.49

Ces commentaires XML ont été créés par Visual Studio.

Un fichier XML est automatiquement généré lors de la compilation du programme. Par exemple, pour le gabarit de commentaires créé à la Figure 3.49, le fichier XML généré est le suivant : <?xml version="1.0"?> <doc> <assembly> <name> WindowsApplication1 </name> </assembly> <members> <member name="M:WindowsApplication1.Form1.Form1_Load(System.Object, „ System.EventArgs)"> <summary> </summary> <param name="sender"></param> <param name="e"></param> <remarks></remarks> </member> </members> </doc>

(33)

89

Ces types de données sont facilement récupérables dans de nombreux programmes. En prenant quelques instants pour documenter tous les passages complexes de vos programmes, vous en assurerez la pérennité à moindres frais.

L’espace de nom My

L’espace de nom (NameSpace) My est apparu dans Visual Basic 2005. Il est entièrement compatible Visual Basic 2010. Son approche résolument pratique facilite la vie du program-meur. Les éléments contenus dans ce nouvel espace de nom peuvent être répartis dans deux catégories :

∑

Raccourcis vers les classes du Framework : accès rapide et intuitif aux classes de base de la BCL (Base Class Library) du .NET Framework.

∑

Éléments dynamiques créés lors de la définition de l’interface et/ou de l’exécution du code : accès aux formulaires, contrôles, paramètres, ressources et services web créés lors de la conception ou de l’exécution de l’application.

Comme le montre la Figure 3.50, l’espace de nom My se décompose en plusieurs branches indépendantes.

Figure 3.50

Structure de l’espace de nom My.

Dans cette section, nous allons vous montrer comment tirer parti de ce nouvel espace de nom en développant plusieurs petites applications qui exploitent les propriétés, procédures et fonctions afférentes au principaux objets qui le composent.

(34)

90 My.Application

L’objet My.Application donne accès à des méthodes, propriétés et événements en rapport avec l’application en cours d’exécution et son environnement.

Test des possibilités de l’objet My.Application

Pour vous faire une idée des possibilités de l’objet My.Application, définissez une nouvelle application Windows Forms et donnez-lui le nom TestMyApplication. Affectez la valeur Test de l’objet My.Application à la propriété Text de l’objet Form1. Ajoutez un objet Label. Double-cliquez sur une partie inoccupée de la feuille et testez les fonctions et propriétés de l’objet My.Application dans la procédure Form1_Load() (voir Figure 3.51).

Figure 3.51 Intellisense facilite la saisie du code.

La Figure 3.52 donne un exemple d’exécution de l’application. La propriété testée est

My.Application.Info.DirectoryPath. Figure 3.52 My.Application.Info. DirectoryPath renvoie le chemin complet de l’application.

Paramètres de la ligne de commande

Les éventuels paramètres passés au programmes lors de son exécution (nom d’un fichier, valeur numérique, etc.) sont récupérés dans l’objet My.Application.CommandLineArgs. Pour vous montrer comment utiliser cet objet, vous allez définir une mini-application. Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom RecupParam à l’appli-cation et validez. Affectez la valeur Paramètres de la ligne de commande à la propriété

(35)

91

Text de la feuille. Ajoutez un contrôle Label, affectez la valeur False à sa propriété Auto-Size et redimensionnez le contrôle de sorte qu’il occupe la plus grande partie de la feuille (voir Figure 3.53).

Figure 3.53

La feuille de l’application en mode Édition.

Double-cliquez sur une partie inoccupée de la feuille et complétez la procédure Form1_ Load() comme suit :

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)

„ Handles MyBase.Load

Label1.Text = LigneCom() End Sub

L’unique instruction de cette procédure affecte la valeur renvoyée par la fonction Ligne-Com() à la propriété Text du contrôle Label1.

Définissez la fonction LigneCom() comme suit :

Private Function LigneCom() As String Dim i = 0

Dim st = ""

For Each s As String In My.Application.CommandLineArgs i = i + 1

st = st + "argument " + Str(i) + " : " + s.ToString + Chr(13) Next

If st = "" Then st = "Aucun paramètre n’a été passé à l’application." Return st

(36)

92

Après avoir déclaré les deux variables utilisées dans la fonction :

Dim i As Integer = 0 Dim st As String = ""

une boucle For Each Next parcourt les éventuels paramètres passés à l’application :

For Each s As String In My.Application.CommandLineArgs …

i = i + 1

Et la chaîne résultat est mise à jour avec le paramètre en cours :

st = st + "argument " + Str(i) + " : " + s.ToString + Chr(13)

Si la chaîne est vide, cela signifie qu’aucun paramètre n’a été passé à l’application. La chaîne résultat est alors initialisée avec un texte indiquant l’absence de paramètre :

If st = "" Then st = "Aucun paramètre n’a été passé à l’application."

La chaîne résultat est alors retournée par la fonction LigneCom() :

Return st

Lancez le programme en appuyant sur la touche F5. Un message indique qu’aucun para-mètre n’a été passé à l’application (voir Figure 3.54).

Figure 3.54

Un message indique l’absence de paramètre.

Copiez le fichier Projects\RecupParam\bin\Debug\RecupParam.exe dans un dossier plus facile à atteindre (par exemple dans le dossier C:\test). Déroulez le menu Démarrer et entrez la commande représentée Figure 3.55.

(37)

93

Figure 3.55

Exécution du programme avec trois paramètres.

Si vous travaillez sous Windows XP, lancez la commande Exécuter dans le menu Démarrer et tapez la commande de la Figure 3.55 dans la boîte de dialogue Exécuter.

La Figure 3.56 montre que les trois paramètres ont bien été récupérés par l’application.

Figure 3.56

Les trois paramètres sont listés dans le contrôle Label.

(38)

94

My.Application.Info

L’objet My.Application.Info est très intéressant. Comme le montre le tableau ci-après, il donne accès à des propriétés qui décrivent l’application en cours d’exécution.

Propriété Description

AssemblyName Nom, sans extension, de l’assembly de l’application

CompanyName Nom de société associé à l’application

Copyright Note de copyright associée à l’application

Description Description associée à l’application

DirectoryPath _{Dossier à partir duquel l’application s’exécute}

LoadedAssemblies _{Collection de tous les assemblies chargés par l’application}

ProductName Nom de l’application

StackTrace Trace de la pile de l’application

Title Titre de l’application

Trademark Marque déposée de l’application

Version Numéro de version de l’application

WorkingSet _{Quantité de mémoire physique associée au processus en cours d’exécution}

Pour définir ces informations, vous pouvez initialiser les propriétés correspondantes dans le code de l’application :

My.Application.Info.ProductName = "Nom de l’application" My. Application.Info.Version = "Numéro de version"

My.Application.Info.Copyright = "Informations de copyright"

My.Application.Info.CompanyName = "Nom de la société à l’origine de l’application" My.Application.Info.Description = "Description de l’application"

Mais il est bien plus pratique d’utiliser la méthode suivante :

1. Lancez la commande Propriétés de Projet1_{du menu Projet. Cette commande affiche} un nouvel onglet dans l’interface (voir Figure 3.57).

2. Cliquez sur le bouton Informations de l’Assembly et remplissez la boîte de dialogue représentée à la Figure 3.58.

1. Dans la commande de menu Propriétés de Projet, «Projet» représente le nom de votre projet (par exemple, Windows Application1 par défaut pour une application Windows).

(39)

95

Figure 3.57

Cet onglet donne accès aux informations relatives à l’application.

Figure 3.58

Personnalisez l’Assembly de l’application dans cette boîte de dialogue.

Boîte de dialogue "A propos"

Définissez une nouvelle application Windows Forms et nommez-la AutoApropos. Lancez la commande Propriétés de projet du menu Projet, cliquez sur Informations de l’assem-bly et paramétrez la boîte de dialogue Informations de l’asseml’assem-bly comme montré à la Figure 3.59.

(40)

96

Visual Basic 2010 Figure 3.59

Un exemple de paramétrage.

Ajoutez une boîte de dialogue "A propos" au projet. Pour cela, lancez la commande Ajouter un formulaire Windows, du menu Projet, sélectionnez Boîte de dialogue A propos de, dans la boîte de dialogue Ajouter un nouvel élément (voir Figure 3.60), et validez en cliquant sur Ajouter.

Figure 3.60 Ajout d’une boîte de dialogue "A propos" au projet.

Ajoutez un bouton de commande dans la feuille principale de l’application. Affectez la valeur Apropos à sa propriété Name et la valeur A propos à sa propriété Text. Double-cliquez sur ce bouton et complétez la procédure Apropos_Click() comme suit :

(41)

97

Private Sub APropos_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)

„ Handles APropos.Click

AboutBox1.Show() End Sub

Exécutez le projet en appuyant sur la touche F5 et cliquez sur le bouton A propos. Comme le montre la Figure 3.61, les champs de la boîte de dialogue A propos ont été automati-quement renseignés.

Figure 3.61

Tous les renseignements sont issus de la boîte de dialogue Informations de l’assembly.

Cette application se trouve dans le dossier Projects\AutoApropos des sources de l’ouvrage.

My.Computer

L’objet My.Computer fournit des méthodes, propriétés et événements permettant de mani-puler des composants en rapport avec l’ordinateur et ses périphériques : horloge système, clavier, système audio, système graphique, etc.

L’objet My.Computer compte douze membres :

∑

Audio ;

∑

Clipboard ;

∑

Clock ;

∑

FileSystem ;