Appel de composants COM à partir de clients .NET

 

Mike Gunderloy
Lark Group, Inc.

Novembre 2001

Résumé: Dans ce document, vous allez découvrir les détails de l’appel de serveurs COM à partir de clients .NET. (14 pages imprimées)

Objectifs

• Comprendre le concept des wrappers Runtime-Callable
• Utiliser TLBIMP pour créer un assembly à partir d’un composant COM
• Référencer un composant COM directement à partir du code Microsoft® Visual Basic® .NET

Hypothèses

Les éléments suivants doivent être vrais pour vous permettre de tirer le meilleur parti de ce document :

• Vous êtes familiarisé avec la programmation Visual Basic
• Vous êtes familiarisé avec les concepts COM. En particulier, vous devez comprendre les avantages et l’architecture des logiciels
• Vous avez accès à Visual Basic .NET
• Vous comprenez l’architecture globale de la plateforme Microsoft .NET

Contenu

La joie de l’interopérabilité
S’entraîner à appeler COM à partir de .NET
Utilisation directe du composant COM
Résumé

La joie de l’interopérabilité

Parfois, une révolution dans la programmation vous oblige à abandonner tout ce qui est arrivé avant. Pour prendre un exemple extrême, supposons que vous écriviez des applications Visual Basic depuis des années. Si vous êtes comme de nombreux développeurs, vous aurez créé un inventaire substantiel de code au cours de cette période. Et si vous avez suivi les recommandations de différents gourous du langage, ce code est en composant. Autrement dit, en utilisant des serveurs COM (Component Object Model) (anciennement Microsoft ActiveX®), vous avez divisé votre application en blocs de fonctionnalités pouvant être appelées. Bien sûr, vous êtes également susceptible d’avoir un investissement important dans des composants, tels que les contrôles ActiveX, d’autres développeurs et d’autres entreprises.

Mais que se passe-t-il si vous décidez du changement radical de développement vers un autre système d’exploitation entièrement ? À ce stade, tout votre investissement dans COM devient inutile. Vous ne pouvez pas utiliser votre code existant et vous devez apprendre à tout faire sur la nouvelle plateforme. Sans aucun doute, ce serait un coup dur pour votre productivité.

Heureusement, le passage de COM à Microsoft .NET n’implique aucune perte radicale de productivité. Il existe deux concepts clés qui facilitent grandement le passage du développement COM au développement .NET sans perte de base de code ou de productivité :

• Les composants .NET peuvent appeler des composants COM.
• Les composants COM peuvent appeler des composants .NET.

Cette interopérabilité bidirectionnel est la clé pour passer de COM à .NET. À mesure que vous apprenez les subtilités de .NET, vous pouvez continuer à utiliser les composants COM. Il existe un certain nombre de situations où cette interopérabilité est utile :

• Vous ne saurez pas tout sur .NET instantanément. L’apprentissage des concepts et de l’implémentation de la programmation .NET prend du temps. Vous devrez donc probablement poursuivre le développement critique dans COM.
• Bien que le code Microsoft Visual Basic 6 puisse être porté vers .NET, la conversion n’est pas parfaite. Vous pouvez avoir des composants qui ne peuvent pas être déplacés vers .NET en raison d’une implémentation ou d’un langage bizarre.
• Vous ne pouvez pas écrire tout le code d’une grande application immédiatement dans un nouveau système tel que .NET. Il est beaucoup plus judicieux d’écrire des composants individuellement et de les tester un par un, tout en interopération avec votre code existant.
• Vous utilisez peut-être des composants COM tiers pour lesquels vous n’avez pas de code source.

Dans ce document, vous allez découvrir les détails de l’appel de serveurs COM à partir de clients .NET. Dans un article complémentaire, Appel d’un composant .NET à partir d’un composant COM, vous allez découvrir comment appeler dans l’autre sens, à partir de clients COM vers des serveurs .NET.

Code non managé et wrappers Runtime-Callable

Le code qui fonctionne dans le Microsoft .NET Common Language Runtime (CLR) est appelé code managé. Ce code a accès à tous les services que le CLR apporte à la table, tels que l’intégration multilingue, la sécurité et la prise en charge du contrôle de version et le garbage collection. Le code qui ne fonctionne pas dans le CLR est appelé code non managé. Tous vos composants COM hérités sont, par définition, du code non managé. Étant donné que COM a été conçu avant l’existence du CLR et que le code COM ne fonctionne pas dans l’infrastructure fournie par le CLR, il ne peut pas utiliser les services CLR.

