VB.Net 2005 : le namespace My
Date de publication : 02/09/2005
Par
Ronald VASSEUR (autres articles)
Introduction
1. Présentation du namespace My
1.1. My.Application
1.2. My.Computer
1.3. My.Forms
1.4. My.Settings
1.5. My.User
1.6. My.WebServices
1.7. Objets spécifiques à ASP.Net
2. Extensibilité du namespace My
3. Utiliser le namespace My en C#
4. Ressources
4.1. Code source
4.2. Documentation MSDN
Conclusion
Introduction
Visual Basic, dans sa version 2005, introduit un nouveau namespace nommé My. Ce namespace a pour
caractéristique d'être un point d'accès rapide à tout un tas de classes du Framework, notamment
à de nombreuses classes couramment utilisées par les développeurs VB.Net. Les deux objectifs de ce
namespace sont en fait de réduire le nombre de lignes de code nécessaire, tout en simplifiant l'accès
à un certain nombre de fonctionnalités. My est composé de neuf objets principaux qui sont agencés selon
de grands thèmes, en voici la liste :
- My.Application
- My.Computer
- My.Forms
- My.Settings
- My.User
- My.WebServices
- My.Log
- My.Request
- My.Response
Nous ferons une présentation plus précise de ces catégories plus tard dans cet article. Mais ce qu'il faut
d'ores et déjà comprendre, c'est qu'il ne s'agit en aucun cas de nouvelles classes, mais en quelque sorte
de raccourcis vers des classes existantes du Framework .Net 2.0. L'avantage sera donc bien évidemment
une plus grande productivité car il sera plus facile d'accéder à des fonctionnalités fréquemment
utilisées, de plus de par l'organisation de ce namespace, le cheminement dans la recherche d'un objet
précis est plus intuitif, ce qui n'est pas forcément toujours le cas sur la totalité de l'immense
Framework; et enfin certaines fonctionnalités sont utilisables en écrivant moins de lignes de code,
si ce dernier point vous semble plus confus, ne vous inquiétez pas nous le verrons plus loin au
cours de cet article.
 |
