Chapitre 1-Organisation D'une Application

Vb.
NET : Chapitre 1-
Organisation D’une
Application
Sami Ben Aissia 11/6/22 Ressource Intellectuelle
Vb.NET : Chapitre 1-Organisation D’une Date de Dernière Modification
Application 06/11/2022
Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f
Signé Signé Signé

01 +Création Sami Ben Aissia Sami Ben Sami Ben
Aissia Aissia
Indice Version [Intitulé_du_Document] Rédacteur Vérificateur Approbateur
Ce document est interne à DEpT Corporation, ce qui le rend sa propriété. Toute reproduction non-autorisée par la direction de DEpT Corporation sera
condamné selon les règlements applicables dans le territoire tunisien.
Table de Matières
Liste des Figures........................................................................................................................................................................................................................................................... 3
1. Les Solutions ...................................................................................................................................................................................................................................................... 1
1.1. Présentation........................................................................................................................................................................................................................................... 1
1.2. Création d’une solution .................................................................................................................................................................................................................... 1
1.3. Modification d’une solution............................................................................................................................................................................................................ 2
1.3.1. Ajouter un projet ..................................................................................................................................................................................................................... 2
1.3.2. Supprimer un projet .............................................................................................................................................................................................................. 3
1.3.3. Renommer un projet ............................................................................................................................................................................................................. 3
1.3.4. Décharger un projet ............................................................................................................................................................................................................... 3
1.4. Organisation d’une solution ........................................................................................................................................................................................................... 3
1.4.1. Créer un dossier de solution .............................................................................................................................................................................................. 4
1.4.2. Créer un projet dans un dossier....................................................................................................................................................................................... 4
1.4.3. Déplacer un projet dans un dossier ............................................................................................................................................................................... 4
1.5. Le dossier éléments de solution ................................................................................................................................................................................................... 4
1.6. Le dossier Fichiers divers................................................................................................................................................................................................................ 4
1.7. Configuration d’une solution ......................................................................................................................................................................................................... 5
1.7.1. Configuration du projet de démarrage ......................................................................................................................................................................... 5
1.7.2. Dépendances d’un projet ..................................................................................................................................................................................................... 6
1.7.3. Paramètres d’analyse de code........................................................................................................................................................................................... 7
1.7.4. Fichiers source pour le débogage .................................................................................................................................................................................... 7
1.7.5. Configurations .......................................................................................................................................................................................................................... 7
2. Les projets..................................................................................................................................................................................................................................................... 8
2.1. Création d’un projet ........................................................................................................................................................................................................................... 8
2.1.1. Les modèles de projets ......................................................................................................................................................................................................... 9
2.1.2. Création d’un modèle de Projet..................................................................................................................................................................................... 11
2.1.3. Utilisation d’un projet existant comme modèle .................................................................................................................................................... 12
2.2. Modification d’un projet ............................................................................................................................................................................................................... 13
2.3. Propriétés des projets .................................................................................................................................................................................................................... 15
2.3.1. Propriétés d’application ................................................................................................................................................................................................... 15
2.3.2. Références et Importations d’un projet .................................................................................................................................................................... 17
2.3.3. Propriétés de débogage..................................................................................................................................................................................................... 18
2.3.4. Propriétés de compilation ............................................................................................................................................................................................... 19
2.3.5. Ressources d’un projet ...................................................................................................................................................................................................... 22
2.3.6. Paramètres d’application ................................................................................................................................................................................................. 22
2.3.7. Autres paramètres de configuration ........................................................................................................................................................................... 23
Liste des Figures

Figure 1: Création d'une solution......................................................................................................................................................................................................................... 1
Figure 2: Création d'un nouveau projet ............................................................................................................................................................................................................ 2
Figure 3: Menu Ajout d'un projet Existant ...................................................................................................................................................................................................... 2
Figure 4: Exemple de projet existant.................................................................................................................................................................................................................. 2
Figure 5: Supression d'un projet .......................................................................................................................................................................................................................... 3
Figure 6: Décharger un projet................................................................................................................................................................................................................................ 3
Figure 7: Organisation d'une solution ............................................................................................................................................................................................................... 3
Figure 8: Dossier de solution ................................................................................................................................................................................................................................. 4
Figure 9: Projet dans un dossier ........................................................................................................................................................................................................................... 4
Figure 10: Fichiers divers ........................................................................................................................................................................................................................................ 5
Figure 11: Configuration d'une solution ........................................................................................................................................................................................................... 5
Figure 12: Dépendances d'un projet .................................................................................................................................................................................................................. 6
Figure 13: Dépendance circulaire ........................................................................................................................................................................................................................ 6
Figure 14: Paramètres d'analyse de code ........................................................................................................................................................................................................ 7
Figure 15: Fichiers sources pour le débogage ............................................................................................................................................................................................... 7
Figure 16: Propriétés de configuration d'une solution ............................................................................................................................................................................. 8
Figure 17: Création d'un nouveau projet ......................................................................................................................................................................................................... 8
Figure 18: Assistant Exportation de Modèle ............................................................................................................................................................................................... 12
Figure 19: Options du Modèle ............................................................................................................................................................................................................................ 12
Figure 20: Nouveau Modèle Disponible dans Visual Studio ................................................................................................................................................................ 12
Figure 21: Configuration des Modèles de Projets dans Visual Studio ............................................................................................................................................. 13
Figure 22: Ajout d'un nouvel élément au projet ........................................................................................................................................................................................ 13
Figure 23: Ajout d'éléments existants ............................................................................................................................................................................................................ 14
Figure 24: Propriétés d'application ................................................................................................................................................................................................................. 15
Figure 25: Informations de l'Assembly .......................................................................................................................................................................................................... 16
Figure 26: Références et Importations du Projet ...................................................................................................................................................................................... 17
Figure 27: Propriétés de débogage .................................................................................................................................................................................................................. 18
Figure 28: Propriétés de Compilation ............................................................................................................................................................................................................. 19
Figure 29: événement du Build .......................................................................................................................................................................................................................... 20
Figure 30: ligne de Commande pré-build ..................................................................................................................................................................................................... 21
Figure 31: Options Avancées de compilation .............................................................................................................................................................................................. 21
Figure 32: Ressources d'un projet .................................................................................................................................................................................................................... 22
Figure 33: Paramètres d'application ............................................................................................................................................................................................................... 22
Vb.NET : Chapitre 1-Organisation D’une Application Date de Dernière Modification
06/11/2022
1. Les Solutions
1.1. Présentation
Pour faciliter la création d’une application et pour que le compilateur soit capable de générer l’application (exécutable, dll, etc..). Visual
Studio propose plusieurs éléments organisés pour regrouper les différents composants d’une application. L’explorateur de solutions
permet de manipuler tous ces éléments.
1.2. Création d’une solution
A la suite de la création d’un nouveau projet dans Visual Studio. La création de la solution est automatique. Lors de la création d’un nouveau
projet, des informations le concernant seront demandées.
A travers cette fenêtre (Figure [1]). Fournir les informations suivantes :
Figure 1: Création d'une solution

