Exporter (0) Imprimer
Développer tout
1 sur 2 ont trouvé cela utile - Évaluez ce sujet

Chargement de classes à la volée

Billy Hollis

14 octobre 2002

Téléchargez le fichier exemple VBNETDynamicForms.exe depuis MSDN Code Center. Notez que les commentaires des programmeurs apparaissent en anglais dans les exemples de fichiers de programmes alors qu'ils sont traduits dans le présent article à des fins explicatives.

Résumé :Billy Hollis explore l'extensibilité de Microsoft .NET et vous indique comment charger dynamiquement des classes dans vos applications Visual Basic à l'aide de l'espace de noms System.Reflection.

L'idéal serait de savoir tout ce qu'un logiciel doit faire avant de le développer. Étant donné que cela n'est pas le cas, nos systèmes doivent pouvoir s'adapter.

L'adaptabilité maximale est la capacité à intégrer de nouvelles fonctionnalités à la volée. Dans une application Windows Forms, par exemple, cela correspond à la capacité de chargement de nouveaux formulaires créés bien après la compilation de l'application d'origine.

Dans Microsoft Visual Basic® 6.0, une telle opération était quasiment impossible, mais elle s'avère plutôt facile dans Visual Basic .NET. Grâce aux capacités de l'espace de noms System.Reflection, un programme peut demander le chargement des assemblys à la volée, ne serait-ce qu'en connaissant l'emplacement de l'assembly. Les classes de l'assembly peuvent alors être chargées et instanciées. Étant donné que Windows Form n'est jamais qu'une autre classe, ces formulaires peuvent être chargés, affichés et utilisés à la volée, même s'ils n'existaient pas lors de la compilation du programme d'origine.

Scénario type

Supposons que nous ayons une application d'interface multidocument (MDI, Multiple Document Interface) qui requiert la capacité de charger des formulaires arbitraires sous forme de formulaires enfants. L'application doit pouvoir effectuer les opérations suivantes :

  • Obtenir une liste de formulaires pouvant être chargés, généralement en dehors d'un fichier de configuration .NET.
  • Afficher la liste et permettre à l'utilisateur de sélectionner un formulaire.
  • Instancier et afficher le formulaire sélectionné par l'utilisateur.

Développons une application de ce type et étudions le chargement dynamique.

Étape 1 : Créer le projet et le formulaire MDI

Lancez un nouveau projet Windows Forms. Appelez-le FormsOnTheFly. Dans le Form1 vide du nouveau projet, remplacez sa propriété IsMdiContainer par True. Le formulaire devient alors un parent MDI. Redimensionnez ensuite le formulaire de telle sorte qu'il soit deux fois plus long et deux fois plus large que sa taille par défaut.

Faites glisser un panneau de contrôle sur le formulaire et paramétrez sa propriété Dock afin de l'ancrer en haut du formulaire. Redimensionnez le panneau de telle sorte qu'il mesure un demi-pouce de haut (1,27 cm).

Faites glisser une zone de liste déroulante sur le panneau. Appelez-la cboForms et paramétrez DropDownStyle sur DropDownList.

Pour finir, faites glisser un bouton sur le panneau. Appelez-le btnLoadForm et paramétrez sa propriété Text sur Load Form.

À ce stade, votre Form1 doit ressembler à la Figure 1.

Le Formulaire MDI en mode design après le placement de tous les contrôles.

Figure 1 : Le Formulaire MDI en mode design après le placement de tous les contrôles.

Étape 2 : Générer une classe pour inclure les données dans les formulaires disponibles.

Nous allons obtenir les informations relatives aux formulaires qui peuvent être chargés à partir d'un fichier de configuration XML. Cependant, pour faciliter l'affichage des formulaires disponibles dans la zone de liste déroulante et pour extraire les informations les concernant lors de la sélection d'un de ces formulaires, nous générerons une collection d'objets. Chaque objet contiendra les informations concernant un formulaire disponible. L'objet devra présenter les propriétés suivantes :

  • Description : description du formulaire qui s'affichera dans la zone de liste déroulante.
  • Emplacement : nom du fichier de la DLL où se trouve le formulaire.
  • Type : nom du type .NET du formulaire (tel que MyProject.Form1).