Le problème avec le mélange de code managé et non managé dans une seule application est que le code non managé n’est pas reconnu dans l’environnement CLR. Les composants de code managé dépendent non seulement du CLR, mais ils s’attendent à ce que d’autres composants avec lesquels ils interagissent dépendent du CLR.

Le moyen de sortir de ce dilemme est d’utiliser un proxy. En termes généraux, un proxy est un logiciel qui accepte les commandes d’un composant, les modifie et les transfère à un autre composant. Le type particulier de proxy utilisé pour appeler du code non managé à partir de code managé est appelé wrapper Runtime-Callable ou RCW. La figure 1 montre schématiquement comment les rcW chevauchent la limite entre le code managé et le code non managé. Cette figure inclut un programme .NET nommé NetUI.exe, deux composants COM nommés BackEnd.dll et Service.dll, ainsi que la technologie nécessaire qui les connecte.

Figure 1. Appel de code non managé avec des RCW

Conversion de métadonnées avec TLBIMP

Bien entendu, .NET n’est pas le premier à utiliser des métadonnées pour décrire les interfaces publiques. En fait, les bibliothèques de types COM contiennent également des métadonnées décrivant l’interface publique aux composants COM. Le travail d’un RCW consiste à convertir ces métadonnées COM en métadonnées .NET.

Un outil pour effectuer cette conversion est appelé tlbimp (importateur de bibliothèque de types) et il est fourni dans le cadre du Kit de développement logiciel (SDK) .NET Framework. Tlbimp lit les métadonnées d’une bibliothèque de types COM et crée un assembly CLR correspondant pour appeler le composant COM.

Note Si vous générez une DLL ActiveX ou un EXE ActiveX avec Visual Basic, la bibliothèque de types est incorporée dans le fichier DLL ou EXE.

Tlbmp est un outil en ligne de commande avec un certain nombre d’options, telles que la signature de l’assembly résultant avec une clé de chiffrement ou la résolution de références externes dans la bibliothèque de types. (Tapez tlbimp /? à une invite de commandes pour afficher toutes les options.) L’option la plus importante est /out, qui vous permet de spécifier un nom pour l’assembly .NET résultant. Par exemple, pour convertir une DLL ActiveX Visual Basic nommée support.dll en assembly .NET correspondant au nom NETsupport.dll, vous pouvez utiliser cette ligne de commande :

tlbimp support.dll /out:NETsupport.dll

Utilisation directe des composants COM

En tant que développeur Visual Basic .NET, vous avez également la possibilité d’utiliser directement des composants COM. Du moins, c’est ce à quoi il ressemble, bien que vous utilisiez toujours par programmation un RCW pour accéder aux objets dans du code non managé. Si vous travaillez dans un projet Visual Basic .NET, vous pouvez suivre ces étapes pour ajouter une référence à un composant COM :

1. Cliquez sur Projet, puis sur Ajouter une référence.
2. Dans la boîte de dialogue Ajouter une référence , cliquez sur l’onglet COM .
3. Sélectionnez la bibliothèque de types que vous souhaitez utiliser dans la liste, puis cliquez sur Sélectionner, ou utilisez le bouton Parcourir pour rechercher un composant qui n’est pas répertorié. Les composants sélectionnés seront ajoutés à l’affichage de liste inférieur dans la boîte de dialogue.
4. Cliquez sur OK pour créer des fichiers RCW pour les bibliothèques de types sélectionnées dans votre projet Visual Basic .NET.

Dans ce cas, vous constaterez que Visual Basic .NET crée en fait une DLL dans le dossier /Bin de votre projet, avec un nom dérivé du nom du composant COM d’origine. Par exemple, si vous référencez BackEnd.dll version 2.0 de cette manière, Visual Basic .NET crée le fichier RCW dans le fichier Interop.BackEnd_2_0.dll.

Le principal inconvénient de cette méthode de raccourci d’utilisation directe d’un composant COM est qu’il n’est pas possible de signer le code résultant. Par conséquent, vous ne pouvez pas placer le code dans le Global Assembly Cache (GAC), ce qui rend à son tour impossible le partage du composant entre plusieurs applications .NET.

Choix entre TLBIMP et référence directe

Bien que l’une ou l’autre des méthodes d’utilisation d’un composant COM autorise le code .NET à appeler votre composant COM, il existe quelques raisons de choisir l’une plutôt que l’autre :