• La version du Framework nécessaire pour l’application ;
• Le langage utilisé dans le projet ;
• Le type du projet ;
• Le nom du projet ;
• Le répertoire de base pour le stockage des fichiers ;
• Le nom de la solution ; et
• La création du répertoire pour la solution.
Après validation de cette boîte de dialogue, l’explorateur de solutions présente la nouvelle solution de travail. Tous les fichiers de la
solution créé et stockés dans l’emplacement spécifié du disque.
Une solution contiendra, au moins, les fichiers suivants :
• Un fichier avec l’extension (.sln) qui est le fichier de configuration de la solution. Ce fichier regroupe la liste de tous les projets
composant la solution et se met à jour au fur et à mesure qu’un projet est ajouté à la solution ;
• Un fichier avec l’extension (.suo), enregistrant les options associées à la solution. Ce fichier permet de retrouver ces options ;
• Un fichier (.vbproj) contenant toutes les informations de configuration du projet avec la liste des fichiers constituant le projet, la
liste de références utilisées par ce projet, les options à utiliser pour la compilation, etc… ;
• De nombreux fichiers (.vb) contenant le code source de toutes les classes, feuilles et modules constituant le projet ;
Page | 1
• Un fichier (.resx) associé à chaque feuille de l’application. Ce fichier au format XML contient la liste des ressources utilisées sur
cette feuille ; et
• Une solution contient de nombreux autres fichiers en fonction des éléments utilisées dans un projet (accès à une BDD, fichiers
HTML…).
1.3. Modification d’une solution
Dans l’explorateur de solutions. Il est possible de gérer leurs éléments. Notamment ajouter, supprimer, renommer des éléments dans la
solution.
1.3.1. Ajouter un projet
Il existe plusieurs possibilités d’ajout d’un projet :
➢ Création d’un nouveau projet :
Choisir l’option Nouveau projet du menu Fichier-Ajouter (Figure [2]) :
Figure 2: Création d'un nouveau projet

Une boîte de dialogue de configuration des caractéristiques du projet. Cette Boîte de dialogue propose un répertoire d’enregistrement du
projet. Il est possible de choisir un répertoire pour chaque projet. Il est également possible de modifier le chemin du répertoire d’un projet
à travers le menu Outils-Options, puis dans la boîte de dialogue, choisir l’option Projets et solutions et modifier la rubrique
Emplacement des projets.
➢ Ajouter un projet existant :
Utiliser l’option Projet existant du menu Fichier-Ajouter. Une boîte de dialogue de sélection de fichiers permet de choisir le fichier
(.vbproj) du projet à ajouter à la solution. (Figure [3] et [4])
Figure 3: Menu Ajout d'un projet Existant
Figure 4: Exemple de projet existant
Page | 2
NB : le projet ajouté reste à son emplacement d’origine dans le disque.

1.3.2. Supprimer un projet
Utiliser le menu contextuel de l’explorateur de solutions suivre les étapes démontrées dans la figure [5] ci-contre :
NB : Après Suppression, le projet est éliminé de la solution, mais reste enregistré

dans son emplacement dans le disque. Si le projet éliminé est toujours existant dans
le disque. Alors, il peut être ajouté de nouveau à une solution.
1.3.3. Renommer un projet
Suivre les mêmes étapes du paragraphe précédent. Sauf, pour ce cas, le choix de
l’option Renommer au lieu de l’option Supprimer (Voir figure [5]). Il sera donc
possible de modifier le nom du fichier (.vbproj) associé au projet.
NB : Le changement du nom du projet dans l’explorateur de solutions ne signifie en
aucun cas un changement du nom de répertoire où les fichiers du projet sont placés.
1.3.4. Décharger un projet
Pour exclure temporairement un projet d’une solution et rendre la modification de
ses composants impossible. Cela est possible via l’option Décharger le projet (voir
figure [5]).
Remarque : Un projet déchargé n’est pas retiré de la solution mais simplement
marqué comme indisponible (Voir figure [6]).
Figure 5: Supression d'un projet
Figure 6: Décharger un projet
Le projet peut être réhabilité dans la solution en utilisant l’option Recharger le projet.
1.4. Organisation d’une solution
Il est possible d’hiérarchiser et regrouper logiquement des projets au sein d’une solution en créant des dossiers de solutions (voir la figure
[7]).
Figure 7: Organisation d'une solution
Il est donc utile de créer, dans un premier temps, l’ensemble des dossiers de solutions. Puis organiser les projets dans ces dossiers.
Remarque : Les dossiers de solution ne créent pas de dossiers physiques sur disque, ils sont juste des conteneurs logiques à l’intérieur de
la solution.
Page | 3
1.4.1. Créer un dossier de solution

Un dossier de solution peut être créé par 2 méthodes différentes.
• Pour ces 2 méthodes, sélectionner la solution dans l’explorateur de
solution.
• Ensuite, utiliser soit le menu Projet-Ajouter un nouveau dossier de
solution, soit le menu contextuel disponible par un clic droit sur le nom de
la solution.
Quelle que soit la méthode utilisée, il faut fournir un nom pour le dossier
créé.
Figure 8: Dossier de solution
1.4.2. Créer un projet dans un dossier

La création d’un projet dans un dossier de solution est identique à la création directe d’un projet dans la solution.
• Sélectionner simplement le dossier où le projet va être créé.
1.4.3. Déplacer un projet dans un dossier
Pour déplacer un projet dans un dossier de solution. Il suffit d’effectuer un glisser-déplacé (voir figure [9]) dans le dossier de solution
souhaité.
Figure 9: Projet dans un dossier

1.5. Le dossier éléments de solution
Les solutions contiennent principalement des projets. Cependant, il est possible d’avoir, dans une solution, des fichiers gérés
indépendamment d’un projet mais associés à la solution. Par exemple, un fichier icône à utiliser dans la solution peut être ajouté à une
solution. Ces fichiers sont appelés éléments de solution et sont placés dans un dossier spécifique de la solution.
• Pour ajouter un nouvel élément de solution, utiliser le menu contextuel sur le nom de la solution en choisissant l’option
Ajouter-Nouvel élément ou l’option Ajouter-élément existant.
Le nouvel élément est ajouté dans le dossier éléments de solution. Ce dossier est créé automatiquement lors de l’ajout d’un premier
élément de solution.
1.6. Le dossier Fichiers divers
Il est parfois utile de visualiser le contenu d’un fichier externe dans l’environnement de Visual Studio pour des raisons d’ergonomie. Ce
genre de fichiers ne doit pas faire partie de manière permanente d’une solution.
• Pour cela, utiliser l’option Ouvrir fichier du menu Fichier.
Page | 4
La boîte de dialogue (Voir Figure [10]) permet de choisir le fichier à ouvrir. Selon le type de fichier, un éditeur par défaut sera associé au
fichier pour édition/modification.
Figure 10: Fichiers divers