Une collection de ce type peut être liée aux données d'une zone de liste (voir Not Your Father's Databinding (leave-msdn france Site en anglais) pour plus d'informations). Pour renvoyer une référence à l'objet sélectionné depuis la zone de liste, une propriété supplémentaire est nécessaire, nous l'appellerons Reference.

Pour créer la classe, sélectionnez Project | Add Class et appelez la classe DynamicClass.vb. Placez le code suivant dans la classe :

Public Class DynamicClass

 Dim msLocation As String
 Dim msType As String
 Dim msDescription As String

 Public Sub New(ByVal sLocation As String, _ 
 ByVal sDescription As String, _
 ByVal sType As String)
 Me.Location = sLocation
 Me.Description = sDescription
 Me.Type = sType
 End Sub

 Public Property Location() As String
 Get
 Return msLocation
 End Get
 Set(ByVal Value As String)
 msLocation = Value
 End Set
 End Property

 Public Property Type() As String
 Get
 Return msType
 End Get
 Set(ByVal Value As String)
 msType = Value
 End Set
 End Property

 Public Property Description() As String
 Get
 Return msDescription
 End Get
 Set(ByVal Value As String)
 msDescription = Value
 End Set
 End Property

 Public ReadOnly Property Reference() As Object
 Get
 Return Me
 End Get
 End Property
End Class
Étape 3 : Générer un fichier de configuration pour y inclure les formulaires disponibles

Si une application doit connaître à l'exécution quelque chose qui n'est pas disponible lors de la compilation, les informations sont généralement placées dans un fichier de configuration. Dans Visual Basic 6.0, il s'agirait d'un fichier INI ou du Registre Windows. Dans .NET, un fichier de configuration XML est utilisé.

Nous ne pouvons pas détailler les fichiers de configuration car il s'agit d'un sujet complexe, mais vous devrez savoir que le fichier de configuration pour une application Windows Forms se trouve dans le même répertoire que l'exécutable de démarrage de l'application. Le nom est le même que cet exécutable de démarrage, suivi du suffixe .config, ce qui signifie, si mon application se lance en exécutant le programme MyApp.exe, que le fichier de configuration doit s'appeler MyApp.exe.config et se trouver dans le même répertoire que MyApp.exe.

Voici le fichier de configuration que nous utiliserons pour notre exemple :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
 <configSections>
 <section name="availableclasses"
 type="System.Configuration.NameValueSectionHandler" />
 </configSections>
 <availableclasses>
 <add key="Placeholder – do not load" 
 value="DLLPathnameGoesHere~NameOfTypeGoesHere"></add>
 </availableclasses>
</configuration>

À ce stade, la balise <availableclasses> contient uniquement des informations d'espace réservé vous permettant de visualiser le format. Nous ajouterons par la suite des informations de configuration pour les nouveaux formulaires créés.

Cette méthode n'est pas idéale pour inclure des informations de configuration concernant les formulaires puisque nous utilisons un format délimité pour conserver à la fois l'emplacement de la DLL et le nom de type au même endroit. Cependant, une méthode avancée pour les inclure séparément nécessiterait un peu plus d'explications et de code, nous nous contenterons donc de ce petit bricolage.

À l'aide d'un éditeur de texte ou d'un éditeur XML (ou Microsoft Visual Studio®), créez le fichier de configuration ci-dessus et sauvegardez-le sous le nom FormsOnTheFly.exe.config dans le répertoire \bin du projet FormsOnTheFly. À la création du fichier, assurez-vous du respect de la casse dans les balises XML, étant donné que les classes de configuration .NET utilisent des balises XML sensibles à la casse.

Étape 4 : Lire les informations de configuration dans une collection

Notre code pour le formulaire utilisera des classes provenant des espaces de noms System.Configuration et System.Reflection. Afin de faciliter l'accès à ces classes, placez les deux lignes suivantes au tout début du code du Form1 :