Remarque : tout au long de cet article, je parlerai de namespace My et d'objet My.Application
ou My.User par exemple (c'est apparemment la terminologie finalement choisie par Microsoft), mais cette
dénomination n'est pas adoptée par tous. Il est fort possible, par exemple, que vous ayez entendu parlé
d'objet My au lieu de namespace My. Il reigne en la matière un petit flou, mais qui n'a aucune espèce
d'importance, et gageons que pour la version finale, Microsoft aura mis tout cela en ordre.
|
1. Présentation du namespace My
Dans cette première partie, nous allons voir les principaux objets du namespace My, en s'arrêtant sur
ses fonctionnalités principales et sur son champ d'action. Cela sera fréquemment illustré de petit exemples
montrant à quel point le namespace My peut augmenter votre productivité en matière du nombre de lignes de
code à réaliser. Passons donc de suite en revue les neuf principales catégories retenues dans le
namespace My.
1.1. My.Application
Cet objet fournit des méthodes et des propriétés permettant d'obtenir des informations sur l'application
courante, son environnement d'exécution, sa culture ou encore son assembly. Comme pour tous les autres objets du namespace My, certaines méthodes et
propriétés ne sont pas disponibles selon le mode de l'application (Console, WinForms,...), tout cela est
détaillé dans la documentation. L'objet My.Application utilise une terminologie claire et intuitive, ainsi aidé
de l'IntelliSense, vous n'aurez pas de difficulté à l'utiliser, et ce, même sans la documentation. Avec
l'objet MyComputer, l'objet My.Application est sûrement celui que vous utiliserez le plus fréquemment.
Cet objet n'est pas utilisable dans les applications ASP.Net.
Voici une impression d'écran des méthodes et propriétés proposées par My.Application :
 Méthodes et propriétés de My.Application
Exemples d'utilisation de cet objet :
Je ne pense pas qu'il soit utile de commenter à outrance ces deux exemples de code, ils sont extrêmement
simples, ils consistent en deux fonctions retournant respectivement, le chemin complet du répertoire
où se situe l'exécutable de votre application et le nom de l'assembly de votre application.
Récupération du répertoire courant de l'application : Public Function getRepertoireAppli() As String
Dim maString As String = String.Empty
maString = My.Application.Info.DirectoryPath
Return maString
End Function
Récupération du nom de l'assembly : Public Function getNomAssembly() As String
Dim maString As String = String.Empty
maString = My.Application.Info.AssemblyName
Return maString
End Function
Passons maintenant à l'objet My.Computer, qui avec l'objet My.Application vous sera trés utile.
1.2. My.Computer
L'objet My.Computer est, selon moi, le plus utile dans les "developpements de tous les jours", en effet
il permet d'accéder à une foule d'information a propos de la machine sur laquelle s'exécute votre
programme et de plus il offre un accès direct aux composants principaux tels la carte réseau, la carte
son, le système de fichier, le registre...
Voyons rapidement deux exemples illustrant l'utilisation de cet objet.
 Méthodes et propriétés de My.Computer
Exemples d'utilisation de cet objet :
Ci dessous voilà un morceau de code permettant de récupérer le nom de la machine
où s'exécute votre application.
Récupération du nom de la machine : Public Function getNomMachine() As String
Dim maString As String = String.Empty
maString = My.Computer.Name
Return maString
End Function
Le code suivant permet de réaliser la copie du contenu d'un répetoire. Pour ceux ayant déjà voulu
copier l'ensemble des fichiers d'un répertoire, ils savent que c'est une chose qui n'est
forcément trés simple à mettre en oeuvre et qui tient sur plusieurs lignes de code. Ici, de part
l'apport du My, on voit que l'on possède une méthode (CopyDirectory) toute prête. En une ligne de
code, il est desormais possible de réaliser cette opération. Cette méthode repose sur les mêmes
méthodes que vous utilisez tous les jours pour faire de la copie de fichiers, mais le namespace
My apporte une grande simplicité à cette opération.
Copie du contenu d'un répertoire : Public Function copieRepertoire(ByVal repSource As String, ByVal repDestination As String) As Boolean
Try
My.Computer.FileSystem.CopyDirectory(repSource, repDestination, True, FileIO.UICancelOption.DoNothing)
Return True
Catch ex As Exception
Return False
End Try
End Function
Enfin, voici le troisième et dernier exemple, qui permet de lire un fichier audio, vous
voyez ici que l'on peut difficilement faire plus simple. Le namespace My montre, dans cet
exemple, à quel point il peut se montrer pratique.
Lecture d'un fichier Wave : Public Function jouerSon() As Boolean
Try
My.Computer.Audio.Play("c:\maMusique.wav", AudioPlayMode.Background)
Return True
Catch ex As Exception
Return False
End Try
End Function
Allez, on continue notre tour d'horizon du My, maintenant le My.Forms...
1.3. My.Forms
My.Forms offre un accès à l'ensemble des formulaires de votre application. Les fonctionnalités qu'il offre
sont très nombreuses, mais nous les aborderons pas car vous y êtes fréquemment confrontés lors
de la réalisation des interfaces grahiques de vos applications .Net. Cet objet n'est pas utilisable dans
les applications ASP.Net.
 Méthodes et propriétés de My.Forms
Exemple :
Cet exemple vous montre comment griser le bouton "maximize" de la Form1.
Activation ou désactivation du bouton 'Maximize' de la Form1 Public Function maximizeForm(ByVal valeur As Boolean) As Boolean
Try
My.Forms.Form1.MaximizeBox = valeur
Return True
Catch ex As Exception
Return False
End Try
End Function
1.4. My.Settings
L'objet My.Settings permet d'accéder aux paramètres des fichiers de configuration
de l'application et de l'utilisateur. Il vous permettra par exemple de récupérer la
valeur d'une chaine de connexion ou d'un mot de passe dans un fichier utilisateur.
Cet objet n'est pas utilisable dans les applications ASP.Net.
Voici une copie d'un fichier de configuration contenant une seule clé (maChaine1) :
Contenu du fichier de configuration Settings.settings : <?xml version="1.0" encoding="utf-8" ?>
<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
<Profiles>
<Profile Name="(Default)" />
</Profiles>
<Settings>
<Setting Name="maChaine1" Type="System.String" Scope="Application">
<Value Profile="(Default)">ma chaine numéro 1</Value>
</Setting>
</Settings>
</SettingsFile>
Exemples :
Les exemples suivants permettent de récupérer et de modifier la valeur
de la clé "maChaine1" dans le fichier de configuration d'une application.
Lecture d'un paramètre dans le fichier de configuration : Public Function getMySetting() As String
Dim monParam As String = String.Empty
monParam = My.Settings.Item("maChaine1").ToString
Return monParam
End Function
Ecriture d'un paramètre dans le fichier de configuration : Public Function setMySetting(ByVal monParam As String) As String
My.Settings.Item("maChaine1") = monParam
Return monParam
End Function
Maintenant vient le tour de l'objet My.User...
1.5. My.User
Les deux méthodes et les trois propriétés de l'objet My.User vous permettent d'accéder
aux informations essentielles relatives à l'utilisateur courant de votre application.
Cet objet permet de savoir comment est authentifié l'utilisateur, qui il est, et quel
utilisateur est utilisé par votre application pour s'exécuter.
Exemple d'utilisation de l'objet My.User :
Cet exemple permet simplément de retourner dans une chaîne de caractères le nom de
l'utilisateur authentifié.
Récupération du nom de l'utilisateur courant : Public Function getUtilisateur() As String
Dim monUtilisateur As String = String.Empty
monUtilisateur = My.User.Name
Return monUtilisateur
End Function
Allez, on s'accroche ! Et on passe à My.WebServices...
1.6. My.WebServices
Cet objet vous permet d'accéder aux Web Services référencés dans votre projet. Attention, cette
fonctionnalité n'est pas accessible dans les applications ASP.Net. Il est ainsi possible
de faire appel à une instance d'un WebService en une seule ligne de code. Une fois de plus, vu
l'intuitivité de l'objet My.WebService, nous entrerons pas dans les détails. Sachez seulement
que pour ajouter un Web Service à votre projet, vous devez utiliser "Ajouter une référence Web"
dans l'explorateur de solution de Visual Studio 2005, puis vous laisser guider par l'assistant.
Pour consommer ce Web Service, il vous reste plus qu'à utiliser la ligne de code My.WebServices."nom du web service".
"nom de la méthode souhaitée", l'IntelliSense vous listera les Web Services référencés dans votre projet, ainsi que
leur méthodes respectives.
Passons maintenant aux objets du namespace My qui sont spécifiques à ASP.Net.
1.7. Objets spécifiques à ASP.Net
Les objets que nous allons voir dans cette partie appartiennent également au namespace My
mais ne sont utilisable qu'avec les applications ASP.Net, cela signifie qu'ils ne seront pas dans une application WinForm
ou console. Ces trois objets sont My.Log, My.Request et My.Response. Ils regroupent un bon nombre
de fonctionnalités que les developpeurs Web sont appellés à utiliser fréquemment, voyons cela sans
plus tarder, en commencant par l'objet My.Log.
Cet objet est équivalent aux fonctionnalités en matière d'accès aux fichiers log
fournies par My.Application, mais il a la particularité d'être dédié aux applications
ASP.Net. Il permet notamment d'inscrire des informations relatives au fonctionnement
de votre application et aux exceptions qui y sont levées directement dans le fichier
Log. Le gain intéressant apporté ici par le namespace My est que cette opération
est effectuée en une seule ligne de code ! Qui dit mieux ?
Tout comme l'objet My.Log, les objets My.Request et My.Response sont spécifiques
à ASP.Net. Ce qui est tout à fait logique car vu leur nature ils seraient
absolument inutile en WinForms.... :). Voyons deux exemples qui montrent
comment utiliser cet objet
Exemples d'utilisation de My.request :
Le premier exemple nous montre simplement comment récupérer le chemin physique
complet de notre application.
Récupération du chemin physique de l'application sur le serveur : Public Function getCheminPhysique() As String
Try
Dim cheminPhysique As String = String.Empty
cheminPhysique = My.Request.PhysicalApplicationPath
Return cheminPhysique
Catch ex As Exception
Return "Une erreur est survenue."
End Try
End Function
Dans une optique de statistique ou de contrôle de fonctionnement, il peut être
intéressant d'accéder aux différentes variables du serveur, nous allons voir
ici comment récupérer trés simplement l'ensemble de ces varaibles à l'aide
de My.Request.
Récupèration de la liste des variables serveur : Public Function getVariablesServeur() As String
Dim maListe As Array
Dim mesVariablesServeur As New StringBuilder
Dim uneVariableServeur As String = String.Empty
Dim maChaineVariables As String = String.Empty
Try
maListe = My.Request.ServerVariables.AllKeys
For Each uneVariableServeur In maListe
mesVariablesServeur.Append(uneVariableServeur & "</BR>")
Next
maChaineVariables = mesVariablesServeur.ToString
Return maChaineVariables
Catch ex As Exception
Return ex.Message
End Try
End Function
Exemples d'utilisation de My.Response :
Récupération de l'encodage du header : Public Function getEncodageHeader() As String
Dim monHeader As String = String.Empty
Try
monHeader = My.Response.HeaderEncoding.HeaderName
Return monHeader
Catch ex As Exception
Return ex.Message
End Try
End Function
Récupération de la durée d'expiration de la page dans le cache : Public Function getDureeCache() As String
Dim dureeCache As String = String.Empty
Try
dureeCache = My.Response.Expires.ToString
Return dureeCache
Catch ex As Exception
Return ex.Message
End Try
End Function
Voilà, nous avons fait le tour de l'ensemble des objets que nous propose le namespace My.
Je ne suis pas trop rentré dans le détail pour éviter d'allourdir l'article, en effet,
ce namespace seul pourrait faire l'objet d'un livre complet si l'on souhaitait être
exhaustif. Si vous souhaitez connaître en détails les méthodes et propriétés de ces
neuf objets, je vous renvoie à la lecture de la documentation, vous trouverez tous
les liens nécessaires dans la partie "Documentation MSDN" de cet article.
Aprés avoir vu comment utiliser ce que nous propose nativement le namespace My, voyons
comment nous pouvons y ajouter nos propres objets, méthodes et propriétés.
2. Extensibilité du namespace My
Le namespace My contient un nombre très important "de raccourcis" vers
les fonctionnalités du Framework .Net fréquemment utilisées, mais dans le
cadre de vos développements vous pouvez être (vous l'êtes d'ailleurs sûrement)
appelé à utilisé fréquemment les mêmes méthodes et les mêmes morceaux de code.
On se rend donc compte qu'il pourrait être intéressant de pouvoir intégrer ces
propres méthodes et autres classes directement dans le namespace My. Et comme
d'habitude en .Net, tout est possible ! et nous allons voir que cela n'est
vraiment pas complexe à réaliser. Je vais vous présenter un exemple "d'extension"
du namespace My en y intégrant une de mes classes. En fait pour réaliser cette
opération, il n'y a rien de particulier à faire si ce n'est de rajouter les deux
lignes de codes suivantes respectivement en début et en fin de votre classe.
Classe étendant le namespace My à mes propres objets : Namespace My
Public Class maClasse
Public Sub New()
End Sub
Public Shared Function getNbElementsListe() As Integer
Dim maListe As New ArrayList
Dim nbListe As Integer
maListe.Add("un")
maListe.Add("deux")
maListe.Add("trois")
nbListe = maListe.Count
Return nbListe
End Function
End Class
End Namespace
Inutile de préciser que le code de cette classe est minimaliste et d'une utilité
bien discutable… mais ce n'est pas l'objectif de cet exemple. Compilons maintenant
notre code et voyons si nous avons bien ajouté notre classe et sa méthode au
namespace My. Pour cela, par exemple insérez un bouton, et dans son évènement _click,
tapez My. Et l'IntelliSense vous affiche alors la liste des objets disponibles
pour la namespace My, vous pouvez voir que votre classe nommée "maClasse"
apparait et qu'elle contient une méthode getNbElementsListe.
Il est bien évident que ce code simpliste n'est là que pour illustrer mes propos,
et de plus le NameSpace a pour vocation première de servir de "raccourci" vers
des objets fréquemment utilisés, donc il faut étendre le Namespace My quand c'est
réellement nécessaire et dans les mêmes conditions que ce qui est en place dans
le Framework 2.0, sous peine de semer la confusion, surtout si vous travaillez en équipe.
Nous avons vu ici qu'étendre le namespace My est une grande simplicité et j'espère
que vous aurez vu ce que cela peut vous apporter dans vos développements de tous les jours.
3. Utiliser le namespace My en C#
Le namespace My a été spécifiquement conçu pour Visual Basic 2005 et il s'appuie en partie
sur de nombreuses classes qui se trouve dans l'assembly Microsoft.VisualBasic.dll. En
théorie, comme pour toute assembly .Net il est possible d'y faire référence et de
l'utiliser dans un projet C# ou autre, mais dans la pratique les choses sont sensiblement
différentes. En effet, cette assembly contient des spécificités propres à Visual Basic 2005,
donc qui ne fonctionneront qu'avec ce langage. Pour résumer les choses, il est tout à fait
possible d'utiliser le namespace My avec C# en ajoutant simplement une référence vers
l'assembly Microsoft.VisualBasic.dll à votre projet dans Visual Studio, mais un certain
nombre de fonctionnalités de My ne seront pas présente, car spécifiques à Visual Basic 2005.
  |