Pour ce faire, le bouton Ouvrir de la boîte de dialogue dispose d’un menu proposant l’option Ouvrir avec permettant le choix de l’éditeur
associé (Voir Figure [10]). La boîte de dialogue propose la liste des éditeurs disponibles.
• Choisir l’éditeur associé au fichier sur lequel on souhaite travailler et valider par OK.
Le Fichier est alors disponible dans le dossier « Fichiers divers » de la solution. Ce dossier sera visible dans l’explorateur de solutions
uniquement dans le cas d’activation de l’option correspondante dans Visual Studio. Pour ce faire, Menu Outils-Options, puis dans la boîte
de dialogue, Option Environnement-Documents et activer l’option Afficher les fichiers divers dans l’explorateur de solutions.
1.7. Configuration d’une solution
Pour configurer les comportements d’une solution. Choisir l’option Propriétés du menu contextuel de la solution à configurer. Une boîte
de dialogue (Voir Figure [11]) qui contient 5 catégories de propriétés de solutions apparait. Ces 5 propriétés sont :
• Projet de démarrage ;
• Dépendances du projet ;
• Paramètres d’analyse de code ;
• Fichiers sources pour débogage ; et
• Propriétés de configuration.
1.7.1. Configuration du projet de démarrage
Cette fenêtre (Voir figure [ ]) permet de déterminer les projets à lancer au démarrage de l’application.
Figure 11: Configuration d'une solution

3 options sont disponibles :
• Sélection actuelle : le projet sélectionné dans l’explorateur de solutions sera exécuté au démarrage de la solution.
• Projet de démarrage unique : Un comboBox propose la liste des projets disponibles pour la sélection au démarrage. Notez bien que
dans ce cas, un seul et unique projet sera sélectionné comme projet de démarrage.
Page | 5
• Plusieurs projets de démarrage : La liste des projets disponibles est présentée dans le tableau de la figure [11]. Pour chaque projet,
on peut choisir l’action à exécuter au lancement de l’application.
o Les choix possibles sont :
▪ Aucune action ;
▪ Démarrer le projet ; et
▪ Exécuter le projet sans débogage.
En cas de démarrage de plusieurs projets. Il faut indiquer l’ordre auquel les projets sont exécutés au démarrage de l’application. Les
boutons ↑ et ↓ permettent de modifier l’ordre d’un projet sélectionné.
1.7.2. Dépendances d’un projet
La génération de certains projets nécessite au préalable la génération d’autres projets. C’est le cas, par exemple, s’il est nécessaire de
générer un projet qui utilise une référence vers un autre projet : celui-ci est donc une dépendance du projet initial (Voir Figure [12]).
Figure 12: Dépendances d'un projet

Dans la liste de projets, sélectionner le projet dont les dépendances sont à configurer. Les autres projets de solution sont listés, chacun
muni d’une case à cocher. Lors de la génération du projet, tous les autres projets dont il dépend seront regénérées, s’ils ont été modifiés
depuis la dernière génération ou s’ils n’ont jamais été générés.
NB : Certaines dépendances ne peuvent être modifiées, la case à cocher apparaît donc en « gris ».
C’est en général le cas, lorsqu’un projet possède une référence sur un autre projet ou que l’ajout d’une dépendance risque de créer une
boucle. Par exemple, le « projet 1 » dépend du « projet 2 » et inversement (Voir Figure [13]).
Figure 13: Dépendance circulaire

Les dépendances d’un projet peuvent être configurées avec l’option Dépendances du projet du menu contextuel de l’explorateur de
solutions.
Page | 6
1.7.3. Paramètres d’analyse de code

Cette rubrique permet de configurer les règles utilisées lors de l’analyse du code des différents éléments de la solution (Voir Figure [14]).
Figure 14: Paramètres d'analyse de code

Pour chaque projet de la solution, il est possible d’indiquer quelle configuration sera utilisée par les outils d’analyse.
L’option Toutes les règles Microsoft est la plus stricte et détecte la moindre anomalie, notamment :
• Les paramètres de fonction non-utilisés à l’intérieur de la fonction ;
• Les variables locales non-utilisées ;
• Les noms de paramètres peu-explicites ; et
• Le non-respect des conventions sur la casse des identifiants.
1.7.4. Fichiers source pour le débogage
Pour les raisons de débogage, Visual Studio doit accéder au fichier source du code à déboguer. La rubrique de la Figure [15] permet de
spécifier les répertoires qui seront analysés à la recherche du code source.
Figure 15: Fichiers sources pour le débogage

La liste Répertoires contenant du code source affiche le nom des répertoires qui seront scrutés à la recherche du code source, pendant
le débogage d’une application.
Cette liste est gérée par la barre d’outils dont ces boutons permettent de :
• Vérifier l’existence du répertoire ;
• Ajouter un nouveau répertoire ;
• Supprimer le répertoire sélectionné ;
• Déplacer le répertoire vers le bas de la liste ;
• Déplacer le répertoire vers le haut de la liste ;
La liste Ne pas rechercher ces fichiers sources exclut certains fichiers de la recherche.
1.7.5. Configurations
Les options de configuration permettent de définir comment différentes versions d’une solution et des projets qui la composent seront
générées. Par défaut, 2 configurations sont disponibles pour une solution dans Visual Studio : le « Debug » et le « Release ».
Page | 7
Pour chacun des projets présents dans la solution, les 2 configurations seront également disponibles. Au niveau du projet, les configurations
permettent de définir les options de compilation. La configuration « Debug » est utilisée pendant le développement et les tests. La
configuration « Release » est utilisée pour la génération finale du projet (Voir Figure [16]).
Figure 16: Propriétés de configuration d'une solution