Imports System.Configuration
Imports System.Reflection

Nous avons également besoin d'une variable au niveau du module pour contenir notre collection d'informations de configuration. Placez la ligne suivante juste sous la ligne indiquant Inherits System.Windows.Forms.Form :

Dim colAvailableClasses As ArrayList

À présent, nous sommes prêts à écrire le code proprement dit. Dans l'événement Form Load du Form1, placez le code suivant pour lire le fichier de configuration, générez une collection d'objets contenant les informations et liez les données de collection à la zone de liste déroulante :

'Instanciez la collection pour les informations de configuration
colAvailableClasses = New ArrayList()

' Récupérez les éléments disponibles à charger depuis le fichier de config.
Dim ClassConfigValues As Specialized.NameValueCollection
ClassConfigValues = CType(ConfigurationSettings.GetConfig("availableclasses"), _ 
 Specialized.NameValueCollection)

Dim iIndex As Integer
Dim sLocation As String
Dim sDescription As String
Dim sType As String
Dim sValue As String

' Générez la collection d'éléments disponibles 
' pour les lier à la zone de liste déroulante.
For iIndex = 0 To ClassConfigValues.Count - 1
 sDescription = ClassConfigValues.Keys(iIndex)
 sValue = ClassConfigValues.Item(sDescription)

 ' Petit bricolage pour obtenir l'emplacement et 
 ' le type à partir d'un champ.
 Dim iPos As Integer
 iPos = InStr(sValue, "~")
 sLocation = Microsoft.VisualBasic.Left(sValue, iPos - 1)
 sType = Microsoft.VisualBasic.Right(sValue, Len(sValue) - iPos)

 Dim objNewForm As New DynamicClass(sLocation, sDescription, sType)
 colAvailableClasses.Add(objNewForm)
Next

' Liez maintenant la collection à la zone de liste déroulante.
' Organisez pour afficher la Description et renvoyez
' une référence à l'objet.
cboForms.DataSource = colAvailableClasses
cboForms.DisplayMember = "Description"
cboForms.ValueMember = "Reference"

Étape 5 : Insérer la logique pour charger un formulaire sélectionné

Dans l'événement click du bouton btnLoadForm, ajoutez la logique suivante :

Dim objFormToLoad As DynamicClass
objFormToLoad = cboForms.SelectedValue

Dim asmAssemblyContainingForm As [Assembly] = _
 [Assembly].LoadFrom(objFormToLoad.Location)
Dim TypeToLoad As Type = asmAssemblyContainingForm.GetType(objFormToLoad.Type)
Dim GenericInstance As Object
GenericInstance = Activator.CreateInstance(TypeToLoad)

Dim FormToShow As Form = CType(GenericInstance, Form)
FormToShow.MdiParent = Me
FormToShow.Show()

C'est le cœur du programme. En utilisant les informations provenant d'un des objets de la collection, ce code instancie et affiche un formulaire. Progressons ligne par ligne.

Nous obtenons d'abord une référence à l'objet (objFormToLoad) qui contient l'emplacement et le type du formulaire que nous souhaitons charger. Elle est définie comme la propriété SelectedValue de la zone de liste déroulante, qui est la propriété utilisée pour le renvoi d'une sélection depuis une zone de liste déroulante liée aux données.

L'objet contient l'emplacement de la DLL dans la propriété Location. Grâce à cette propriété, une référence à l'assembly est créée à l'aide de la méthode LoadFrom de la classe Assembly. (La classe Assembly est placée entre crochets, étant donné que Assembly est un mot clé .NET. Les crochets signalent au compilateur qu'il ne s'agit pas du mot clé utilisé, mais plutôt du nom de classe.)