• Pour un composant COM qui ne sera utilisé que dans un seul projet Visual Basic .NET et que vous avez écrit vous-même, utilisez une référence directe plutôt que d’effectuer un travail supplémentaire. Cette méthode convient uniquement à un composant véritablement privé qui n’a pas besoin d’être partagé.
• Si un composant COM est partagé entre plusieurs projets, utilisez tlbimp afin de pouvoir signer l’assembly résultant et le placer dans le Global Assembly Cache. Le code partagé doit être signé. Cette méthode vous permet également de créer le RCW avec un nom spécifique dans un emplacement spécifique.
• Si vous devez contrôler les détails avancés de l’assembly créé, tels que son espace de noms ou son numéro de version, vous devez utiliser tlbimp. La méthode de référence directe ne vous donne aucun contrôle sur ces détails.
• Si vous n’avez pas écrit le composant COM, aucune de ces méthodes n’est acceptable. Cela est dû au fait que vous n’êtes pas autorisé à signer du code écrit par un autre développeur. Dans ce cas, vous devez obtenir un assembly PIA (Primary Interop Assembly) auprès du développeur d’origine du composant. MSDN inclut des liens pour vous aider à trouver des piaas pour des composants courants tels que des contrôles ActiveX.

S’entraîner à appeler COM à partir de .NET

Dans l’exemple suivant, vous allez utiliser des propriétés, des méthodes et des événements dans un composant COM à partir de code .NET. Vous allez utiliser tlbimp pour convertir l’interface du composant COM en assembly, puis voir comment le traiter comme n’importe quel autre composant .NET à partir du code managé. Une fois cette opération effectuée, vous verrez également comment prendre un raccourci à l’aide du composant COM directement à partir d’un projet Visual Basic .NET sans utiliser tlbimp.

Installer le composant COM

Le composant COM que vous allez utiliser dans cet exercice est nommé PhysServer.dll. Il s’agit d’une DLL ActiveX qui contient une seule classe nommée Temperature. Cette classe stocke une variable interne représentant une température et gère les conversions entre Celsius et Fahrenheit. Le tableau 1 présente les membres de l’interface Temperature.

Tableau 1. Interface vers la classe Temperature dans PhysServer.dll

Membre	Type	Explication
Celsius	Propriété	Température actuelle en degrés Celsius
Fahrenheit	Propriété	Température actuelle en degrés Fahrenheit
GetCelsius	Méthode	Obtenir la température actuelle en degrés Celsius
GetFahrenheit	Méthode	Obtenir la température actuelle en degrés Fahrenheit
BelowFreezing	Événement	Se déclenche lorsqu’une température inférieure au point de congélation est définie
AboveBoiling	Événement	Se déclenche lorsqu’une température au-dessus de l’ébullition est définie

Pour créer ce composant COM sur un ordinateur sur lequel Visual Basic 6.0 est installé :

1. Lancez Visual Basic 6.0 et créez un projet DLL ActiveX.

2. Cliquez sur le module Class1 dans la fenêtre Project Explorer et utilisez le Fenêtre Propriétés pour remplacer le nom de la classe par Temperature.

3. Cliquez sur le projet Project1 dans la fenêtre Project Explorer et utilisez la Fenêtre Propriétés pour remplacer le nom du projet par PhysServer.

4. Ajoutez ce code à la classe Temperature :

    Option Explicit
   
   Private mdblCelsius As Double
   Private mdblFahrenheit As Double
   
   Public Event BelowFreezing()
   Public Event AboveBoiling()
   
   Public Property Get Celsius() As Double
       Celsius = mdblCelsius
   End Property
   
   Public Property Let Celsius(NewTemperature As Double)
       mdblCelsius = NewTemperature
       mdblFahrenheit = ((NewTemperature * 9) / 5) + 32
       If mdblCelsius < 0 Then
           RaiseEvent BelowFreezing
       End If
       If mdblCelsius > 100 Then
           RaiseEvent AboveBoiling
       End If
   End Property
   
   Public Property Get Fahrenheit() As Double
       Fahrenheit = mdblFahrenheit
   End Property
   
   Public Property Let Fahrenheit(NewTemperature As Double)
       mdblFahrenheit = NewTemperature
       mdblCelsius = ((NewTemperature - 32) * 5) / 9
       If mdblFahrenheit < 32 Then
           RaiseEvent BelowFreezing
       End If
       If mdblFahrenheit > 212 Then
           RaiseEvent AboveBoiling
       End If
   End Property
   
   Public Function GetCelsius() As Double
       GetCelsius = mdblCelsius
   End Function
   
   Public Function GetFahrenheit() As Double
       GetFahrenheit = mdblFahrenheit
   End Function
   
   Private Sub Class_Initialize()
       mdblCelsius = 0
       mdblFahrenheit = 32
   End Sub
   