On a en fait un système à trois niveaux : pour chaque configuration de solution, on indique quelle configuration utiliser pour chaque projet
et, pour chaque configuration de projet, on spécifie des options de compilation. Les options de compilation sont modifiables au niveau des
propriétés du projet.
2. Les projets
Les projets sont des conteneurs de deuxième niveau dans une application. Ils sont utilisés pour organiser logiquement, gérer, générer et
déboguer les composants d’une application. La génération d’un projet génère en général un fichier exécutable ou une bibliothèque (.dll).
Un projet peut être très simple et ne contenir que deux éléments, un fichier source (.vb) et le fichier projet (.vbproj). Plus généralement,
les projets contiennent de nombreux fichiers source, des scripts de base de données, des références vers des services Web, des ressources
graphiques, etc.
Visual Studio propose par défaut un ensemble de modèles de projets. Ces modèles fournissent un point de départ pour la majorité des
besoins dans le développement d’une application. Pour de cas plus spécifiques, vous pouvez créer vos propres modèles de projet.
2.1. Création d’un projet
• Pour créer un projet, activez le menu Fichier-Nouveau-Projet (Voir Figure [17]) :
Figure 17: Création d'un nouveau projet
Une Boîte de dialogue (Figure [1]) vous propose alors de choisir les caractéristiques du nouveau projet.
• Choisissez d’abord la version du Framework pour le développement du projet. La version choisie influence les types de projets
que vous pouvez créer ;
• Choisissez ensuite le langage à utiliser dans le développement du projet. Dans notre cas c’est trivialement le Visual Basic ;
• Choisissez ensuite le type de projet à développer (Console, Application Windows Forms, WPF, Reporting, etc…). La boîte de
dialogue (Figure [1]) propose différents modèles pour chaque type de projet ;
• Indiquez un nom et un emplacement pour le projet et ses fichiers et un nom pour la solution (Figure [1]). Ceux-ci seront utilisées
par l’assistant pour créer les éléments du projet ; et
• Après quelques instants, le projet sera disponible dans l’explorateur de solutions et la personnalisation de l’ébauche créé est
maintenant possible.
Page | 8
2.1.1. Les modèles de projets

De nombreux modèles de projets sont disponibles. Ces modèles fournissent les éléments de base pour chaque type de projet. En fonction
du type du projet, on trouve toujours :
• Le fichier de projet ;
• Un exemplaire de l’élément le plus utilisé.
Par exemple, une bibliothèque de classes contient initialement une ébauche de fichier source d’une classe. Les références et les
importations par défaut sont également créées pour les bibliothèques et les espaces de noms les plus utiles.
Applications Windows Forms
Ce type de projets est utilisé pour le développement d’applications Windows standard. Le modèle ajoute au projet :
• Un fichier AssemblyInfo.vb utilisé pour la description de l’application avec les informations de la version.
• Un formulaire de base avec sa source Form1.vb ;
Les références ci-dessous sont automatiquement ajoutées :
• System
• System.Core
• System.Data
• System.Data.DataSetExtensions
• System.Deployment
• System.Drawing
• System.Windows.Forms
• System.Xml
• System.Xml.Linq
Bibliothèque de classes :
Ce modèle de projet est utilisable pour créer des classes et composants pouvant être ensuite partagées et/ou utilisées avec ou par d’autres
projets. Ajoutés à ce genre de projets les éléments suivants :
• AssemblyInfo.vb pour la description du projet et les informations de version ;
• Une classe de base avec son fichier source class1.vb ;
Les références suivantes sont ajoutées et importées par défaut :
• System
• System.Core
• System.Data
• System.Xml
• System.Xml.Linq
Bibliothèque de Contrôles Windows
Cette bibliothèque permet de créer un type spécifique de classes, appelées contrôles, utilisables dans des projets. Ces contrôles étendent
la boîte à outils disponible dans les applications Windows.
Ajouté à ce genre de projets les éléments suivants :
• Assemblyinfo.vb pour la description du projet avec les informations de version ;
• Une classe UserControl1 héritant de la classe System.Windows.Forms.UserControl fournissant les fonctionnalités de base
pour un contrôle Windows, avec son fichier UserControl1.vb ;
• System
• System.Core
• System.Data
• System.Drawing
• System.Windows.Forms
• System.Xml
• System.Xml.Linq
Application Console
Ce type d’application est exécuté à partir d’une ligne de commande de l’invite de commandes. Elle est conçue sans interface graphique et
les entrées/sorties se font via les lignes de commande vers la console.
Ce type d’applications est pratique pour les tests, car elle permet de se concentrer sur un point particulier sans se soucier de la
présentation de l’application.
Ce genre d’application est devenu au moment présent inadapté aux demandes des marchés de logiciels et un peu obsolète.
Page | 9
• Une classe de base avec sa source class1.vb

• System
• System.Core
• System.Data
• System.Xml
• System.Xml.Linq
Service Windows
Ce genre de projets est utilisé pour des applications exécutant des actions de fond sur le système. Le lancement de ce type peut se faire
automatiquement au démarrage du système sans avoir la nécessité d’avoir la session d’utilisateur ouverte.
Ce genre d’applications est dépourvu d’interface utilisateur. Si des informations doivent être communiquées à l’utilisateur, elles devront
transiter par les journaux système, consultables, par l’observateur des événements.
• Une classe de base avec le squelette des procédures OnStart et OnStop appelés respectivement et automatiquement au
démarrage et à l’arrêt du service.
• System
• System.Core
• System.Data
• System.ServiceProcess
• System.Xml
• System.Xml.Linq
Application WPF
Ce modèle de projet est un nouveau système d’affichage graphique de Windows, utilisé dans Windows 7 et les versions ultérieures.
• Un fichier Applacation.xaml et son fichier de code associé, Application.xaml.vb, permettant la gestion des événements
déclenchés au niveau de l’application.
• Une fenêtre de base Window.xaml et son fichier de code associé, Window.xaml.vb.
• PresentationCore
• PresentationFramework
• System
• System.Core
• System.Data
• System.Xaml
• System.Xml
• System.Xml.Linq
• WindowBase
Bibliothèque de contrôles utilisateur WPF
Ce type de projet permet d’étendre la boîte à outils disponible dans les applications WPF.
Un fichier UserControl1.xaml pour la définition de l’aspect graphique du contrôle ;
• Un fichier UserControl1.xaml.vb pour le code associé à ce contrôle ;
• PresentationCore
• PresentationFramework
• System
• System.Core
• System.Data
Page | 10
• System.Xaml
• System.Xml
• System.Xml.Linq
• WindowBase
Bibliothèque de contrôles utilisateur WPF
Ce modèle de projet est également un nouveau système d’affichage graphique de Windows. Contrairement au type de projet précédent,
les contrôles ne sont pas créés en toute pièce, mais sont basés sur des contrôles existants dont ils étendent leurs caractéristiques.
Les références et importations par défaut sont identiques au type de projet précédent.
Projet vide
Ce modèle doit être utilisé lorsque vous souhaitez créer votre propre type de projet. Seul le fichier de projet est créé. Par contre, aucun
élément, référence ou importation n’est ajoutée à ce type de projet.
2.1.2. Création d’un modèle de Projet
La création d’un modèle de projet personnalisé apparaissant comme modèle prédéfini est possible à condition que l’on conçoit les
éléments suivants :
• Un fichier de définition contenant les métadonnées du modèle. Ce fichier est utilisé par Visual Studio pour l’affichage du projet
dans l’environnement de développement et pour l’affectation des propriétés par défaut au projet. Ces informations sont
contenues dans un fichier XML ayant l’extension .vstemplate ;
• Un fichier pour le projet (.vbproj) ; et
• Les fichiers sources et ressources inclus par défaut lors de la création d’un projet à partir de ce modèle.
Remarque : Ces fichiers doivent être compressées dans un fichier (.zip). Le fichier (.zip) doit contenir les fichiers individuellement et non
le dossier dans lequel ils sont placés.
Le fichier (.vstemplate) doit avoir le format suivant :
On retrouve dans ce fichier :
Dans la section Name
Le nom affiché par la boîte de dialogue de création d’un nouveau projet.
Dans la section Description
Une description détaillée du projet.
Dans la section ProjectType
Le nom du dossier dans lequel ce projet sera classé dans la boîte de dialogue de création de projet.
Dans la section DefaultName
<VSTemplate Version=”3.0.0”
xmlns=http://schemas.microsoft.com/developer/vstemplate/2005 Type=”Project”>
<TemplateData>
<Name>AppliPerso</Name>
<Description>Création d’un projet avec une configuration personnalisee</Description>
<ProjectType>VisualBasic</ProjectType>
<DefaultName>AppliPerso</DefaultName>
</TemplateData>
<TemplateContent>
<Project File=”AppliPerso.vbproj”>
<ProjectItem>AssemblyInfo.vb</ ProjectItem>
<ProjectItem>Feuille1.vb</ ProjectItem>
<ProjectItem>Feuille1.Designer.vb</ ProjectItem>
<ProjectItem>Feuille1.resx</ ProjectItem>
</Project>
</TemplateContent>
</VSTemplate>
Le nom utilisé par défaut pour tous les projets créés à partir de ce modèle. Ce nom sera complété par un suffixe numérique à la création
du projet.
Dans la section Project File
Le nom du fichier associé au modèle. Ce fichier doit être présent dans le fichier (.zip) du modèle.
Dans les sections ProjectItem
Les éléments faisant partie du projet. Ces éléments doivent également être disponible dans le fichier (.zip).
Page | 11
2.1.3. Utilisation d’un projet existant comme modèle