Nous devons ensuite obtenir une référence vers le type .NET (classe) en cours de chargement. L'utilisation de la méthode GetType de l'assembly le permet en passant une chaîne contenant le nom du type (extrait de la propriété Type de l'objet contenant les données de configuration). La référence de type est stockée dans TypeToLoad.

Une autre classe Reflection, la classe Activator, utilise alors la méthode CreateInstance pour créer une instance du type. (CreateInstance rappelle CreateObject dans Visual Basic 6.0.) L'instance doit cependant être l'objet de type, étant donné que le type est chargé à la volée.

Pour finir, un cast du nouvel objet instancié (qui est en fait un formulaire) doit être effectué avec le type correct pour activer la liaison anticipée. Nous savons qu'il s'agit d'un formulaire, nous pouvons donc effectuer un cast vers ce type à l'aide de la fonction CType.

Nous définissons enfin le nouveau formulaire en tant qu'enfant du parent MDI et nous l'affichons.

Ce code risque de vous paraître familier si vous avez lu l'article Death of the Browser? (leave-msdn france Site en anglais). La logique est très similaire à celle utilisée pour le déploiement Internet des applications. Si l'explication précédente vous semble trop vague, vous pouvez vous reporter à l'article Death of the Browser? (leave-msdn france Site en anglais) pour obtenir des détails.

Remarque :   Les assemblys chargés à partir d'une URL comme indiqué dans l'article Death of the Browser? (leave-msdn france Site en anglais) sont copiés dans un cache local. Les assemblys chargés à partir d'un UNC, comme dans le présent article, ne sont utilisés que sur place et ne sont copiés dans aucun cache.
Étape 6 : Compiler l'application

À ce stade, nous pouvons compiler l'application mais nous ne pouvons afficher aucun formulaire, étant donné qu'aucun formulaire n'a été créé. Nous pouvons compiler et lancer le programme pour vérifier qu'il fonctionne et que la zone de liste déroulante se charge correctement avec l'élément d'espace réservé. En cliquant sur btnLoadForm, une erreur surviendra forcément, étant donné que les informations du fichier de configuration ne pointent encore vers rien.

Étape 7 : Créer les formulaires à afficher

Lancez maintenant une nouvelle application Windows Forms appelée FirstForm. Placez certains contrôles sur le formulaire Form1 vide qui apparaît—peu importe lesquels.

Cliquez ensuite avec le bouton droit de la souris sur le projet FirstForms dans l'Explorateur de solutions et sélectionnez Properties. Dans la zone de liste déroulante Output Type, sélectionnez Class Library. (Si vous ne voyez pas cette zone de liste déroulante, vous avez probablement cliqué avec le bouton droit de la souris sur Solution au lieu de Project dans l'Explorateur de solutions.)

Générez maintenant le projet. Une DLL contenant le formulaire est créée.

Créez un répertoire appelé C:\NewForms. Copiez FirstForms.dll du répertoire \bin du projet FirstForms sur C:\NewForms.

Répétez ces étapes pour deux projets supplémentaires appelés SecondForm et ThirdForm. Modifiez les contrôles que vous glissez sur chaque formulaire afin de pouvoir les différencier.Vous pouvez également modifier la couleur d'arrière-plan de chaque formulaire à l'aide de couleurs voyantes.

Étape 8 : Mettre à jour le fichier de configuration avec les informations du nouveau formulaire

Maintenant que nous avons de nouveaux formulaires, nous devons y faire référence dans le fichier de configuration. Remplacez les informations d'espace réservé dans FormsOnTheFly.exe.config par les lignes suivantes :

<add key="First Form" 
 value="C:\NewForms\FirstForm.dll~FirstForm.Form1"></add>
 <add key="Second Form" 
 value="C:\NewForms\SecondForm.dll~SecondForm.Form1"></add>
 <add key="Third Form"
 value="C:\NewForms\ThirdForm.dll~ThirdForm.Form1"></add>

Si vous choisissez de modifier l'emplacement des formulaires ou leurs noms, vous devrez modifier les lignes précédentes en conséquence.

Étape 9 : Exécuter FormsOnTheFly.exe et charger certains formulaires

Exécutez maintenant FormsOnTheFly.exe (sans charger Visual Studio). Sélectionnez un des formulaires dans la zone de liste déroulante et cliquez sur btnLoadForm. Si toutes les étapes ont été correctement exécutées, vous devriez voir le formulaire enfant se charger dans la fenêtre MDI, même si le formulaire enfant n'existait pas lors de la compilation de l'application MDI.