Remarque : Cette utilisation restreinte du namespace My avec C# tient au fait que les compilateurs de
C# et de VB.Net présentent des différences. L'assembly Microsoft.VisualBasic.dll faisant appel
à des spécificités du compilateur VB.Net, le compilateur C# ne sera alors pas à même d'y
faire face. Cela est dans l'absolu facilement compréhensible par le fait que même si le
namespace My repose sur .Net, il n'est implémenté que dans Visual Basic 2005.
|
4. Ressources
4.1. Code source
Voici un fichier Zip contenant les fichiers mesMethodes.vb et maClasse.vb correspondant à l'intégralité
du code présent dans cet article.
4.2. Documentation MSDN
Voici les liens pointant vers la documentation MSDN relative au namespace My et aux objets s'y rattachant.
Cette documentation n'est pour le moment pas définitive et est succeptible d'évoluer d'ici la sortie
de la version finale du Framework .Net 2.0.
Conclusion
Comme nous l'avons vu au cours de cet article, le namespace My n'est pas une révolution dans
Visual Basic 2005, mais indéniablement de par sa conception, il va permettre d'accroître encore
un peu plus la productivité des developpeurs VB.Net. Le namespace couvre un champ de fonctionnalités
et d'objets suffisament large pour que chaque développeur y retrouve les objets qu'il utilise de
manière récurrente, de plus, on a vu que si besoin il était possible d'étendre le namespace My à
ses propres objets, ce qui peut être trés utile dans certains cas. Les developpeurs C# pourront aussi
bénéficier si nécessaire du namespace My, mais l'on a vu que cela n'est pas recommandé et que
la compatibilité totale n'est pas assurée pour des raisons tenant aux spécifités intrinsèques de
cette nouveauté de Visual Basic 2005.
J'espère vous avoir montré au cours de cet article l'utilité du namespace My qui devient vite un
réflexe et apporte un "confort" de programmation, ce qui dans le cadre d'une pratique intensive,
n'est pas négligeable.
Un grand merci à Freegreg pour la relecture de cet article.
|