C’est peut-être la solution la plus simple pour construire un modèle de projet.
• Dans un premier temps, créez le modèle comme projet ordinaire ;
• Un fois le projet finalisé, exportez-le comme modèle. Le menu 𝑭𝒊𝒄𝒉𝒊𝒆𝒓 > 𝑬𝒙𝒑𝒐𝒓𝒕𝒆𝒓 𝒍𝒆 𝒎𝒐𝒅è𝒍𝒆 démarre un assistant (Figure
[18]) pour vous guider pendant la création du modèle.
Figure 18: Assistant Exportation de Modèle

Cette première boîte de dialogue vous propose de choisir le projet que vous souhaitez exporter ainsi que, la rubrique de la boîte de
dialogue de création de projet dans laquelle sera placé le futur modèle (Figure [19]).
Figure 19: Options du Modèle

Cette deuxième boîte de dialogue vous invite à choisir une icône pour votre modèle de projet, un nom pour le modèle et une description.
Deux options supplémentaires vous permettent de prendre en compte immédiatement le nouveau modèle dans Visual Studio et de vous
présenter le résultat de la génération en vous affichant le contenu du fichier (.zip) créé. Après validation de cette boîte de dialogue, le
nouveau modèle de projet sera disponible dans Visual Studio (Figure [20]) :
Figure 20: Nouveau Modèle Disponible dans Visual Studio
Page | 12
Remarque : Cette méthode est très simple pour construire un Nouveau modèle de projet et évite de se torturer l’esprit avec la syntaxe du
fichier (.vstemplate).
Dans le cadre d’un développement en équipe, il peut être intéressant de partager les modèles personnalisés entre tous les membres de
l’équipe :
• Recopiez le fichier (.zip) sur un partage réseau ;
• Configurer l’environnement Visual Studio pour lui permettre d’accéder aux modèles. Cette modification s’effectue par la boîte
de dialogue accessible par le menu 𝑶𝒖𝒕𝒊𝒍𝒔 > 𝑶𝒑𝒕𝒊𝒐𝒏𝒔 > 𝑷𝒓𝒐𝒋𝒆𝒕𝒔 𝒆𝒕 𝒔𝒐𝒖𝒍𝒕𝒊𝒐𝒏𝒔 (Figure [21]).
Figure 21: Configuration des Modèles de Projets dans Visual Studio

2.2. Modification d’un projet
Il est parfois utile d’ajouter des éléments à un projet. Ces ajouts se font par l’intermédiaire du menu contextuel de l’explorateur de
solutions.
• Activer le menu 𝑨𝒋𝒐𝒖𝒕𝒆𝒓 > 𝑵𝒐𝒖𝒗𝒆𝒍 é𝒍é𝒎𝒆𝒏𝒕 afin de choisir le type d’élément que vous souhaitez ajouter au projet. La boîte de
dialogue propose une panoplie d’éléments pouvant être ajoutés au projet (Figure [22]).
Figure 22: Ajout d'un nouvel élément au projet
Page | 13
• Indiquez ensuite un nom pour le fichier contenant le nouvel élément.

Il est également possible d’ajouter un élément existant dans un autre projet et de l’ajouter à un projet. Utilisez dans ce cas, l’option
𝑨𝒋𝒐𝒖𝒕𝒆𝒓 > é𝒍é𝒎𝒆𝒏𝒕 𝒆𝒙𝒊𝒔𝒕𝒂𝒏𝒕 du menu contextuel de l’explorateur de solutions. Une boîte de dialogue vous propose la sélection du
fichier à inclure dans le projet (Figure [23]).
Figure 23: Ajout d'éléments existants

Le bouton Ajouter de cette boîte de dialogue comporte un menu (Figure [23]) permettant d’ajouter le fichier normalement (une copie
locale du fichier est alors réalisée) ou de créer un lien sur le fichier (le fichier original est utilisé). Il faut être prudent avec cette possibilité
car le fichier n’appartient pas réellement à l’application mais peut être partagé entre plusieurs applications. Si le fichier est supprimé du
disque, toutes les applications l’utilisant ne pourront pas être compilées.
Afin de retirer un élément d’un projet. Deux options sont accessibles par le menu contextuel de l’explorateur de solutions :
• L’option 𝑺𝒖𝒑𝒑𝒓𝒊𝒎𝒆𝒓 supprime le fichier du projet mais également du disque ;
• L’option 𝑬𝒙𝒄𝒍𝒖𝒓𝒆 𝒅𝒖 𝒑𝒓𝒐𝒋𝒆𝒕 retire le fichier du projet, mais ne le supprime pas du disque. Cette option est utile si d’autres
projets utilisent ce fichier par l’intermédiaire d’un lien.
Page | 14
2.3. Propriétés des projets