La Figure 2 est un exemple de formulaire MDI et de deux formulaires chargés à la volée.

Formulaire MDI et formulaires chargés à la volée

Figure 2 : Formulaire MDI et formulaires chargés à la volée

À ce stade, vous pouvez créer autant de nouveaux formulaires que vous le souhaitez pour les charger dans l'application MDI. Pour qu'ils soient disponibles, tout ce que vous avez à faire est de les compiler en une bibliothèque de classes et d'y faire référence dans le fichier de configuration.

Chargement d'autres types de classes à la volée

Cette technique fonctionne avec des types de classes autres que des formulaires. Cependant, il existe une complication. Dans l'exemple précédent, nous pouvions anticiper la liaison avec l'interface de classe System.Windows.Forms.Form puisque nous savions que la classe était un formulaire. C'est pourquoi nous utilisions, par exemple, la méthode Show du formulaire. Quelle interface pouvons-nous lier à nos propres classes ?

La réponse consiste à créer notre propre interface. Il s'agit en fait d'un exemple de manuel parfaitement adapté pour y implémenter une interface. Vous avez peut-être utilisé des interfaces dans Visual Basic 6.0. Elles ont été créées sous forme de classes vides. Dans Visual Basic .NET, il existe une nouvelle syntaxe et une interface est déclarée tout à fait indépendamment d'une classe. Nous verrons comment procéder à l'étape 1 ci-dessous.

Créons un exemple dans lequel le chargement d'une classe à la volée est souhaitable. Supposons que nous souhaitons écrire une application de nettoyage des données qui requiert la manipulation d'un groupe de données. Cependant, comme avec tous les nettoyeurs de données, le programme ne semble jamais terminé. Le codage de nouveaux types de validation et de nettoyage semble toujours nécessaire.

Vous pouvez, bien sûr, créer cette nouvelle logique de nettoyage et recompiler toute l'application, mais ne serait-il pas intéressant de pouvoir activer de nouvelles fonctionnalités de nettoyage de données à la volée, sans devoir recompiler l'application principale ? Voyons cette capacité du début à la fin, à travers un exemple qui nous y autorise.

Étape 1 : Créer le fichier de classe pour conserver l'interface

La création d'une interface dans Visual Basic .NET est en théorie similaire à la création d'une interface dans Visual Basic 6.0, mais la syntaxe est totalement différente. Pour créer votre classe d'interface d'origine, exécutez un nouveau projet de type Class Library. Appelez-le ScrubberInterface.

Remplacez alors, sur le fichier de classe créé, les lignes existantes par le code suivant :

Public Interface IScrubber
 Sub Scrub(ByVal ds As DataSet)
End Interface

Notre interface est très simple. Une méthode d'exploitation du groupe de données est nécessaire. Nous avons appelé la méthode Scrub.

Générez maintenant le projet et ScrubberInterface.DLL sera créé dans le répertoire \bin du projet.

Étape 2 : Créer l'application de nettoyage

Notre application de nettoyage sera similaire à bien des égards aux exemples de formulaires précédents. Cependant, au lieu de choisir une classe particulière à utiliser, nous ferons en sorte que toutes les classes de nettoyage de données soient utilisées une par une.

Créez une nouvelle application Windows Forms et appelez-la ClassesOnTheFly. Placez les contrôles suivants sur le formulaire Form1 qui apparaît :

Type de contrôle Nom Paramètres de propriété
Bouton btnLoadDataset Texte = "Load Dataset"
Bouton btnScrubDataset Texte = "Scrub Dataset"
DataGrid DataGrid1 aucune modification

Au début du code du Form1, placez le même code que celui qui se trouvait au début de l'exemple précédent :

Imports System.Configuration
Imports System.Reflection

Nous avons également besoin d'une variable au niveau du module pour contenir notre collection d'informations de configuration. Placez la ligne suivante juste sous la ligne indiquant Inherits System.Windows.Forms.Form :