5. Cliquez sur Projet, puis, dans le menu Visual Basic , cliquez sur Propriétés physServer. Dans la boîte de dialogue Propriétés du projet , remplacez la Description du projet par Serveur de constantes physiques. Cliquez sur OK.

6. Enregistrez le projet.

7. Cliquez sur Fichier, puis pour créer le composant COM, cliquez sur Créer PhysServer.dll.

Pour installer ce composant COM sur votre ordinateur Visual Studio .NET :

1. Créez un dossier nommé Hérité sur votre disque dur.

2. Copiez PhysServer.dll dans le dossier Hérité.

3. Ouvrez une fenêtre d’invite de commandes et tapez :

   regsvr32 c:\Legacy\PhysServer.dll
   

   Le message affiché dans la figure 2 doit s’afficher.

   

   Figure 2 : Installation réussie du message de composant COM hérité

Utiliser TLBIMP pour créer un assembly

Ensuite, utilisez l’utilitaire tlbimp pour créer un assembly qui fournit un RCW pour le composant PhysServer. À partir de la Panneau de configuration, lancez l’applet système.

1. Pour ouvrir une fenêtre d’invite de commandes Visual Studio .NET, cliquez sur Démarrer, sur Programmes, sur Microsoft Visual Studio .NET 7.0, sur Visual Studio .NET Tools, puis sur Invite de commandes Visual Studio .NET.

2. Accédez au répertoire \Legacy.

3. À l’invite de commandes, tapez :

   tlbimp PhysServer.dll /out:NETPhysServer.dll
   

Dans ce cas particulier, nous avons choisi de créer le RCW sans le signer. Si ce composant était partagé entre plusieurs clients, nous devrons le signer lorsque nous avons appelé tlbimp. Les détails de cette étape sont omis ici par souci de concision. Pour en savoir plus sur la signature de code et le Global Assembly Cache, consultez Appel d’un composant .NET à partir d’un composant COM.

Tlbimp effectue le travail de conversion, puis imprime un message confirmant que la bibliothèque de types a été importée comme nouveau nom.

Note L’invite de commandes Visual Studio .NET ajoute le dossier /Bin du Kit de développement logiciel (SDK) Framework au chemin d’accès afin que les outils sdk, tels que tlbimp, puissent être appelés sans spécifier leur chemin.

Créer le projet de test

Vous pouvez maintenant tester la capacité d’une application .NET Visual Basic à utiliser un objet à partir d’un composant COM hérité.

1. Ouvrez Visual Studio .NET et, dans la page Démarrer , choisissez Nouveau projet.

2. Sélectionnez Projet Visual Basic dans l’arborescence sur le côté gauche de l’écran.

3. Sélectionnez Application Windows comme modèle de projet.

4. Définissez le nom de l’application sur PhysServerTest et cliquez sur OK pour créer le projet.

5. Mettez en surbrillance le formulaire appelé Form1.vb dans la fenêtre Explorateur de solutions et renommez-le frmTemperature.vb.

6. Créez le formulaire illustré dans la figure 3 en ajoutant les contrôles appropriés et en définissant les propriétés de ces contrôles, comme indiqué dans le tableau 2.

   Tableau 2. Contrôles pour frmTemperature.vb

   Type de contrôle	Propriété	Valeur
   Étiquette	Nom	lblFahrenheit
   	Texte	Fahrenheit
   TextBox	Nom	txtFahrenheit
   	Texte	(vide)
   Button	Nom	cmdConvertToC
   	Texte	Convertir en C
   Étiquette	Nom	lblCelsius
   	Texte	Celsius
   TextBox	Nom	txtCelsius
   	Texte	(vide)
   Button	Nom	cmdConvertToF
   	Texte	Convertir en F
   Étiquette	Nom	lblAboveBoiling
   	Texte	Au-dessus de l’ébullition!
   	Taille de police	12
   	Police en gras	True
   	Visible	False
   Étiquette	Nom	lblBelowFreezing
   	Texte	En dessous de gel!
   	Taille de police	12
   	Police en gras	True
   	Visible	False

   

   Figure 3. Conception du formulaire de test

7. Pour utiliser rcw pour le composant COM PhysServer, cliquez sur Projet, puis sur Ajouter une référence. Vérifiez que l’onglet .NET est sélectionné, puis cliquez sur Parcourir.