Les projets sont des éléments fondamentaux de la conception d’une application avec Visual Basic. Ils possèdent de nombreuses propriétés
permettant de manipuler leur comportement au moment de la conception ou de l’exécution de l’application. Ces propriétés sont
accessibles par une boîte de dialogue présentant, par l’intermédiaire d’onglets, les différentes rubriques de configuration de projet.
• Activez cette boîte de dialogue par l’option Propriétés du menu contextuel de l’explorateur de solutions.
2.3.1. Propriétés d’application
Les propriétés présentes dans cet onglet (Figure [24]) vont permettre de configurer le comportement de l’application.
Figure 24: Propriétés d'application
Nom de l’assembly
C’est le nom utilisé pour le fichier résultant de la compilation de l’application. Par défaut, ce nom est identique au nom du projet mais ce
nom peut être modifié indépendamment du nom du projet et vice versa. L’extension du fichier de l’assembly dépend du type du projet.
Framework cible
Celle-ci indique la version du Framework nécessaire à l’exécution de l’application. Par défaut, cette propriété est identique à celle spécifiée
à la création du projet.
Type d’application
Cette propriété détermine le type d’application générée par la compilation du projet. En règle générale, cette propriété est déterminée par
le modèle choisi lors de la création du projet. Cette propriété est rarement modifiée par la suite car elle dépend énormément du code du
projet (si vous avez conçu votre application comme application Windows et que souhaitez la considérer comme application console, il
risque d’y avoir beaucoup de code inutile !).
Formulaire de démarrage
Cette propriété détermine le point d’entrée dans l’application, lors de son exécution. Généralement, elle correspond à la fenêtre principale
de l’application ou à une procédure Sub Main(). Cette propriété n’est disponible que pour les projets pouvant s’exécuter de manière
autonome. Elle est inutile pour les projets de type bibliothèque.
Page | 15
Espaces de noms racine

Tous les éléments du projet, accessibles à partir d’un autre projet, appartiennent à l’espace de noms défini par cette propriété. Celle-ci
vient s’ajouter aux éventuels espaces de noms, définis au niveau du code lui-même. Par défaut, cette propriété correspond au nom du
projet mais elle peut être modifiée indépendamment de celui-ci. Elle peut même être vide vous permettant ainsi de gérer les espaces de
noms directement dans le code.
Icône
Cette propriété configure l’icône associée au fichier compilé du projet, lorsqu’il est affiché dans l’explorateur Windows ou lorsque
l’application apparaît sur la barre des tâches de Windows.
Informations de l’assembly
Cette option permet de fournir des informations sur le code généré par la compilation du projet. Une boîte de dialogue permet de remplir
différentes rubriques concernant la description du projet (Figure [ ]).
Figure 25: Informations de l'Assembly

L’utilisateur de votre code pourra consulter ces informations en affichant les propriétés du fichier compilé dans l’explorateur Windows.
Afficher les paramètres Windows
Cette option permet de spécifier le niveau d’exécution requis pour l’application. Ces informations sont utilisées par le mécanisme User
Account Control (UAC) de Windows. Il détermine sous quelle identité va être exécuté le code de l’application.
Trois valeurs sont possibles :
• asInvoker : l’application s’exécute avec l’identité actuelle de l’utilisateur et ne demande pas d’augmentation de privilèges ;
• highestAvailable : l’application s’exécute avec le plus haut niveau de privilèges de l’utilisateur ;
• requireAdministrator : l’application doit s’exécuter avec le privilège administrateur et UAC peut vous demander votre
consentement pour accorder l’augmentation de privilèges.
Activer l’infrastructure de l’application
Cette option détermine si vous souhaitez activer une interaction plus évoluée entre l’application et le système d’exploitation. Si cette
option est active, l’élément de démarrage de l’application doit obligatoirement être une feuille. L’utilisation de cette option active la
disponibilité des propriétés suivantes :
a) Activer les style visuelles XP
Si cette option est activée et que l’application s’exécute sur un système Windows XP, alors l’interface utilisateur de l’application s’adaptera
au thème Windows actif.
b) Application à instance unique
Par défaut, vous pouvez lancer autant d’exemplaires d’une même application que vous le souhaitez sur un poste ; toutefois, il peut parfois
être utile de n’autoriser le fonctionnement que d’un seul exemplaire de l’application à un instant donné (problème de licence d’utilisation,
préservation des ressources de la machine…). L’activation de cette option garantit qu’il n’y aura plus d’un exemplaire de l’application
Page | 16
s’exécutant sur la machine. Si une nouvelle instance est lancée alors qu’il en existe déjà une sur le système, le focus passe immédiatement
sur l’instance existante. Au niveau de l’application, l’événement StartupNextInstance est également déclenché.
c) Enregistrer My.Settings lors de l’arrêt
Cette option indique si les propriétés personnalisées de l’application sont sauvegardées à la fermeture de l’application. Ceci permet, par
exemple, de mémoriser les préférences de l’utilisateur.
Mode d’authentification
Par défaut, les applications Visual Basic utilisent l’authentification Windows pour identifier l’utilisateur de l’application. Si vous souhaitez
de gérer vous-même cette identification, vous devez utiliser l’option Défini au niveau de l’application.
Mode d’arrêt
Ce mode détermine le comportement de l’application à l’arrêt. Par défaut, l’application arrête son exécution lorsque la fenêtre de
démarrage de l’application est fermée, même s’il y a d’autres fenêtres actives (hormis bien sûr une fenêtre modale). L’option à la
fermeture du dernier formulaire provoque l’arrêt de l’application à la fermeture de la dernière fenêtre active de l’application ou lorsque
les instructions My.application.exit ou end sont appelées explicitement dans le code.
Ecran de démarrage
Les écrans d’accueil souvent utilisés pour fournir des informations à l’utilisateur, pendant le démarrage de l’application. Visual studio
propose un modèle d’écran d’accueil personnalisable. Cet écran apparaît pendant le chargement de la fenêtre principale de l’application.
Afficher les événements de l’application
Cette option permet d’accéder aux gestionnaires d’événements de l’objet application. Ces gestionnaires d’événements permettent de
réagir face à différentes situations :
Startup
L’application démarre.
StartupNextInstance
Un nouvel exemplaire de l’application vient d’être lancé.
Shutdown
L’application s’arrête.
UnHandledException
Une exception non gérée vient de se produire.
NetworkAvailabilityChanged
L’accès au réseau vient d’être modifié (le câble est débranché ou rebranché).
2.3.2. Références et Importations d’un projet
Pour pouvoir utiliser des éléments externes, disponibles dans un assembly, vous devez ajouter une référence à cet assemblage.
La page des propriétés suivante regroupe toutes les informations concernant les références d’un projet.
Figure 26: Références et Importations du Projet