Dim colAvailableClasses As ArrayList

Étape 3 : Charger un DataSet dans la grille pour son traitement

Pour simplifier les choses, nous chargerons notre DataSet à partir d'un fichier XML. Placez le fichier XML suivant dans le répertoire \bin du projet ClassesOnTheFly et appelez-le TimeCardData.xml :

<TimeCardData>
 <Employee>
 <Name>Sherlock Holmes</Name>
 <ID>123</ID>
 </Employee>
 <Employee>
 <Name>John Watson</Name>
 <ID>345</ID>
 </Employee>
 <Employee>
 <Name>Irene Adler</Name>
 <ID>567</ID>
 </Employee>
 <Employee>
 <Name>Jabez Wilson</Name>
 <ID>789</ID>
 </Employee>
</TimeCardData>

Nous aurons besoin d'une référence au Dataset au niveau du module, placez donc la ligne suivante juste en dessous de celle qui indique colAvailableClasses :

Dim ds As DataSet

Pour lire le groupe de données et charger la grille, placez le code suivant dans l'événement click pour btnLoadDataset :

ds = New DataSet()
ds.ReadXml("TimeCardData.xml")
DataGrid1.DataSource = ds.Tables(0)

Exécutez le programme à ce stade pour garantir que la grille se charge correctement.

Étape 4 : Ajouter une référence à l'interface de nettoyage

Nous devrons ensuite ajouter une référence à la DLL créée précédemment pour contenir l'interface pour les classes de nettoyage des données. Sélectionnez Project | Add Reference. Cliquez sur le bouton Browse, recherchez ScrubberInterface.DLL (créé à l'Étape 1 ci-dessus) et cliquez sur Open. Cliquez ensuite sur OK et la référence s'ajoutera.

Étape 5 : Créer la classe contenant les données sur les formulaires disponibles

Copiez maintenant le module DynamicClass.vb utilisé dans l'exemple de formulaires précédent et insérez-le dans le projet ClassesOnTheFly. Il peut être utilisé sans modification.

Étape 6 : Générer un fichier de configuration pour y inclure les formulaires disponibles

Générez un fichier de configuration semblable en tout point à l'original utilisé dans l'exemple de formulaires précédent. Il doit se présenter comme suit :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
 <configSections>
 <section name="availableclasses" 
 type="System.Configuration.NameValueSectionHandler" />
 </configSections>
 <availableclasses>
 <add key="Placeholder – do not load" 
 value="DLLPathnameGoesHere~NameOfTypeGoesHere"></add>
 </add>
 </availableclasses>
</configuration>

N'oubliez pas de placer ce fichier dans le répertoire \bin du projet ClassesOnTheFly et appelez-le ClassesOnTheFly.exe.config.

Étape 7 : Lire les informations de configuration dans une collection

Cette opération est pratiquement la même que dans l'exemple de formulaires précédent à l'exception de la liaison de la collection à une zone de liste déroulante. Copiez donc la même logique utilisée dans Form Load pour l'exemple de formulaires, mais omettez les trois dernières lignes (celles qui lient les données pour la zone de liste déroulante). Collez cette logique dans l'événement Form Load pour Form1 dans le projet ClassesOnTheFly.

Étape 8 : Insérer la logique pour charger et utiliser les classes de nettoyage des données

Placez maintenant la logique suivante dans l'événement click du bouton btnScrubDataset :

Dim objScrubberClass As DynamicClass
For Each objScrubberClass In colAvailableClasses
 Dim asmAssemblyContainingForm As [Assembly] = _
 [Assembly].LoadFrom(objScrubberClass.Location)
 Dim TypeToLoad As Type = _
 asmAssemblyContainingForm.GetType(objScrubberClass.Type)
 Dim GenericInstance As Object
 GenericInstance = Activator.CreateInstance(TypeToLoad)

 Dim Scrubber As ScrubberInterface.IScrubber = _
 CType(GenericInstance, ScrubberInterface.IScrubber)
 Scrubber.Scrub(ds)