8. Accédez au dossier Hérité et sélectionnez le composant NETPhysServer.dll. Cliquez sur Ouvrir. Cela ajoute le composant à la liste Composants sélectionnés, comme illustré dans la figure 4.

9. Cliquez sur OK. Le nœud Références dans le Explorateur de solutions se développe pour afficher la référence NetPhysServer (ainsi que les références par défaut que contient le projet Visual Basic).

   

   Figure 4. Ajout d’une référence au composant RCW

Ajouter du code pour utiliser le composant COM

Vous êtes maintenant prêt à écrire du code qui utilise les méthodes, les propriétés et les événements de la classe Temperature. Cliquez sur Afficher, sur Code, puis entrez ce code après le code généré par windows Form Designer :

    Private WithEvents moTemp As NETPhysServer.Temperature

    Private Sub cmdConvertToC_Click(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles cmdConvertToC.Click
        lblBelowFreezing.Visible = False
        lblAboveBoiling.Visible = False
        With moTemp
            .Fahrenheit = txtFahrenheit.Text
            txtCelsius.Text = .GetCelsius
        End With
    End Sub

    Private Sub cmdConvertToF_Click(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles cmdConvertToF.Click
        lblBelowFreezing.Visible = False
        lblAboveBoiling.Visible = False
        With moTemp
            .Celsius = txtCelsius.Text
            txtFahrenheit.Text = .GetFahrenheit
        End With
    End Sub

    Private Sub frmTemperature_Load(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles MyBase.Load
        moTemp = New NETPhysServer.Temperature()
    End Sub

    Private Sub moTemp_AboveBoiling() Handles moTemp.AboveBoiling
        lblAboveBoiling.Visible = True
    End Sub

    Private Sub moTemp_BelowFreezing() Handles moTemp.BelowFreezing
        lblBelowFreezing.Visible = True
    End Sub

Notez que, en ce qui concerne ce code, la classe NETPhysServer.Temperature est comme n’importe quelle autre classe .NET. Vous déclarez une instance de la classe et utilisez ses méthodes et propriétés comme s’il s’agissait d’une classe native plutôt que d’une Runtime-Callable Wrapper autour d’un composant COM.

Essayez-le

Pour voir la classe Temperature en action, procédez comme suit :

1. Appuyez sur F5 pour démarrer le projet.
2. Entrez 41 dans la zone de texte Fahrenheit , puis cliquez sur Convertir en C. La zone Celsius doit remplir avec la valeur 5.
3. Entrez 123 dans la zone Celsius , puis cliquez sur Convertir en F. La zone Fahrenheit doit remplir la valeur 253,4 et l’étiquette Au-dessus de l’ébullition! doit devenir visible.
4. Fermez le formulaire pour arrêter le projet.

Utilisation directe du composant COM

Maintenant que vous avez vu comment utiliser tlbimp, essayez le processus alternatif d’utilisation directe du composant COM.

1. Ouvrez une deuxième instance de Visual Studio .NET et, dans la page De démarrage, choisissez Nouveau projet.
2. Sélectionnez Projet Visual Basic dans l’arborescence sur le côté gauche de l’écran.
3. Sélectionnez Application Windows comme modèle de projet.
4. Définissez le nom de l’application sur PhysServerTest2 , puis cliquez sur OK pour créer le projet.
5. Mettez en surbrillance le formulaire appelé Form1.vb dans la fenêtre Explorateur de solutions et renommez-le en frmTemperature.vb.
6. Basculez vers le instance d’origine de Visual Studio .NET et ouvrez frmTemperature en mode Création. Cliquez sur Ctrl-A, Ctrl-C pour sélectionner tous les contrôles du formulaire et les copier.
7. Revenez à la deuxième instance de Visual Studio .NET, sélectionnez frmTemperature en mode Création, puis cliquez sur Ctrl-V pour coller tous les contrôles dans le nouveau formulaire.

Pour utiliser directement le composant COM, cliquez sur Projet, cliquez sur Ajouter une référence et sélectionnez l’onglet COM dans la boîte de dialogue Ajouter une référence . Faites défiler la liste des composants COM jusqu’à ce que vous trouviez serveur de constantes physiques, cliquez sur Sélectionner, puis sur OK. Vous recevrez l’avertissement illustré dans la figure 5.

Figure 5. Avertissement qui s’affiche lors de l’insertion d’une référence de composant COM

À ce stade, la réponse appropriée dépend de qui a créé le composant COM. S’il provient d’un fournisseur ou d’un autre développeur, vous devez cliquer sur Non , puis obtenir un assembly d’interopérabilité primaire auprès de ce fournisseur ou développeur. Dans ce cas, le composant étant privé de votre propre développement, cliquez sur Oui pour indiquer à Visual Studio .NET de générer un RCW pour ce composant. Vous verrez PhysServer apparaître dans la liste des références dans le Explorateur de solutions.

Note Il s’agit du PhysServer.dll d’origine, et non du RCW que vous avez généré précédemment à l’aide de tlbimp.

Ajouter du code pour utiliser le composant COM

Vous êtes maintenant prêt à écrire du code qui utilise les méthodes, les propriétés et les événements de la classe Temperature. Cliquez sur Afficher, sur Code, puis entrez ce code après le code généré par windows Form Designer :

    Private WithEvents moTemp As PhysServer.Temperature

    Private Sub cmdConvertToC_Click(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles cmdConvertToC.Click
        lblBelowFreezing.Visible = False
        lblAboveBoiling.Visible = False
        With moTemp
            .Fahrenheit = txtFahrenheit.Text
            txtCelsius.Text = .GetCelsius
        End With
    End Sub

    Private Sub cmdConvertToF_Click(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles cmdConvertToF.Click
        lblBelowFreezing.Visible = False
        lblAboveBoiling.Visible = False
        With moTemp
            .Celsius = txtCelsius.Text
            txtFahrenheit.Text = .GetFahrenheit
        End With
    End Sub

    Private Sub frmTemperature_Load(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles MyBase.Load
        moTemp = New PhysServer.Temperature()
    End Sub

    Private Sub moTemp_AboveBoiling() Handles moTemp.AboveBoiling
        lblAboveBoiling.Visible = True
    End Sub

    Private Sub moTemp_BelowFreezing() Handles moTemp.BelowFreezing
        lblBelowFreezing.Visible = True
    End Sub

Note À l’exception du nom de la bibliothèque, il s’agit exactement du même code que celui que vous avez utilisé dans la première version du projet PhysServerTest.

Essayez-le

Pour voir la classe Temperature en action, procédez comme suit :

1. Appuyez sur F5 pour démarrer le projet.
2. Entrez 77 dans la zone de texte Fahrenheit , puis cliquez sur Convertir en C. La zone Celsius doit remplir la valeur 25.
3. Entrez -17 dans la zone Celsius , puis cliquez sur Convertir en F. La zone Fahrenheit doit être remplie avec la valeur 1.4 et l’étiquette Below Freezing! doit devenir visible.
4. Fermez le formulaire pour arrêter le projet.

Résumé

Bien que l’appel d’un composant COM à partir de code managé soit simple, vous ne devez pas considérer cela comme une solution permanente pour la plupart des applications. À long terme, vous souhaiterez migrer des composants fortement utilisés vers du code .NET natif. Vous disposez ainsi de la gamme complète de fonctionnalités .NET, ainsi que de rendre votre code plus rapide en éliminant la couche RCW.

Toutefois, lorsque vous commencez à déplacer votre développement de Visual Basic vers Visual Basic .NET, la possibilité d’appeler des composants COM à partir de code .NET est essentielle. Comme vous l’avez vu, il est également facile à implémenter. Considérez cette technique comme un élément important de votre stratégie de migration.

À propos de l’auteur

Mike Gunderloy écrit sur les logiciels et élève des poulets dans l’est de l’État de Washington. Il est co-auteur de Access 2002 Developer’s Handbook et auteur de SQL Server Développeur’s Guide to OLAP avec Analysis Services, tous deux de Sybex. Il écrit du code pour les produits Microsoft depuis l’ère pré-Windows et n’a pas l’intention de s’arrêter de sitôt.

À propos du groupe de communications d’informateurs

Informant Communications Group, Inc. (www.informant.com) est une société de médias diversifiée axée sur le secteur des technologies de l’information. Spécialisée dans les publications de développement logiciel, les conférences, la publication de catalogues et les sites web, ICG a été fondée en 1990. Avec des bureaux au États-Unis et au Royaume-Uni, ICG a été un intégrateur de contenu médiatique et marketing respecté, satisfaisant l’appétit naissant des professionnels de l’informatique pour une information technique de qualité.

Copyright © 2001 Informant Communications Group et Microsoft Corporation

Modification technique : PDSA, Inc. ou KNG Consulting