Dans cette page de propriétés, la liste des Références présente tous les assemblages actuellement référencés par le projet.
Cette liste peut être mise à jour à l’aide des boutons Ajouter, Supprimer, Mettre à Jour qui permettent respectivement, d’ajouter une
référence locale ou une référence Web, de supprimer une référence ou de mettre à jour une référence Web.
Page | 17
Le bouton Chemin d’accès des références permet d’indiquer des répertoires supplémentaires contenant des assemblages disponibles.
Lorsqu’une référence est ajoutée à un assemblage, le fichier original est utilisé lors de la première exécution de l’application. Vous pouvez
utiliser la création automatique d’une copie locale de ce fichier dans le répertoire de l’application. Pour cela :
• Modifier la propriété Copy Local de la référence concernée. Après avoir sélectionné la référence, vous pouvez modifier cette
propriété dans la fenêtre propriétés de Visual Studio.
Le bouton Références inutilisées propose la liste de toutes les références non-utilisées dans le code et vous propose de les supprimer
du projet.
Les éléments disponibles dans les assemblages référencés font certainement partie d’un espace de noms. Pour pouvoir les utiliser il est
possible d’importer automatiquement certains espaces de noms. La liste des Espaces de noms importés reprend les espaces de noms
importés automatiquement dans tous les codes du projet.
Vous pouvez compléter cette liste en saisissant dans la zone de texte le nom de l’espace de noms importé et en validant avec le bouton
Ajouter une importation utilisateur.
2.3.3. Propriétés de débogage
Les propriétés présentes sur cette page déterminent le comportement du projet lors de son débogage.
Figure 27: Propriétés de débogage
Action de démarrage
Cette propriété détermine le comportement du projet lors du démarrage du débogage.
Trois options sont possibles :
• Démarrer le projet indique que le projet lui-même doit être exécuté. Cette option n’est à utiliser que pour les projets
d’application Windows ou les projets d’application console ;
• Démarrer le programme externe permet de provoquer l’exécution d’une application externe qui va se charger de faire les
appels au code de notre projet. Cette option est utilisée pour le débogage des bibliothèques de classes.
• Démarrer le navigateur avec l’URL est identique à l’option précédente, mis à part que l’application démarrée est une
application Web.
Options de démarrage
Arguments de la ligne de commande précise les arguments passés à l’application lors de son exécution par Visual Studio. Ces arguments
peuvent être utilisées par le code pour déterminer l’action à entreprendre : par exemple, démarrer l’application en mode maintenance.
Répertoire de travail permet de spécifier le répertoire actif pendant l’exécution de l’application.
Page | 18
Utiliser l’ordinateur distant autorise le débogage d’une application s’exécutant sur une autre machine. Dans ce cas, le nom de la machine
distante, sur laquelle le code va s’exécuter, est à indiquer.
Activer les débogueurs
Ces options déterminent les différents types de débogueurs actifs, en complément du débogueur du code managé de Visual Studio.
2.3.4. Propriétés de compilation
Les propriétés de cette page concernent le fonctionnement du compilateur et son éventuelle optimisation.
Figure 28: Propriétés de Compilation

Chemin de sortie de la génération
Cette propriété indique le répertoire dans lequel sera copié le fichier résultant de la compilation du projet. Par défaut, il s’agit du sous-
répertoire bin du répertoire dans lequel se trouve le projet.
Option Explicit
Cette option permet d’exiger ou non que toute variable soit déclarée avant d’être utilisée. Elle s’applique à tous les fichiers source d’un
projet. Il est cependant possible, pour un fichier particulier, de modifier cette option en ajoutant la directive Option Explicit On ou
Option Explicit Off en début du fichier.
Option Strict
Cette option permet de contrôler les conversions effectuées. Si une conversion restrictive est tentée, le compilateur génère une erreur.
Comme l’option précédente, celle-ci s’applique à tous les fichiers source d’un projet et peut être modifiée pour un fichier particulier en
ajoutant la directive Option Strict On ou Option Strict Off en début du fichier.
Option Compare
Cette option détermine comment la comparaison des chaînes de caractères est effectuée dans l’application. Avec la valeur Binary,
l’application fait une distinction entre les caractères en minuscule et en majuscule, lors d’une comparaison. La valeur Text permet d’éviter
cette distinction.
Option Infer
Cette option indique si l’inférence des types de variables locales est active. Avec cette option, le compilateur détermine de lui-même le
type des variables à partir des valeurs qui leur sont affectées.
Unité centrale cible
Cette option spécifie le processeur pour lequel le code doit être généré. Trois options sont disponibles :
• x86 : pour les processeurs 32 bits compatibles Intel ;
• x64 : pour les processeurs 64 bits compatibles Intel ;
• Any CPU : pour tous les processeurs.
Préférer 32 bits
Cette application indique que l’application s’exécutera toujours comme application 32 bits même sur un système 64 bits. Elle n’est
disponible que si l’unité centrale cible est définie à Any CPU.
Avertissements
Le compilateur est capable de détecter des problèmes potentiels dans votre code et de générer des avertissements associés. Vous avez la
possibilité de configurer l’action entreprise par le compilateur pour différentes catégories de problèmes. Les trois actions possibles sont :
Page | 19
• Aucun : le compilateur ignore le problème ;

• Avertissement : le compilateur génère un avertissement dans la liste des tâches ;
• Erreur : le compilateur génère une erreur de compilation.
Vous pouvez également dévalider tous les warnings en utilisant l’option Désactiver tous les avertissements ou, au contraire, les traiter
comme des erreurs avec l’option Considérer tous les avertissements comme des erreurs.
Générer le fichier de documentation XML
Avec cette option, le compilateur recherche dans le code les commentaires spéciaux grâce au caractères ’’’ et les utilise pour générer le
fichier de documentation. Ce fichier est créé dans le répertoire dans lequel est généré le fichier compilé.
Evénements de build
Cette boîte de dialogue permet de configurer une commande pouvant être lancée automatiquement avant ou après la génération du projet.
Figure 29: événement du Build