Next

Cela ressemble énormément à la logique qui a chargé dynamiquement les formulaires, nous ne traiterons donc pas ces opérations de manière détaillée. Les principales différences sont les suivantes :

  • Le chargement dynamique est effectué pour chaque classe du fichier de configuration.
  • Un cast du nouvel objet instancié est effectué vers un type de ScrubberInterface.IScrubber. Ceci nous permet d'effectuer une liaison vers l'interface IScrubber.
  • La méthode Scrub de chaque objet est exécutée, en passant dans le groupe de données.
Étape 9 : Compiler et exécuter l'application

Exécutez l'application pour vérifier qu'elle se compile correctement. Ne cliquez cependant pas encore sur le bouton Scrub Dataset, étant donné que la classe de nettoyage n'a pas été créée.

Une fois que l'application s'est correctement compilée, fermez Visual Studio pour le projet ClassesOnTheFly.

Étape 10 : Créer la classe de nettoyage des données

Lancez un nouveau projet de type Class Library dans Visual Studio. Appelez-le FirstClass. Remplacez le code Class1 qui est automatiquement inséré par le code suivant :

Public Class FirstClass
 Implements ScrubberInterface.IScrubber
 Public Sub Scrub(ByVal ds As DataSet) _
 Implements ScrubberInterface.IScrubber.Scrub
 Dim dr As DataRow

 dr = ds.Tables(0).NewRow
 dr.Item(0) = "Professor Moriarty"
 dr.Item(1) = "666"
 ds.Tables(0).Rows.Add(dr)
 End Sub

End Class

Cette classe implémente l'interface IScrubber qui ne représente qu'une seule méthode. Cette méthode prend un groupe de données et lui ajoute une ligne supplémentaire. Une classe réelle de nettoyage des données peut, bien sûr, contenir autant de logique de manipulation des données que nécessaire.

Générez ce projet pour obtenir FirstClass.DLL. Copiez la DLL du répertoire \bin du projet vers un nouveau répertoire appelé C:\ScrubberClasses.

Étape 11 : Mettre à jour le fichier de configuration avec la nouvelle classe

Revenez maintenant à ClassOnTheFly.exe.config. Modifiez la section de la balise <availableclasses> pour qu'elle apparaisse ainsi :

<add key="First Class" 
 value="C:\ScrubberClasses\FirstClass.dll~FirstClass.FirstClass">

Enregistrez le fichier de configuration avant de passer à la dernière étape.

Étape 12 : Tester le fonctionnement de la nouvelle classe de nettoyage des données

Exécutez maintenant ClassesOnTheFly.exe et cliquez sur le bouton Load Dataset. Notez que la grille comporte quatre lignes. Cliquez sur le bouton Scrub Dataset. Une cinquième ligne (ajoutée par la classe de nettoyage des données) apparaît dans la grille.

Vous pouvez ajouter des classes de nettoyage des données supplémentaires si nécessaire et effectuer toutes les opérations souhaitées sur le DataSet. Créez-les et ajoutez-les simplement au fichier de configuration. Elles seront alors automatiquement utilisées en cas de pression sur le bouton Scrub Dataset.

Conclusion

Le point le plus important de ces deux exemples est que les applications d'origine (FormsOnTheFly et ClassesOnTheFly) ont été créées et compilées sans référence aux formulaires et classes qui pourraient être chargés ensuite dynamiquement. En fait, ces formulaires et classes n'ont même pas été créés à ce stade !

Par la suite, une fois les formulaires et classes créés, l'application a été mise à jour pour les utiliser en faisant référence à leurs emplacements et leurs types dans le fichier de configuration. Autant de nouveaux formulaires et classes que nécessaire peuvent être créés et ajoutés à la volée. Si une application nécessite ce degré d'extensibilité, .NET offre une solution formidable grâce à Reflection et au chargement dynamique des classes.



Dernière mise à jour le jeudi 5 décembre 2002



Pour en savoir plus
Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.
Afficher:
© 2014 Microsoft. Tous droits réservés.