Résumé : présentation de la façon dont la fonction My expose les fonctionnalités du .NET Framework, y compris les classes disponibles, les classes générées dynamiquement et les threads.
Remarque : Cet article et cet exemple de code sont basés sur la version préliminaire de Microsoft Visual Studio 2005 (anciennement nommée « Whidbey »). Toutes les informations contenues dans ce document sont susceptibles de changer. L'exemple de projet nécessite Visual Studio 2005Beta1 ou version ultérieure.
Introduction
My est une nouvelle fonctionnalité de Visual Basic 2005 qui met à portée de main les fonctionnalités fréquemment utilisées et réduit le nombre de lignes de code que vous devez écrire. Il le fait de manière efficace, fiable et thread-safe. Dans un environnement où la productivité des programmeurs est particulièrement importante, My peut vous aider à terminer votre travail plus rapidement. C'est l'essence même de Visual Basic.
Le but de cet article est d’explorer comment utiliser My pour accéder aux fonctionnalités et aux éléments de .NET Framework dans votre projet.
Classes .NETFramework disponibles depuis My
Étant donné les nombreuses implications du .NET Framework, il peut être difficile de trouver les fonctionnalités dont vous avez besoin. Pour résoudre ce problème, My fournit des points d’entrée aux classes et fonctions .NET Framework couramment utilisées. My expose également de nouvelles classes .NET Framework de haut niveau qui regroupent les fonctionnalités associées dans des API basées sur des tâches.
My expose les fonctionnalités en renvoyant une classe .NETFramework instanciée et prête à l'emploi, en différant les appels aux méthodes .NETFramework et en renvoyant des classes générées dynamiquement qui peuvent être utilisées pour accéder aux éléments de votre projet.
Directement public
Dans la mesure du possible, My sert de mécanisme de découverte pour les classes existantes dans le .NET Framework et expose directement ces types. Consultez l’exemple My.application.Deployment suivant :
PublicReadOnlyPRpertyDeployment()As_
System.Deployment.ApplicationDeployment
Obtenir
Retour_
System.Deployment.ApplicationDeployment.CurrentDeployment
FinObtenir
Propriété de fin
D'autres exemples d'exposition directe incluent My.Computer.FileSystem.OpenTextFileReader() (qui renvoie System.IO.StreamReader), My.Application.OpenForms() (qui renvoie System.Windows.Forms.FormsCollection), My.User (qui renvoie System.Security.Principal.IPrincipal), etc.
Apparence
My peut également renvoyer de nouvelles classes qui fournissent une API basée sur des tâches pour effectuer des opérations qui étaient auparavant difficiles à réaliser car la recherche de fonctionnalités était difficile et/ou nécessitait la collaboration de plusieurs objets.
Les tâches courantes qui nécessitent l'utilisation de l'API .NET Framework de bas niveau ou qui nécessitent plusieurs lignes de code sont considérablement simplifiées. Consultez l'exemple de tâche suivant pour déterminer si une connexion réseau est disponible :
ImportsSystem.Net.NetworkInformation
PublicReadOnlyPropertyIsAvailable()AsBoolean
Obtenir
ForEachNetInterfaceAsNetworkInterfaceIn_
NetworkInterface.GetAllNetworkInterfaces()
IfNetInterface.Type<>InterfaceType.Loopback_
AndAlsoNetInterface.Type<>InterfaceType.Tunnel_
AndAlsoNetInterface.OperationalStatus=_
OperationalStatus.UpThen
RetourVrai
FinSi
Suivant
RetourFaux
FinObtenir
Propriété de fin
Le code ci-dessus nécessite une connaissance détaillée de plusieurs types dans l'espace de noms System.Net.NetworkInformation. À l'aide du modèle d'apparence, My.Computer.Network réduit ces types et leurs relations à une seule ligne de code : My.Computer.Network.IsAvailable().
Les apparences peuvent également simplement rassembler des fonctionnalités connexes qui seraient autrement difficiles à trouver. Par exemple, My.Computer regroupe les propriétés de différentes classes pour fournir le nom de l'ordinateur et l'accès à l'écran :
PublicReadOnlyPropertyName()AsString
Obtenir
ReturnSystem.Environment.MachineName
FinObtenir
Propriété de fin
PublicReadOnlyPropertyScreen()AsSystem.Windows.Forms.Screen
Obtenir
ReturnSystem.Windows.Forms.Screen.PrimaryScreen
FinObtenir
Propriété de fin
D'autres exemples de classes dans My qui rassemblent des fonctionnalités associées à partir de plusieurs types de .NET Framework incluent My.Application, My.Computer, My.Computer.FileSystem, My.Computer.Info et My.Application.Info.
Classe proxy
La classe proxy est une classe très « fine » qui transmet tous les appels à l’objet de base. Par exemple, si vous appelez My.Computer.Clipboard.GetText(), vous appelez en fait la méthode de classe proxy ClipboardProxy.GetText(), définie comme suit :
PublicFunctionGetText()AsString
ReturnClipboard.GetText()
FinFonction
Par convention, les classes proxy portent toujours le suffixe Proxy. My utilise des proxys lors de l'accès au presse-papiers, au système de fichiers et au registre, car les classes de base exposées par les proxys sont composées de méthodes partagées qui ne sont pas visibles dans IntelliSense. La classe Proxy ne peut pas être instanciée par l'utilisateur. Les tests de performances ont montré que le transfert d'appels via un proxy n'a aucun sens.
Classes générées dynamiquement
Conformément à l'objectif de « mettre les fonctionnalités à portée de main », My donne accès aux formulaires, aux services Web, aux ressources et aux paramètres définis dans votre projet. Par exemple, si votre projet contient une référence au service Web MapDirections, vous pouvez utiliser le service Web immédiatement sans avoir à savoir comment démarrer une instance du proxy du service Web. Tapez simplement ce qui suit : My.WebServices.MapDirections.GetDirections(...)
Comment cela marche-t-il? Les classes Factory sont générées par un compilateur qui renvoie à la demande des instances créées paresseusement pour les formulaires, les services Web, les paramètres et les ressources de votre projet. La classe factory est adaptée pour renvoyer des instances d'une manière adaptée au type de projet (exe/dll/web) dans lequel votre code s'exécute. Voir la section "Threading" pour plus de détails.
Mes.Forms
Comme exemple de classe générée dynamiquement, considérons My.Forms. Cette classe vous est fournie et définit les méthodes d'usine pour chaque formulaire de votre projet. Lorsque vous accédez au formulaire via My.Forms.Form1, la méthode d'usine vérifie si une instance de Form1 est déjà ouverte. Si une instance est déjà ouverte, cette instance est renvoyée. Sinon, une instance de Form1 est créée et renvoyée. Le code généré pour le projet contenant Form1 ressemble à ceci :
ClasseMesFormulaires
'Codeen grasgénéréparlecompilateur
Publicm_Form1AsForm1
PublicPropertyForm1()AsForm1
Obtenir
m_Form1=Créer__Instance__(OfForm1)(m_Form1)
Retourm_Form1
FinObtenir
Ensemble (ByValValueAsForm1)
IfValueIsm_Form1
Retour
FinSi
SiNotValueIsNothingThen
ThrowNewArgumentException(_
La propriété ne peut correspondre qu'à rien.)
FinSi
Disposer__Instance__(OfForm1)(m_Form1)
Ensemble de fin
Propriété de fin
Classe de fin
La fonction Create__Instance__() est chargée de créer des instances du formulaire à la demande. Il vérifie si le formulaire (stocké dans m_Form1) a été instancié. Si le formulaire a déjà été instancié, le formulaire est renvoyé. Sinon, une instance est créée et renvoyée. Create__Instance__() capture également les tentatives de création de formulaires récursifs. Dispose__Instance__() est responsable de la fermeture du formulaire.
My.Forms fournit également une méthode permettant de réintroduire une instance par défaut d'un formulaire, que vous connaissez peut-être dans les versions antérieures de Visual Basic. Les instances par défaut permettent de référencer une instance d'un formulaire sans créer explicitement au préalable une instance du formulaire.
Par exemple, dans Visual Basic 6.0, vous auriez peut-être écrit Form1.Show() à la place :
DimForm1InstanceasForm1
Form1Instance=nouveauForm1
Form1Instance.Show()
Étant donné que le compilateur de Visual Basic 2005 utilise My.Forms pour créer des instances par défaut, vous pouvez simplement écrire Form1.Show().
Mes.WebServices
L’une des difficultés rencontrées par les utilisateurs lors du codage de services Web est de déterminer la classe à utiliser. My.WebServices élimine ce processus de détermination et fournit des instances de proxys de services Web à la demande.
My.WebServices est le mieux adapté aux appels synchrones vers des services Web. Le modèle de code généré pour fournir une instance du proxy de service Web est le même que le modèle de code affiché pour renvoyer une instance du formulaire.
Mes.paramètres
La nouveauté de Visual Basic 2005 est le Concepteur de paramètres, qui vous permet de spécifier les paramètres d'application par application ou par utilisateur. Le concepteur crée une classe que vous pouvez utiliser pour accéder à vos paramètres de manière fortement typée. Vous pouvez voir un exemple de la classe MySettings en affichant Tous les fichiers dans l'Explorateur de solutions et en recherchant le fichier MySettings.vb sous le nœud MySettings.Settings.
Voici un exemple de propriété générée pour gérer un paramètre d'application nommé SampleUserSetting :
PartialNotInheritableClassMySettings
InheritsSystem.Configuration.ApplicationSettingsBase
<System.Diagnostics.DebuggerNonUserCode(),_
System.Configuration.UserScopedSettingAttribute(),_
System.Configuration.DefaultSettingValueAttribute(TryMe)>_
PublicPropertySampleUserSetting()AsString
Obtenir
ReturnCType (Moi (SampleUserSetting), Chaîne)
FinObtenir
Ensemble
Moi (SampleUserSetting) = valeur
Ensemble de fin
Propriété de fin
Classe de fin
Les classes générées font tout le gros du travail à votre place. Pour accéder à ce paramètre, tapez simplement :
Mes.Paramètres.SampleUserSetting
Mes.Ressources
Une autre nouvelle fonctionnalité de Visual Basic 2005 est le Resource Designer, qui vous permet d'ajouter des ressources à votre application. Le Resource Designer crée également un module que vous pouvez utiliser pour accéder aux ressources de votre application de manière fortement typée. Par exemple, si vous ajoutez un bitmap nommé Smiley à votre projet, vous pouvez accéder au bitmap à l'aide de My.Resources.Smiley. Vous pouvez voir un exemple du module de ressources généré en affichant Tous les fichiers dans l'Explorateur de solutions de l'exemple de projet et en recherchant le fichier MyResources.vb sous le nœud MyResources.resx.
Voici un exemple d'exemple de projet généré pour renvoyer une propriété d'usine pour une ressource Smiley :
PublicReadOnlyPropertySmiley()AsSystem.Drawing.Bitmap
Obtenir
ReturnCType(ResourceManager.GetObject(Smiley,_resCulture),_
Système.Dessin.Bitmap)
FinObtenir
Propriété de fin
Le module de ressources fortement typé généré gère les ID de ressources sensibles à la casse, utilise la classe System.Resources.ResourceManager pour récupérer vos ressources et gère les détails liés à la création correcte du ResourceManager pour votre application.
Pour accéder au même bitmap Smiley dans VisualBasic2002 ou VisualBasic2003, vous devez d'abord placer le bitmap dans un fichier .resx, ce qui est difficile. Une autre façon consiste à l'insérer dans le projet en tant que ressource intégrée et vous devez vous rappeler de modifier l'action de construction dans la grille des propriétés de la ressource qui sera la ressource intégrée. De cette façon, le code que vous écrivez devrait ressembler à ceci :
DimCurrentAssemblyAsReflection.Assembly=_
Réflexion.Assembly.GetExecutingAssembly
DimBitMapStreamAsIO.Stream=_
CurrentAssembly.GetManifestResourceStream(_
WindowsApplication2.Smiley.bmp)
DimSmileyBitmapasDrawing.Bitmap=NewBitmap(BitMapStream)
Il y a quelques détails importants dans ce code que vous devez connaître. Vous devez savoir obtenir l'assembly en cours d'exécution et appeler GetManifestResourceStream() dessus. N'oubliez pas de qualifier les noms de ressources avec le nom de l'espace de noms racine. Vous devez obtenir l'autorisation de casse car le nom transmis à GetManifestResourceStream() est sensible à la casse. Vous devez savoir où définir la classe stream afin de pouvoir capturer la valeur de retour de GetManifestResource dans l'objet stream. Vous devez savoir comment créer un bitmap à partir d'un flux. Vous pouvez rencontrer de la frustration lorsque vous essayez de déterminer pourquoi un BitMapStream renvoie toujours Nothing en raison de l'un des problèmes ci-dessus.
Visual Basic 2005 résout le premier problème en fournissant ResourceEditor, qui facilite le placement de ressources nouvelles ou existantes dans des fichiers .resx. Ces ressources sont ensuite facilement accessibles via My. Tout ce que vous avez à faire est d'écrire ce qui suit :
DimSmileyBitmapasDrawing.Bitmap=Mes.Resources.Smiley
Enfilage
Les instances de classe disponibles dans My sont exposées de manière à atténuer les problèmes de thread, car les instances des objets My sont fournies thread par thread. Autrement dit, l'instance de My.Computer renvoyée sur le thread 1 est différente de l'instance de My.Computer renvoyée sur le thread 2. Cela signifie que vous n'avez pas besoin d'écrire de code de synchronisation lorsque vous utilisez l'objet My.
Dans une application Web, l'instance renvoyée par My est stockée sur demande.
résumé
Nous avons examiné comment My expose les classes .NET Framework et comment des classes générées dynamiquement peuvent être générées pour compléter My.
Enfin, My réduit le nombre de lignes de code que vous devez écrire et donne accès aux fonctionnalités couramment utilisées. Il le fait de manière efficace, fiable et thread-safe. Dans un environnement où l'efficacité du travail des programmeurs est particulièrement importante, My peut vous aider à terminer votre travail plus rapidement et plus efficacement.
->