Chacune des commandes peut être saisie dans la zone de texte correspondante. Les boutons modifier pré-build et Modifier post-build
ouvrent une fenêtre d’édition facilitant la saisie de la commande.
Cette boîte de dialogue propose également une liste de macros permettant la récupération et l’utilisation par votre commande de certains
paramètres du projet. L’exemple présenté sur la figure précédente effectue une copie complète du répertoire de l’application dans le
répertoire c:\sauvegarde avant chaque génération.
Page | 20
L’exécution de la commande après génération peut être conditionnelle et avoir lieu uniquement en cas de génération réussie ou si la
génération a mis à jour la sortie du projet.
Figure 30: ligne de Commande pré-build
Remarque :
Si une commande d’après génération doit exécuter un fichier (.bat), l’appel de celui-ci doit être précédé du mot clé call.
Options avancées de compilation
Cette option propose une boîte de dialogue permettant la configuration avancée du compilateur. (Figure [31])
Figure 31: Options Avancées de compilation
Cette boîte de dialogue permet la configuration des options suivantes :

• Supprimer la vérification de débordement lors des calculs sur les entiers ;
• Autoriser les optimisations de code lors de la compilation ;
• Spécifier l’adresse à laquelle une bibliothèque (.dll) sera chargée ;
• Indiquer si des informations de débogage sont ajoutés au résultat de compilation.
• Définir les constantes de compilation ;
• Demander la génération d’informations pour permettre la sérialisation XML.
Page | 21
2.3.5. Ressources d’un projet

Les ressources sont utilisées pour externaliser certains éléments d’une application. Elles permettent de réaliser rapidement des
modifications simples d’une application, sans avoir à rechercher dans des milliers de lignes de code. L’utilisation la plus classique consiste
à séparer, du code, les constantes de chaîne de caractères. Vous pouvez également créer des ressources icônes, images, fichiers texte, ou
audio. Toutes les ressources sont gérées par cette boîte de dialogue. (Figure [32]) :
Figure 32: Ressources d'un projet

• Pour chaque ressource, indiquez un nom et une valeur. Le nom sera bien sûr utilisé dans le code pour pouvoir récupérer la
valeur.
En fonction du type de la ressource, vous avez à disposition un éditeur adapté pour modifier la ressource. Les ressources peuvent être
liées ou embarquées, en fonction de leur type. Une ressource liée est stockée dans son propre fichier et le fichier Resources.resx contient
simplement un lien vers le fichier original. Une ressource embarquée est stockée directement dans le fichier Resources.resx de
l’application. Dans tous les cas, les ressources seront compilées dans l’exécutable de l’application.
Voyons maintenant comment accéder aux ressources à partir du code de l’application.
Toutes les ressources sont accessibles via la propriété ressources de l’objet My.
L’exemple suivant utilise :
• Une ressource chaîne de caractères (MessageBienvenuFr) ;
• Une ressource Icon (IconAppli) ; et
• Une ressource Image bitmap (ImageFond).
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Me.Icon = My.Resources.IconAppli
Me.BackgroundImage = My.Resources.ImageFond
MsgBox(My.Resources.MessageBienvenuFr)
End Sub
2.3.6. Paramètres d’application
Les paramètres d’application sont, en général, utilisés pour stocker et charger dynamiquement les paramètres de configuration d’une
application, comme par exemple, les préférences de l’utilisateur ou les derniers fichiers utilisés dans l’application.
Les paramètres doivent d’abord être crées dans la page de propriétés suivante (Figure [ ]) :
Figure 33: Paramètres d'application

Pour chaque paramètre, vous devez fournir un nom, utilisé pour manipuler le paramètre dans le code et un type, pour le paramètre.
Vous devez également fournir une portée pour le paramètre. Deux choix sont possibles :
• Utilisateur : Le paramètre peut être modifié pendant le fonctionnement de l’application ;
• Application : Le paramètre est en lecture seule pendant l’exécution et peut uniquement être modifié par l’intermédiaire de cette
boîte de dialogue.
La dernière chose à faire est de spécifier une valeur pour le paramètre.
Nous allons maintenant étudier comment manipuler les paramètres dans le code.
Nous devons réaliser trois opérations :
• Au démarrage de l’application, nous devons charger les paramètres. L’accès aux paramètres se fait par la propriété Settings
de l’objet My.
My.Sttings.Reload()
Page | 22
• Pendant l’exécution de l’application, nous avons accès aux paramètres également par la propriété mentionnée précédemment, à
laquelle nous ajoutons le nom du paramètre. Ceci nous permet la lecture de la valeur du paramètre ou l’affectation d’une valeur
au paramètre.
Me.BackColor=My.Settings.CouleurFond
My.Settings.DerniereUtilisation=Now
• A la fermeture de l’application, nous devons enfin sauvegarder les paramètres en utilisant la méthode Save ;
My.Sttings.Save()
Pour chaque utilisateur de l’application, une version distincte des paramètres est sauvegardée.
2.3.7. Autres paramètres de configuration
Les autres rubriques de configuration du projet concernant le déploiement de l’application seront traitées dans un chapitre spécifique.
Page | 23

Chapitre 1-Organisation D'une Application

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 1-Organisation D'une Application

Transféré par

Droits d'auteur :

Formats disponibles

Vb.

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Signé Signé Signé

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Liste des Figures

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 1: Création d'une solution

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 2: Création d'un nouveau projet

Figure 3: Menu Ajout d'un projet Existant

Figure 4: Exemple de projet existant

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

NB : le projet ajouté reste à son emplacement d’origine dans le disque.

NB : Après Suppression, le projet est éliminé de la solution, mais reste enregistré

Figure 5: Supression d'un projet

Figure 6: Décharger un projet

Figure 7: Organisation d'une solution

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

1.4.1. Créer un dossier de solution

Figure 8: Dossier de solution

1.4.2. Créer un projet dans un dossier

Figure 9: Projet dans un dossier

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 10: Fichiers divers

Figure 11: Configuration d'une solution

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 12: Dépendances d'un projet

Figure 13: Dépendance circulaire

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

1.7.3. Paramètres d’analyse de code

Figure 14: Paramètres d'analyse de code

Figure 15: Fichiers sources pour le débogage

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 16: Propriétés de configuration d'une solution

Figure 17: Création d'un nouveau projet

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

2.1.1. Les modèles de projets

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

• Une classe de base avec sa source class1.vb

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

2.1.3. Utilisation d’un projet existant comme modèle

Figure 18: Assistant Exportation de Modèle

Figure 19: Options du Modèle

Figure 20: Nouveau Modèle Disponible dans Visual Studio

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 21: Configuration des Modèles de Projets dans Visual Studio

Figure 22: Ajout d'un nouvel élément au projet

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

• Indiquez ensuite un nom pour le fichier contenant le nouvel élément.

Figure 23: Ajout d'éléments existants

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

2.3. Propriétés des projets

Figure 24: Propriétés d'application

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Espaces de noms racine

Figure 25: Informations de l'Assembly

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 26: Références et Importations du Projet

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f

Figure 27: Propriétés de débogage

Version : 01 Auteur : Sami Ben Aissia Code=bff74eae42dc441d988284da3acf482f