Construction de compléments Outlook 2002 avec Visual Basic .NET

Randy Byrne
Micro Eye, Inc. ( ).

S'applique à :
    Microsoft® Visual Basic® .NET
    Microsoft Outlook® 2002

Résumé : Cet article montre comment utiliser Visual Basic .NET pour développer des compléments COM pour Outlook 2002. L'exemple de complément COM Visual Basic .NET pour Outlook retrouve les adresses postales des contacts grâce à un service Web XML.

Téléchargez ou consultez odc_oladdinvbnet.exe sur MSDN Downloads ( ). Pour une meilleure compréhension, les commentaires du programmeur, en anglais dans les fichiers exemple, sont traduits dans l'article.

Sommaire

Introduction
Prise en charge de compléments dans Visual Studio .NET
Utilisation de l'assembly PIA d'Office XP
L'exemple d'application OutlookCOMAddinVBNet
Bases du code d'un complément COM Visual Basic .NET pour Outlook
Travailler avec un projet de configuration
Conclusion

Introduction

Les compléments permettent aux développeurs de faire aller Microsoft® Outlook® 2002 au-delà de ses capacités de départ. Dans le langage courant des développeurs Microsoft Office, les compléments sont appelés compléments COM car ils dépendent du modèle COM (Component Object Model) pour fonctionner in-process avec Outlook. Vous vous demandez peut-être comment un assembly en code géré peut fonctionner avec Outlook, qui reste du code non géré dépendant de COM. Pour garantir l'interopérabilité, il suffit d'installer les assemblys dits PIA (Primary Interop Assemblies) de Microsoft Office XP. Au moment de déployer votre package d'installation, il vous faudra y inclure les PIA nécessaires. Vous apprendrez comment coder un complément Outlook avec Microsoft Visual Basic® .NET. L'exemple de complément Visual Basic .NET présenté ici illustre les bonnes pratiques en matière de programmation, que vous pouvez appliquer dans vos propres solutions. L'exemple d'application est un complément COM pour Outlook qui utilise un service Web XML en respectant les règles en matière de comportement. Si votre application est à usage privé et non commercial, ce service Web XML vous permet de valider des adresses de messagerie ContactItem par rapport à la base de données des services postaux des États-Unis.

Pour apprécier cet article, le lecteur doit :

• Savoir ce que sont les compléments COM, comment les créer, les déployer et les installer. Pour plus d'informations sur les compléments COM, reportez-vous à l'article What is a COM Add-in? ( ).
• Être familier avec le modèle objet d'Outlook 2002.
• Connaître les Services Web et savoir comment ajouter une référence Web à un projet Microsoft Visual Studio® .NET.
• Avoir des connaissances de base sur .NET et COM interop.

Prise en charge de compléments dans Visual Studio .NET

Visual Studio .NET prend en charge les compléments Office. Pour créer un complément Office, suivez les indications ci-dessous :

1. Appuyez sur CTRL+SHIFT+N pour afficher la boîte de dialogue Nouveau projet.
2. Dans l'arborescence Types de projets, développez Autres projets et sélectionnez Projets d'extensibilité.
3. Dans la liste Modèles, double-cliquez sur Complément partagé.
4. L'Assistant Complément Visual Studio démarre et vous demande les informations nécessaires à la création de la classe Connect et des paramètres du registre de votre complément.

Il faut toutefois savoir que l'Assistant Complément Visual Studio omet plusieurs blocs de code qui sont essentiels au bon fonctionnement de votre complément dans Outlook 2002. Par ailleurs, certains problèmes liés à l'assembly d'interopérabilité généré par Visual Studio .NET lorsque vous définissez une référence à la bibliothèque d'objets d'Outlook subsistent actuellement. Un assembly d'interopérabilité contient des métadonnées qui aident votre code géré à communiquer avec une bibliothèque de types COM, comme la bibliothèque d'objets de Microsoft Outlook 10.0. L'assembly d'interopérabilité créé par Visual Studio .NET est appelé assembly d'interopérabilité généré par TLBIMP. TLBIMP est appelé lorsque vous ajoutez une référence à votre projet Visual Basic .NET et que vous sélectionnez des bibliothèques d'objets à partir de la page COM de la boîte de dialogue Références (voir figure 1). Par exemple, supposons que vous choisissiez d'ajouter une référence à la bibliothèque d'objets Microsoft Outlook 10.0. Une fois que vous avez ajouté cette référence à votre projet, un fichier appelé Outlook.Interop.dll est créé dans le dossier bin de votre projet.

Figure 1. Boîte de dialogue Ajouter une référence

Si vous utilisez l'Assistant Complément Visual Studio pour créer un complément Outlook et que vous n'avez pas installé le PIA d'Office XP, vous constaterez que :

• L'Assistant Complément ne crée pas de référence à la bibliothèque d'objets d'Outlook. Vous devez créer cette référence manuellement.
• Si vous avez défini une référence à Outlook, vous ne pouvez pas recevoir les événements Outlook.
• Visual Basic .NET IntelliSense® indiquera aussi bien les classes natives d'Outlook (comme Explorer et Inspector) que l'interface de coclasses .NET (ExplorerClass et InspectorClass).
• Item n'est pas la propriété par défaut des objets de collection ; il sera impossible d'utiliser des syntaxes de type For Each objMessage In colMessages.
• À cause du complément, il se peut qu'Outlook reste en mémoire après que l'utilisateur l'aura fermé.

Pour plus de détails et pour savoir comment réparer l'assembly généré par TLBIMP, veuillez vous reporter aux articles suivants dans la Base de connaissances de Microsoft :

• BUG: InvalidCastException Is Generated When You Try to Sink Outlook Application Events (Q309336) ( )
• HOW TO: Build an Office COM Add-in by Using Visual Basic .NET (Q302896) ( )

Utilisation de l'assembly PIA d'Office XP

Pour résoudre certains des problèmes que vous pourriez rencontrer avec un assembly d'interopérabilité généré par TLBIMP, téléchargez les PIA (Primary Interop Assembly) d'Office XP sur MSDN Downloads ( ). Quand vous installez les PIA d'Office XP, il devient inutile de réparer l'assembly d'interopérabilité généré par TLBIMP. Le PIA réside dans le cache d'assembly global (GAC, global assembly cache) et évite de créer un assembly d'interopérabilité distinct dans le dossier bin pour chaque projet qui fait référence à une bibliothèque de types Office XP. Imaginez que le PIA est un assembly d'interopérabilité auquel on a donné un statut spécial parce qu'il a été signé numériquement par l'éditeur du composant COM d'origine. Dans le cas qui nous intéresse, l'éditeur de la bibliothèque d'objets Outlook est Microsoft. La figure 2 montre le PIA Microsoft.Office.Interop.Outlook tel qu'il apparaît dans le GAC.

Figure 2. Cache d'assembly global

Avant d'exécuter l'exemple de code qui accompagne cet article, installez les PIA d'Office XP sur l'ordinateur que vous utilisez pour le développement. Si vous souhaitez distribuer votre solution dans un package d'installation, ajoutez Microsoft.Office.Interop.Outlook.dll au projet de configuration.

Pour installer les PIA d'Office XP

1. Extrayez les PIA d'Office XP dans un répertoire d'un ordinateur sur lequel Visual Studio .NET est installé.

2. À partir du menu Démarrer, cliquez sur Programmes, pointez sur Microsoft Visual Studio .NET puis sur Outils Visual Studio .NET et cliquez sur Invite de commandes Visual Studio .NET. La fenêtre Invite de commandes Visual Studio .NET apparaît. Elle facilite l'utilisation des outils du kit de développement .NET Framework SDK.

3. Dans la fenêtre Invite de commandes Visual Studio .NET, utilisez la commande cd (change directory) pour modifier le répertoire dans lequel les PIA d'Office XP ont été extraits. Par exemple, si vous avez extrait les PIA d'Office XP vers C:\PIA Office XP\ dossier, entrez :

   cd C:\PIA Office XP
   
   
   

   et appuyez sur ENTRÉE.

4. Pour installer tous les PIA d'Office XP en même temps, entrez :

   register.bat
   
   

   et appuyez sur ENTRÉE.

Pour utiliser le PIA d'Outlook 2002 dans votre solution

Si vous avez déjà généré votre projet de complément Outlook et ajouté un projet de Programme d'installation à votre solution, ajoutez le PIA d'Outlook 2002 au dossier de sortie du GAC. Les PIA et les fichiers .reg fournis avec le PIA d'Office XP sont redistribuables.

1. Dans la fenêtre Explorateur de solutions, cliquez avec le bouton droit sur votre projet de configuration, pointez sur Afficher et cliquez sur Système de fichiers. Les volets Système de fichiers apparaissent.
2. Cliquez avec le bouton droit sur Système de fichiers de l'ordinateur cible, pointez sur Ajouter un dossier spécial et cliquez sur Dossier Global Assembly Cache. Le Dossier Global Assembly Cache est ajouté à la liste de dossiers Système de fichiers de l'ordinateur cible.
3. Dans la fenêtre Explorateur de solutions, cliquez avec le bouton droit sur Microsoft.Office.Interop.Outlook.dll sous le nom de votre projet Configuration et cliquez sur Propriétés. La fenêtre Propriétés apparaît.
4. Dans la fenêtre Propriétés, dans la zone Dossier, cliquez sur le bouton Sélection (. . .). La boîte de dialogue Sélectionner un dossier apparaît.
5. Cliquez sur Dossier Global Assembly Cache puis sur OK pour fermer la boîte de dialogue Sélectionner un dossier.

Ensuite, ajoutez les entrées de registre du PIA d'Outlook 2002 dans le volet Registre de l'ordinateur cible.

1. Dans la fenêtre Explorateur de solutions, cliquez avec le bouton droit sur votre projet Configuration, pointez sur Afficher et cliquez sur Registre. Les volets Registre de l'ordinateur cible apparaissent.
2. Cliquez avec le bouton droit sur Registre de l'ordinateur cible puis cliquez sur Importer. La boîte de dialogue Importer un fichier du Registre apparaît.
3. Dans le dossier vers lequel vous avez extrait au départ les PIA d'Office XP, localisez le fichier Microsoft.Office.Interop.Outlook.dll.reg et cliquez sur Ouvrir. Les entrées de registre du PIA d'Outlook 2002 sont ajoutées et la boîte de dialogue Importer un fichier du Registre disparaît.

L'exemple d'application OutlookCOMAddinVBNet

L'exemple d'application vous donne un exemple de fonctionnement d'un complément COM pour Outlook créé avec Visual Basic .NET. Avant de consulter l'exemple de code, téléchargez, installez et testez le complément COM d'Outlook pour VB.NET.

Pour télécharger l'exemple de solution OutlookCOMAddinVBNET

1. Téléchargez odc_oladdinvbnet.exe grâce au lien donné au début de l'article.
2. Extrayez OutlookCOMAddinVBNET.exe vers le dossier Projets Visual Studio, dans votre répertoire Mes Documents. Lorsque vous extrayez les fichiers contenus dans OutlookCOMAddinVBNET.exe, utilisez les noms de dossiers donnés dans le fichier à extraction automatique. Vous devez alors disposer d'un dossier nommé OutlookCOMAddinVBNET dans le dossier Projets Visual Studio.

Le dossier OutlookCOMAddinVBNET contient un exemple de projet de complément COM géré Microsoft Visual Basic .NET. Le nom de l'assembly du complément COM est OutlookCOMAddinVBNET. Ce projet sera utilisé pour montrer comment coder un complément COM pour Outlook avec Visual Basic .NET.

• Pour afficher ce projet, ouvrez OutlookCOMAddinVBNET.sln, situé dans  . . .\Mes Documents\Projets Visual Studio\OutlookCOMAddinVBNET\.
• Ce dossier contient aussi un sous-dossier nommé OutlookCOMAddinVBNETSetup qui contient le projet de configuration géré OutlookCOMAddinVBNET.

Installation de l'exemple de solution OutlookCOMAddinVBNET

Remarque :     Avant d'installer la DLL du complément COM géré OutlookCOMAddinVBNET, fermez Microsoft Outlook.

Pour installer le complément COM, procédez comme suit :

1. Pour ouvrir le projet OutlookCOMAddinVBNET dans Visual Studio .NET, ouvrez le fichier OutlookCOMAddinVBNET.sln situé dans . . .\Mes Documents\Projets Visual Studio\OutlookCOMAddinVBNET\.
2. Vous devriez trouver deux projets dans l'explorateur de solutions de l'IDE de Visual Studio .NET : OutlookCOMAddinVBNET et OutlookCOMAddinVBNETSetup.
3. Régénérez d'abord le complément COM géré en cliquant avec le bouton droit sur le projet OutlookCOMAddinVBNET, puis en cliquant sur Régénérer.
4. Ensuite, générez le projet de configuration du complément COM géré en cliquant avec le bouton droit sur le projet OutlookCOMAddinVBNETSetup, puis en cliquant sur Générer.
5. Vous pouvez dès lors installer le complément COM en cliquant avec le bouton droit de la souris sur le projet OutlookCOMAddinVBNETSetup, puis en cliquant sur Installer. Cela lancera l'Assistant de configuration Outlook COM Add-in for VB.NET.
6. Cliquez sur Suivant.
7. Dans la boîte de dialogue Sélectionner le dossier d'installation, acceptez le dossier d'installation par défaut ou choisissez-en un autre.
8. Cliquez sur Suivant.
9. Cliquez sur Suivant pour installer Outlook COM Add-in for VB.NET.

Utilisation du complément COM d'Outlook pour Visual Basic .NET

Après avoir installé l'exemple de complément COM, lancez Outlook. Vous devez voir apparaître un bouton de barre de commandes Visual Basic .NET sur la barre d'outils de l'Explorateur Outlook. Le bouton de barre de commandes Explorateur affiche une boîte de dialogue About Outlook COM Add-in for VB.NET. Si vous avez une connexion Internet en état de fonctionnement, vous serez également capable de trouver les adresses postales des éléments Contact contenus dans le dossier Contacts. Le complément crée un bouton de commandes Resolve Zip (voir figure 3). Lorsque vous cliquez sur le bouton Resolve Zip correspondant à un élément Contact d'Outlook, l'adresse postale du contact est recherchée dans la base de données des services postaux américains par un service Web XML. Enfin, le complément vous empêche d'envoyer des messages sans objet. Le codage de cette fonctionnalité dans un complément COM Outlook est expliqué ci-dessous.

Figure 3. Bouton de barre de commandes Resolve Zip

Bases du codage d'un complément COM Visual Basic .NET pour Outlook

Les sections suivantes présentent la plupart des principes de codage de base qu'il est conseillé d'utiliser lorsque vous créez un complément pour Outlook. Certains de ces principes sont obligatoires, d'autres sont facultatifs et ne reflètent que les préférences de l'auteur. Nous ne présenterons pas l'intégralité du code de l'exemple d'application, mais certains éléments de code sont essentiels à la construction d'un complément d'Outlook qui fonctionne bien. Par exemple, il est indispensable d'implémenter l'interface Extensibility.IDTExtensibility2 dans la classe Connect de votre complément. Si vous n'implémentez pas cette interface, Outlook ne pourra pas charger votre complément en code géré. Vous devez également utiliser des techniques de codage spécifiques à Outlook pour être certain que votre complément ne maintienne pas Outlook.exe en mémoire lorsque l'utilisateur ferme le logiciel. Contrairement aux compléments créés avec Microsoft Visual Basic 6.0, dans Visual Basic .NET, les techniques de gestion de la mémoire utilisent les nettoyages de mémoire réalisés par le CLR (common language runtime). Pour les ressources de code géré, le nettoyage de mémoire est automatique. En revanche, les objets de code non géré représentés par le modèle objet Outlook demandent un nettoyage explicite. Si vous ne supprimez pas correctement de la mémoire les objets liés aux événements, vous aurez des problèmes avec les objets non détruits et Outlook restera en mémoire.

Définition de références et utilisation des importations

Dans l'application exemple, il existe déjà une référence à la bibliothèque d'objets de Microsoft Outlook 10.0. La figure 4 montre Outlook répertorié comme une référence dans la fenêtre Explorateur de solutions. Remarquez que la fenêtre Propriétés à droite de l'Explorateur de solutions indique que le chemin d'accès à l'assembly d'interopérabilité pour Outlook pointe vers le PIA d'Outlook dans le GAC.

Figure 4. Référence à Outlook dans l'Explorateur de solutions

Si vous créez votre propre solution et avez besoin d'une référence à Outlook, utilisez la boîte de dialogue Ajouter une référence pour ajouter une référence à Outlook. La boîte de dialogue Ajouter une référence est montrée à la figure 5.

Figure 5. Boîte de dialogue Ajouter une référence

Pour ajouter une référence à Outlook :

1. Pointez sur **Ajouter une référence. . . ** dans le menu Projet de Visual Studio.
2. Dans la boîte de dialogue Ajouter une référence, cliquez sur l'onglet COM.
3. Dans la Liste des composants, sélectionnez Bibliothèque d'objets Microsoft Outlook 10.0.
4. Cliquez sur le bouton Sélectionner pour ajouter Outlook à la liste des Composants sélectionnés.
5. Cliquez sur OK.

Une fois que vous avez ajouté Outlook comme référence, ajoutez une instruction Imports de façon à ne pas avoir à qualifier entièrement les objets Outlook (en entrant par exemple Microsoft.Office.Interop.Outlook.MailItem). Une instruction Imports apparaîtra après chaque instruction Option et avant chaque déclaration de type. Dans le cas de notre exemple d'application, nous utilisons un alias Import pour Outlook dans les classes Connect et OutlAddIn :

Imports Extensibility
Imports System.Reflection
Imports System.Runtime.InteropServices
Imports Outlook = Microsoft.Office.Interop.Outlook
Imports Microsoft.Office.Core
Imports Microsoft.Win32

Implémentation de l'interface IDTExtensibility2

Tous les compléments COM doivent implémenter l'interface IDTExtensibility2. Contrairement au Concepteur de complément de Visual Basic 6.0, qui expose une interface utilisateur pour la page de propriétés de votre classe Connect, Visual Studio. NET ne prend pas en charge d'interface utilisateur pour IDTExtensibility2. Vous devez créer manuellement les paramètres de registre du complément (LoadBehavior, Description et FriendlyName) en utilisant l'Éditeur du registre de votre projet de configuration, que nous présenterons plus bas. L'interface IDTExtensibility2 fait office de connecteur entre votre complément en code géré et Outlook, qui fonctionne comme l'application hôte des compléments connectés. L'interface IDTExtensibility2 expose cinq événements :

• OnAddinsUpdate : Cet événement se produit lorsqu'un complément est supprimé ou ajouté dans l'objet de collection COMAddins. La collection COMAddins appartient à l'objet Application d'Outlook.
• OnBeginShutdown : Cet événement se produit lorsque l'application amorce sa fermeture. Il n'est pas fiable dans l'environnement Outlook.
• OnConnection : Cet événement se produit lorsque Outlook se charge ou lorsque votre complément est connecté. Le code d'initialisation de votre complément appartient à l'événement OnConnection.
• OnDisconnection : Cet événement se produit lorsqu'un utilisateur déconnecte votre complément dans la boîte de dialogue Compléments COM. Il ne se déclenche pas de façon fiable lorsque l'application hôte, Outlook, est en cours de fermeture. Vous trouverez dans la suite de cet article davantage d'informations sur la méthode à utiliser pour libérer des ressources correctement et pour détecter la fermeture d'Outlook.
• OnStartupComplete : Cet événement se produit après le chargement de l'application hôte et la mise à disposition de toutes ses ressources.

Le code suivant montre comment fonctionne l'événement OnConnection dans Visual Basic .NET. Nous présenterons dans les sections suivantes les instructions de code importantes dans l'événement OnConnection. Si vous connaissez le code OnConnection d'un complément COM dans Visual Basic 6.0, ce code vous semblera familier, mais il comporte néanmoins des éléments nouveaux assez importants :

• l'utilisation d'un bloc Try Catch End Try pour détecter les erreurs.
• les propriétés d'extraction GetType et InvokeMember à partir de variables objet lorsque Option Strict est activé.
• la classe RegistryKey vous permet de rechercher un WriteDiagnostics, qui enregistre les informations de débogage dans un fichier texte.
• l'objet d'application générique passé à l'événement OnConnection doit être explicitement converti en un objet dont le type est Outlook.Application. Les conversions de types implicites de Visual Basic 6.0 ne sont plus autorisées lorsque vous activez Option Strict dans Visual Basic .NET.

'Implements est nécessaire dans les déclarations de la classe Connect.
 Implements Extensibility.IDTExtensibility2
 'La classe OutAddIn sépare le code du complément de la classe Connect.
 Dim m_BaseClass As New OutAddIn()
 Private Sub OnConnection(ByVal application As Object, _
 ByVal connectMode As Extensibility.ext_ConnectMode, _
 ByVal addInInst As Object, ByRef custom As System.Array) _
 Implements Extensibility.IDTExtensibility2.OnConnection
 Dim oApp As Outlook.Application
 Dim oType As Type
 Dim GetProgID As Object
 Dim MyProgID As String
 Dim oArgs As Object()
 Dim Reg As RegistryKey
 Dim strKey As String
 Try
 'Utilisation d'InvokeMember pour obtenir le ProgID de l'objet addInInst.
 oType = addInInst.GetType
 GetProgID = oType.InvokeMember("ProgID", _
 BindingFlags.Public Or BindingFlags.GetField Or _
 BindingFlags.GetProperty, _
 Nothing, _
 addInInst, _
 oArgs)
 MyProgID = CType(GetProgID, String)
 'Recherche de la valeur WriteDiagnostics.
 'Si cette clé est trouvée, DebugWriter écrit dans addinerr.txt.
 strKey = "Software\Microsoft\Office\Outlook\Addins\" _
 & MyProgID
 Reg = Registry.CurrentUser.OpenSubKey(strKey)
 Dim arrayNames As Array = Reg.GetValueNames
 If arrayNames.BinarySearch(arrayNames, "WriteDiagnostics") _
 < 0 Then
 m_blnWriteDiagnostics = False
 Else
 m_blnWriteDiagnostics = True
 End If
 'Fermeture de la clé.
 Reg.Close()
 DebugWriter("OnConnection Called")
 'L'application est convertie d'objet générique en
 'Outlook.Application.
 oApp = CType(application, Outlook.Application)
 'Appel de InitHandler.
 m_BaseClass.InitHandler(oApp, MyProgID)
 Catch ex As SystemException
 DebugWriter("OnConnection Exception: {0}", ex.Message)
 End Try
 End Sub

Architecture à deux classes

OutlookCOMAddinVBNET est généré à l'aide d'une architecture à deux classes. La classe Connect contient le mécanisme générique d'IDTExtensibility2 pour le complément et la classe OutAddin contient le code spécifique à l'application et les objets liés aux événements pour le complément. La classe OutAddin est initialisée par l'instruction Dim m_BaseClass As New OutAddIn() dans la classe Connect. Les classes OutAddin et Connect doivent toutes deux contenir des attributs <GuidAttribute> et <ProgIDAttribute> uniques afin d'être reconnues par COM. Par exemple, voici les attributs de la classe OutlookCOMAddinVBNET.Connect :

<GuidAttribute("14CF4472-86DE-48b0-9FD1-E5CA7673F9A9"), _
ProgIdAttribute("OutlookCOMAddinVBNET.Connect")> _
Public Class Connect
 'Implements est nécessaire.
 Implements Extensibility.IDTExtensibility2
 'Les procédures d'événements IDTExensibility sont placées ici.
 'Code supplémentaire...
End Class

Remarque : Si vous modifiez OutlookCOMAddinVBNET pour qu'il serve de base à votre propre complément, modifiez également les Guids et les ProgIDs des classes Connect et OutAddin. Utilisez la commande Créer GUID du menu Outils pour générer de nouveaux GUID pour votre projet. Veillez à supprimer les {} (accolades) du GUID après avoir collé les nouveaux GUID dans le <GuidAttribute>.

Option Strict

Dans le projet OutlookCOMAddinVBNET, Option Strict a été activé dans la boîte de dialogue Propriétés du projet, comme indiqué à la figure 6. Option Strict exige la déclaration explicite de toutes les variables objet (en activant implicitement Option Explicit) et empêche les conversions de types étendues entre les types d'objet. Si vous désactivez Option Strict, le code de votre complément fonctionnera davantage comme les compléments créés dans Visual Basic 6.0. Toutefois, votre code est alors sujet à d'éventuelles erreurs de conversions de types qui seront exposées au moment de l'exécution et non pendant la conception.

Figure 6. Utilisation de la boîte de dialogue Propriétés du projet pour activer Option Strict

L'activation de Option Strict a des implications pour les différents types d'objets pris en charge par le modèle objet d'Outlook. Par exemple, le modèle objet d'Outlook utilise le type générique Item pour représenter MailItem, AppointmentItem, ContactItem et d'autres classes spécifiques à Outlook. Dans l'exemple d'application, le type générique d'Outlook Item est géré par une classe Friend appelée OutlookItem. Grâce à cette classe, il est possible de retrouver les propriétés de l'Item d'Outlook, comme MessageClass, Subject, EntryID et StoreID à partir d'objets Item. Les propriétés spécifiques d'Item sont renvoyées en tant que propriétés de la classe OutlookItem.

Par exemple, le code de OutlookItem suivant montre comment la propriété ObjectClass est renvoyée pour un objet OutlookItem. CbbZipResolveOnOff est une procédure qui reçoit deux arguments, oItem As Object et blnShow As Boolean. Ces arguments déterminent s'il faut ou non afficher le bouton de barre de commandes Resolve Zip sur un inspecteur Outlook. Puisque Option Strict est activé, une conversion de type implicite entre oItem et la classe Outlook représentée par cet Item n'est pas autorisée. Pour passer outre cette restriction, la classe OutlookItem récupère une partie des propriétés communes de MailItems, PostItems, AppointmentItems, etc. Une grande partie des opérations réalisées dans la classe OutlookItem est effectuée par la fonction GetPropValue. GetPropValue utilise la méthode surchargée InvokeMember pour récupérer un objet qui représente le nom de propriété spécifique passé sous forme d'argument à GetPropValue. InvokeMember est utile lorsque Option Strict est activé et que vous devez déterminer la valeur de la propriété d'un objet.

Private Sub CbbZipResolveOnOff(ByVal oItem As Object, _
 ByVal blnShow As Boolean)
 Dim cbStandard As CommandBar
 Dim oAI As Outlook.AppointmentItem
 Dim oJI As Outlook.JournalItem
 Dim oCI As Outlook.ContactItem
 Dim oDI As Outlook.DistListItem
 Dim oTI As Outlook.TaskItem
 Dim oPI As Outlook.PostItem
 Dim oMI As Outlook.MailItem
 'Utilisation de la classe OutlookItem pour récupérer les propriétés Item.
 Dim MyItem As New OutlookItem(oItem)
 DebugWriter("CbbZipResolveOnOff Called")
 Try
 Select Case MyItem.ObjectClass
 Case Outlook.OlObjectClass.olAppointment
 oAI = CType(oItem, Outlook.AppointmentItem)
 cbStandard = oAI.GetInspector.CommandBars("Standard")
 Case Outlook.OlObjectClass.olMail
 oMI = CType(oItem, Outlook.MailItem)
 cbStandard = oMI.GetInspector.CommandBars("Standard")
 Case Outlook.OlObjectClass.olContact
 oCI = CType(oItem, Outlook.ContactItem)
 cbStandard = oCI.GetInspector.CommandBars("Standard")
 Case Outlook.OlObjectClass.olDistributionList
 oDI = CType(oItem, Outlook.DistListItem)
 cbStandard = oDI.GetInspector.CommandBars("Standard")
 Case Outlook.OlObjectClass.olPost
 oPI = CType(oItem, Outlook.PostItem)
 cbStandard = oPI.GetInspector.CommandBars("Standard")
 Case Outlook.OlObjectClass.olTask
 oTI = CType(oItem, Outlook.TaskItem)
 cbStandard = oTI.GetInspector.CommandBars("Standard")
 Case Outlook.OlObjectClass.olJournal
 oJI = CType(oItem, Outlook.JournalItem)
 cbStandard = oJI.GetInspector.CommandBars("Standard")
 End Select

 If Not cbStandard Is Nothing Then
 CBBZipResolve = _
 CType(cbStandard.FindControl(Tag:="ZipResolve"), _
 CommandBarButton)
 If CBBZipResolve Is Nothing Then
 CBBZipResolve = _
 CType(cbStandard.Controls.Add _
 (Type:= MsoControlType.msoControlButton, _
 Parameter:="ZipResolve"), CommandBarButton)
 End If
 With CBBZipResolve
 .DescriptionText = _
 "Resolve Zip Codes and Addresses using Web Service"
 .BeginGroup = True
 .Caption = "&Resolve Zip"
 .FaceId = 4211
 .Tag = "ZipResolve"
 .TooltipText = _
 "Resolve Zip Codes and Addresses using Web Service"
 .Style = MsoButtonStyle.msoButtonIconAndCaption
 .OnAction = "!<" & m_ProgID & ">"
 .Visible = blnShow
 End With
 End If
 Catch ex As SystemException
 DebugWriter("CbbZipResolveOnOff Exception: {0}", ex.Message)
 End Try
 End Sub

 Public ReadOnly Property ObjectClass() As Outlook.OlObjectClass
 Get
 Return CType(GetPropValue(OlClass), Outlook.OlObjectClass)
 End Get
 End Property

 Public Function GetPropValue(ByVal strPropName As String) As Object
 Try
 GetPropValue = m_Type.InvokeMember(strPropName, _
 BindingFlags.Public Or BindingFlags.GetField Or _
 BindingFlags.GetProperty, _
 Nothing, _
 m_Item, _
 m_Args)
 Catch ex As SystemException
 Debug.WriteLine(String.Format _
 ("OutLookItem: GetPropValue for {0} Exception: {1} ", _
 strPropName, ex.Message))
 End Try
 End Function

Appel de InitHandler

La procédure InitHandler de la classe OutAddin initialise les objets liés aux événements pour OutlookCOMAddinVBNET. Elle est déclarée à l'aide du mot-clé Friend de façon à pouvoir être appelée à partir de OnConnection dans la classe Connect, mais n'est pas visible publiquement. Elle crée également un bouton de barre de commandes sur la barre d'outils standard de l'Explorateur Outlook. Le bouton de barre de commandes affiche un formulaire Windows Server System qui donne des informations sur l'application OutlookCOMAddinVBNET.

Friend Sub InitHandler(ByVal oApp As Outlook.Application, _
 ByVal strProgID As String)
 Dim oCommandBars As CommandBars
 Dim oStandardBar As CommandBar
 DebugWriter("InitHandler Called")
 Try
 'WithEvents déclaré
 m_olOutlook = oApp 'Objet Application
 'Instanciation de la variable d'application Outlook au niveau du module public.
 m_olApp = oApp
 'La chaîne ProgID est nécessaire pour CommandBarControls.
 m_ProgID = strProgID
 'Instanciation des objets liés aux événements.
 m_olNamespace = m_olOutlook.Session
 m_olExplorers = m_olOutlook.Explorers
 m_olInspectors = m_olOutlook.Inspectors
 'Une conversion de type est nécessaire en raison du problème de « nom ambigu ».
 m_olExplorer = CType(m_olOutlook.ActiveExplorer, _
 Outlook.ExplorerClass)
 'Création d'un bouton de barre de commandes.
 'Création d'un bouton personnalisé sur la barre de commandes standard.
 oCommandBars = m_olExplorer.CommandBars
 oStandardBar = oCommandBars.Item("Standard")
 ' Si le bouton n'a pas été supprimé, l'utiliser.
 CBBAbout =CType(oStandardBar.FindControl _
 (Tag:="Visual Basic .NETSample"), CommandBarButton)
 If CBBAbout Is Nothing Then
 CBBAbout = CType(oStandardBar.Controls.Add _
 (Type:=MsoControlType.msoControlButton, _
 Temporary:=False), CommandBarButton)
 With CBBAbout
 .Caption = ".NET"
 .Style = MsoButtonStyle.msoButtonIconAndCaption
 .FaceId = 472
 .TooltipText = _
 "About Outlook COM Add-in for Visual Basic .NET"
 .BeginGroup = False
 ' Utilisation de la propriété Tag pour trouver le contrôle.
 .Tag = "Visual Basic .NETSample"
 .OnAction = "!<" & m_ProgID & ">"
 ' Faire en sorte que le bouton soit visible.
 .Visible = True
 End With
 End If
 Catch ex As SystemException
 DebugWriter("InitHandler Exception: {0}", ex.Message)
 End Try
 End Sub

Création d'objets liés aux événements

Les objets liés aux événements (comme m_olOutlook, m_olNamespace, m_olExplorers, m_olExplorer et m_olInspectors) sont instanciés dans InitHandler. Ces objets répondent aux événements provoqués par le modèle objet d'Outlook. Il s'agit d'événements COM et le CLR fournit les points de connexion afin que le code géré du complément puisse répondre aux événements COM hébergés par Outlook. Visual Basic .NET fournit deux méthodes pour raccorder des événements :

• En utilisant le classique Dim WithEvents m_olOutlook As Outlook.Application puis en écrivant le code de procédure d'événement à l'aide de la clause Handles. Cette approche est utilisée dans le projet OutlookCOMAddinVBNET.

  Dim WithEvents m_olOutlook As Outlook.Application
  'Faire autant de déclarations d'objets liés
  'aux événements supplémentaires que nécessaire.
  Private Sub m_olOutlook_NewMail() Handles m_olOutlook.NewMail
  'Le code de l'événement se place ici
  End Sub
  
  

• En utilisant les nouvelles instructions AddHandler et RemoveHandler de Visual Basic .NET. Ces instructions peuvent connecter et déconnecter dynamiquement les gestionnaires d'événements et les procédures d'événements dans votre code. Contrairement à la technique WithEvents, AddHandler et RemoveHandler vous permettent d'associer plusieurs gestionnaires d'événements à un même événement.

  Private Sub TestLocalEventHander()
  Dim m_olApp As New Outlook.Application()
  AddHandler m_olApp.NewMail, AddressOf Me.EventHandlerNewMail
  'Code supplémentaire
  RemoveHandler m_olApp.NewMail, AddressOf Me.EventHandlerNewMail
  End Sub
  
  

Private Sub EventHandlerNewMail() 'Le code d'événement se place ici. End Sub

> **Remarque :** N'utilisez pas **WithEvents** et **AddHandler/RemoveHandler** pour un même événement.

Utilisées ensemble, les versions actuelles du PIA d'Outlook et du compilateur de Visual Basic .NET génèrent un problème lorsque vous essayez de déclarer des objets liés aux événements en utilisant certaines classes Outlook. Par exemple, si vous utilisez Dim m_olExplorer As Outlook.Explorer et que vous tentez ensuite de créer une procédure d'événement pour l'événement Close, Visual Basic .NET affichera l'erreur de conception suivante dans la Liste des tâches :

Remarque : « Close » est ambigu dans les interfaces héritées 'Microsoft.Office.Interop.Outlook._Explorer' et 'Microsoft.Office.Interop.Outlook.ExplorerEvents_10_Event'.

Pour éviter ce message et permettre la compilation de votre projet, vous devez utiliser la coclasse RCW ou .NET pour les déclarations de certains objets Outlook qui provoquent des erreurs de conception de type « nom ambigu ». Par exemple, la syntaxe suivante fonctionne correctement pour la déclaration de l'objet lié aux événements m_olExplorer et de l'objet m_olExplorer_Close. m_olExplorer est déclaré en tant qu'objet ExplorerClass et non en tant qu'objet Explorer :

'Les déclarations sont réalisées avec WithEvents et des coclasses.
Dim WithEvents m_olExplorer As Outlook.ExplorerClass
Private Sub m_olExplorer_Close() _
Handles m_olExplorer.ExplorerEvents_Event_Close
 'Le code de l'événement se place ici.
 End Sub

Remarque : Ce problème sera résolu dans les versions à venir du compilateur de Visual Basic .NET.

Intégration de Services Web

L'un des avantages les plus évidents du développement avec Visual Basic .NET, tient à la facilité d'intégration des Services Web dans votre projet. Si vous sélectionnez la commande Ajouter une référence Web dans le menu Projet, Visual Studio affiche la boîte de dialogue Ajouter une référence Web. Visual Studio crée alors en coulisses tout le code nécessaire pour ajouter le service Web XML à votre projet et appeler les propriétés et méthodes des objets fournis par le service Web XML. Le code ci-dessous pour CBBZipResolve appelle le service Web XML pour retrouver l'adresse postale de m_olContactItem, qui représente un objet ContactItem. Le service Web ZipResolver renvoie l'adresse postale en majuscules, mais le code suivant utilise la classe .NET intégrée CultureInfo pour renvoyer une chaîne dans la casse adaptée au nom d'une rue et d'une ville dans une adresse postale.

Private Sub CBBZipResolve_Click(ByVal Ctrl As _
 Microsoft.Office.Core.CommandBarButton, _
 ByRef CancelDefault As Boolean) Handles CBBZipResolve.Click
 Dim strAddress, strCity, strState As String
 Try
 If IsUSPostalAddress(m_olContactItem) Then
 strAddress = m_olContactItem.MailingAddressStreet
 strCity = m_olContactItem.MailingAddressCity
 strState = m_olContactItem.MailingAddressState
 Dim fWait As New frmWait()
 Dim oCorrectedAddress As _
 New net.eraserver.webservices.USPSAddress()
 Dim oZipResolve As _
 New net.eraserver.webservices.ZipCodeResolver()
 'Affiche fWait puisqu'il est impossible d'afficher un sablier.
 fWait.Show()
 System.Windows.Forms.Application.DoEvents()
 oZipResolve.Url = _
 "http://webservices.eraserver.net/zipcoderesolver/" &
 _
 "zipcoderesolver.asmx?WSDL"
 oCorrectedAddress = _
 oZipResolve.CorrectedAddressXml _
 ("0", strAddress, strCity, strState)
 fWait.Close()
 'oCorrectedAddress.Street renvoie Nothing si elle est introuvable.
 If oCorrectedAddress.Street Is Nothing Then
 MsgBox("Unable to resolve this address.", _
 MsgBoxStyle.Information, _
 "Outlook COM Add-in for VB.NET")
 Else
 Dim oContact As Outlook.ContactItem = _
 CType(m_olApp.ActiveInspector.CurrentItem, _
 Outlook.ContactItem)
 With oContact
 .MailingAddressStreet = _
 GetProper(oCorrectedAddress.Street)
 .MailingAddressCity = _
 GetProper(oCorrectedAddress.City)
 .MailingAddressState = oCorrectedAddress.State
 .MailingAddressPostalCode = _
 oCorrectedAddress.FullZIP
 End With
 End If
 Else
 MsgBox("Not a valid postal address!", _
 MsgBoxStyle.Exclamation, _
 "Outlook COM Add-in for VB.NET")
 End If
 Catch ex As System.Exception
 MsgBox("Error invoking Zip Code Resolver Web Service." _
 & vbCrLf & ex.Message, MsgBoxStyle.Information, _
 "Outlook COM Add-in for VB.NET")
 End Try
 End Sub

 'Cette fonction convertit les adresses USPS (en majuscules)
 ' pour mettre une majuscule au début de chaque mot.
 string
 Private Function GetProper(ByVal strInput As String) As String
 On Error Resume Next
 If Len(strInput) = 0 Then
 Exit Function
 End If
 Dim oCI As New CultureInfo("en-us")
 GetProper = oCI.TextInfo.ToTitleCase(LCase(strInput))
 End Function

Détection de la fermeture d'Outlook

L'une des grandes difficultés de la programmation de compléments Outlook est de s'assurer qu'Outlook ne reste pas en mémoire après sa fermeture à cause du complément. Outlook se ferme lorsqu'il ne reste plus d'inspecteurs ou d'explorateurs ouverts. Outlook est différent des autres produits Office dans la mesure où il dispose de deux classes pour son interface utilisateur, l'explorateur et l'inspecteur. Si l'on ferme la fenêtre principale de l'explorateur d'Outlook mais qu'une fenêtre d'inspecteur est restée ouverte, Outlook est encore ouvert. La détection de la fermeture est compliquée car certains appels d'Outlook (comme Envoyer vers Destinataire depuis le menu contextuel de l'Explorateur de Microsoft Windows) n'incrémentent pas les compteurs des fenêtres d'explorateur et d'inspecteur. Si des références à des objets sont encore actives dans votre complément à la fermeture d'Outlook, ce dernier restera en mémoire à cause de votre complément.

Normalement, l'événement OnDisconnection exposé par l'interface IDTExtensibility2 pourrait fournir un moyen pour que votre code nettoie les objets et garantisse la bonne réalisation de la séquence de fermeture. Mais l'événement OnDisconnection ne se déclenche pas à coup sûr lorsque le mode de fermeture est égal à ext_DisconnectMode.ext_dm_HostShutdown.

Pour résoudre ce problème, la solution la plus connue est d'utiliser l'événement Close à la fois pour les objets Inspecteur et pour les objets Explorateur. L'événement Close appelle UnInitHandler, qui nettoie les objets. Puisque pour ces objets, l'événement Close déclenche l'erreur de conception « ambiguïté sur plusieurs interfaces héritées », vous devez déclarer des objets liés aux événements en utilisant les classes ExplorerClass et InspectorClass respectivement. Le code suivant, tiré de la classe OutAddin, détecte correctement la fermeture de l'interface utilisateur d'Outlook.

'Les déclarations sont réalisées avec WithEvents et des coclasses.
 Dim WithEvents m_olExplorer As Outlook.ExplorerClass
 Dim WithEvents m_olInspector As Outlook.InspectorClass
'Code de l'événement Close pour l'explorateur :
 Private Sub m_olExplorer_Close() _
 Handles m_olExplorer.ExplorerEvents_Event_Close
 Try
 DebugWriter("Explorer_Close Called", "")
 m_olExplorer = CType(m_olApp.ActiveExplorer, _
 Outlook.ExplorerClass)
 If (m_olExplorer Is Nothing) And _
 (m_olApp.Inspectors.Count = 0) Then
 UnInitHandler()
 End If
 Catch ex As SystemException
 DebugWriter("Explorer_Close Exception: {0}", ex.Message)
 End Try
 End Sub
 'Code de l'événement Close pour l'inspecteur :
 Private Sub m_olInspector_Close() _
 Handles m_olInspector.InspectorEvents_Event_Close
 Try
 DebugWriter("Inspector_Close Called", "")
 If m_olApp.ActiveExplorer Is Nothing And _
 m_olApp.Inspectors.Count <= 1 Then
 UnInitHandler()
 End If
 Catch ex As SystemException
 DebugWriter("Inspector_Close Exception: {0}", ex.Message)
 End Try
 End Sub

Appel de UnInitHandler et élimination des objets

Une fois que l'événement Close a appelé la procédure UnInitHandler indiquée ci-dessous, il vous faut éliminer correctement vos objets. Si vous n'éliminez pas tous les objets déclarés et instanciés dans votre complément, Outlook restera en mémoire après sa fermeture. Le code de nettoyage des objets doit être placé dans un bloc Try...Catch...Finally...End Try. Pour les compléments créés avec Visual Basic 6.0, la bonne pratique de codage est de définir toutes les variables d'objets sur Nothing pendant la procédure UnInitHandler. Pour les objets COM dans Visual Basic 6.0, en définissant l'objet sur Nothing, on élimine la référence à l'objet et on libère l'objet de la mémoire. Pour les compléments .NET qui fonctionnent avec Outlook (basé sur COM), l'élimination des objets COM est plus complexe. La procédure DisposeObject est appelée sur toutes les classes ou les variables objet au niveau des modules qui sont encore disponibles. DisposeObject appelle Marshal.ReleaseCOMObject(obj) jusqu'à ce que le compteur de références soit à zéro. Marshal.ReleaseCOMObject procède à la libération des objets COM. Dans le bloc Finally de UnInitHandler, grâce à GC.Collect et à GC.WaitforPendingFinalizers, le CLR nettoie les objets RCW restants et garantit la bonne fermeture d'Outlook.

Friend Sub UnInitHandler()
 'Vous devez déréférencer tous les objets dans cette procédure,
 'sans quoi Outlook restera en mémoire.
 Dim oCommandBars As CommandBars
 Dim oStandardBar As CommandBar
 Dim oCBB As CommandBarButton
 Try
 If m_blnRunUnInitHandler Then
 Exit Sub
 Else
 m_blnRunUnInitHandler = True
 End If
 DebugWriter("UnInitHandler Called")
 ' Suppression du bouton de barre de commandes Explorateur.
 If Not (CBBAbout Is Nothing) Then
 CBBAbout.Delete()
 End If
 ' Suppression du bouton de barre de commandes Inspecteur.
 CbbZipResolveRemove()
 ' Libération de tous les objets Outlook dimensionnés avec WithEvents.
 DisposeObject(m_olMailItem)
 DisposeObject(m_olPostItem)
 DisposeObject(m_olAppointmentItem)
 DisposeObject(m_olContactItem)
 DisposeObject(m_olDistListItem)
 DisposeObject(m_olJournalItem)
 DisposeObject(m_olTaskItem)
 DisposeObject(m_olInspector)
 DisposeObject(m_olExplorer)
 DisposeObject(m_olInspectors)
 DisposeObject(m_olExplorers)
 DisposeObject(m_olReminders)
 DisposeObject(m_olResults)
 DisposeObject(m_olViews)
 DisposeObject(m_olNamespace)
 DisposeObject(m_olApp)
 DisposeObject(m_olOutlook)
 Catch ex As SystemException
 DebugWriter("UnInitHandler Exception: {0}", ex.Message)
 Finally
 ' Exécution du nettoyage final de la mémoire.
 GC.Collect()
 GC.WaitForPendingFinalizers()
 End Try
 End Sub

 Private Sub DisposeObject(ByVal obj As Object)
 Dim count As Integer
 DebugWriter("DisposeObject Called")
 Try
 If obj Is Nothing Then
 Exit Try
 End If
 count = Marshal.ReleaseComObject(obj)
 DebugWriter(String.Format("DisposeObject - Release {0}, _
 RefCount: {1}", obj.ToString(), count), "")
 While count > 0
 count = Marshal.ReleaseComObject(obj)
 End While
 Catch ex As SystemException
 DebugWriter("DisposeObject Exception: {0}", ex.Message)
 Finally
 obj = Nothing
 End Try
 End Sub

Travailler avec un projet de configuration

Vous connaissez maintenant l'essentiel du code de fonctionnement d'un complément Outlook construit avec Visual Basic .NET. L'exemple de projet OutlookCOMAddinVBNET est accompagné du projet de configuration appelé OutlookCOMAddinVBNETSetup. Il existe plusieurs questions de configuration sur lesquelles il faut se pencher lorsque l'on déploie un complément développé avec Visual Basic .NET :

• Vous devez installer Microsoft .NET Framework (environ 20 Mo) sur la machine cible avant d'installer votre complément.

• Vous devez installer le PIA d'Outlook sur la machine cible. Voyez pour cela la section ci-dessus : « Pour utiliser le PIA d'Outlook 2002 dans votre solution ».

• Si votre projet de configuration installe les clés du registre du complément dans HKEY_LOCAL_MACHINE (HKLM) et non dans HKEY_CURRENT_USER (HKCU), le complément ne sera pas visible dans la boîte de dialogue des compléments COM pour Outlook.

• Cette boîte de dialogue affichera le moteur du CLR, mscoree.dll, en tant que source de votre complément plutôt que le nom de votre code géré (voir figure 7). Dans le cas de l'exemple d'application, le nom du fichier en question est OutlookCOMAddinVBNET.dll.

  

  Figure 7. Boîte de dialogue Compléments COM

Exigences en cas de distribution de la configuration

À ce stade, il n'existe pas de solution pratique pour contourner la nécessité d'installer .NET Framework. Il se peut que .NET Framework soit installé sur les versions ultérieures de Microsoft Windows ou d'Office, de sorte qu'aucune distribution supplémentaire ne sera nécessaire.

Microsoft conseille de ne pas distribuer les solutions à l'aide de l'assembly d'interopérabilité généré par TLBIMP. Le mieux aujourd'hui est d'utiliser le PIA d'Outlook, qui n'est disponible pour l'instant que pour Outlook 2002. À l'heure de la rédaction de cet article, l'arrivée d'un PIA pour Office 2000 ni pour Outlook 2000 n'est pas prévue.

Pour distribuer votre complément à d'autres utilisateurs, suivez les instructions ci-dessous :

1. Veillez à ajouter le PIA d'Outlook à votre projet de configuration en suivant les étapes décrites ci-dessus dans la section « Pour utiliser le PIA d'Outlook 2002 dans votre solution ».

2. Vous pouvez exclure stdole.dll et office.dll de la liste des Dépendances détectées de votre projet de configuration.

3. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Nom_de_votre_projet_de_configuration, puis cliquez sur Générer. Cela crée un fichier Setup.exe ainsi que les fichiers .msi nécessaires dans le dossier Nom_de_votre_projet_de_configuration\Debug ou Nom_de_votre_projet_de_configuration\Release, selon le type de génération utilisé.

4. Copiez le contenu du dossier Nom_de_votre_projet_de_configuration\Debug ou Nom_de_votre_projet_de_configuration\Release sur l'ordinateur cible sur lequel vous voulez installer le complément.

5. Lancez Setup.exe pour installer le complément partagé .NET.

   Remarque : Dans l'exemple de projet OutlookCOMAddinVBNETSetup, toutes ces opérations ont été réalisées pour vous. Sachez que, pour minimiser la taille du téléchargement, le projet de configuration OutlookCOMAddinVBNET n'inclut pas les fichiers d'amorçage de Windows Installer.

Comportement du complément lors du chargement

Le comportement au chargement d'un complément COM pour Outlook est contrôlé par des paramètres du registre Windows. Si le complément est inscrit sous HKLM, le complément ne sera pas visible dans la boîte de dialogue Compléments COM d'Outlook. L'inscription sous HKLM empêche les utilisateurs de déconnecter le complément via la boîte de dialogue Compléments COM. Le tableau 1 indique les valeurs DWORD de LoadBehavior. Ces valeurs s'appliquent pour HKCU et pour HCLM.

Tableau 1. Paramètres de registre LoadBehavior

Vous devez créer dans votre projet de configuration des valeurs de registre pour LoadBehavior, Description et FriendlyName. Ces valeurs sont stockées dans HKCU ou HKLM\Software\Microsoft\Office\Outlook\Addins\ProgID.

ProgID est l'identificateur de programmation de votre complément. Les clés de l'exemple de projet OutlookCOMAddinVBNETSetup sont indiquées dans l'Éditeur du registre, figure 8. Lorsque le complément est installé par votre projet de configuration, les paramètres de registre provoquent le chargement du complément pendant le démarrage d'Outlook.

Figure 8. Utilisation de l'Éditeur du registre pour créer les paramètres de registre du complément

**Remarque :**Vous ne pouvez pas utiliser la boîte de dialogue Compléments COM d'Outlook pour ajouter manuellement un complément en code géré à la liste des compléments installés. Outlook vous renverra que « <addin.dll> n'est pas un complément Office valide ». Si vous souhaitez déployer l'exemple de complément, vous devez utiliser le fichier .msi créé par votre projet de configuration Visual Studio .NET.

Si vous avez créé votre complément avec l'Assistant Complément Visual Studio, sachez que les choix que vous avez faits dans l'Assistant Complément contrôlent la ruche du registre (HKLM ou HKCU) dans laquelle votre complément est inscrit. Pour plus de détails, veuillez vous reporter à l'article PRB: Visual Studio .NET Shared Add-in Is Not Displayed in Office COM Add-ins Dialog Box (Q316723) ( ) de la Base de connaissances de Microsoft.

Compléments et sécurité dans Outlook

Un dernier point important quant à la configuration : votre complément en code géré semble être fourni par mscoree.dll, le moteur du CLR. En fait, ce que vous apercevez dans la boîte de dialogue Compléments COM est plus qu'une apparence. Il est vrai, en fait, que du point de vue de COM, le paramètre InprocServer32 de votre complément pointe vers mscoree.dll. La clé InprocServer32 contient une valeur CodeBase qui pointe vers l'emplacement de l'assembly de votre complément en code géré. Cette dépendance vis-à-vis de mscoree.dll représente un problème si vous tentez d'ajouter votre complément à la liste des compléments fiables dans le Formulaire de sécurité d'Outlook du dossier public Paramètres de sécurité d'Outlook. Nous n'entrerons pas ici dans les détails de cette question, mais il est important d'avoir connaissance des points suivants :

• Tous les compléments dans Outlook sont considérés comme fiables par défaut, qu'ils soient en code géré ou non géré.
• Contrairement à d'autres applications Office, les paramètres de sécurité des macros d'Outlook (Faible, Moyen ou Élevé) ne déterminent pas le chargement ou le non-chargement d'un complément.
• Tous les compléments sont soumis aux restrictions de protection du modèle objet imposées par la mise à jour de sécurité des courriers électroniques d'Outlook. Les restrictions de protection du modèle objet comprennent l'envoi par programmation, l'accès aux objets destinataires, etc. Si vous souhaitez utiliser les propriétés et les méthodes bloquées du modèle objet d'Outlook dans votre complément, vous pouvez éviter les avertissements de sécurité d'Outlook en ajoutant votre complément à la liste des compléments fiables. Pour plus de détails, veuillez vous reporter à l'article de la Base de connaissances n° Q290500, OL2002: Developer Information About E-Mail Security Features ( ).
• N'ajoutez pas mscoree.dll à la liste des compléments fiables. Ceci permettrait à tous les compléments utilisant le CLR d'être considérés comme fiables. Puisque vous ne voulez accorder cette confiance qu'à un complément spécifique, vous devez créer un complément COM de compensation qui jouera le rôle de proxy pour votre complément en code géré. Veuillez vous reporter à l'article Q322027 de la Base de connaissances : OL2002: COM Add-Ins Are Not Trusted If They Are Created with Visual Studio .NET ( ) pour plus de précisions, ainsi que Utilisation d'une solution à base de shim en vue de déployer des compléments COM gérés dans Office XP ( ).

Conclusion

Vous devez respecter certaines pratiques de codage importantes lorsque vous créez un complément Outlook avec Visual Basic .NET. Vous devez également être conscient des impératifs liés à la configuration lorsque vous déployez votre complément sur une machine cible. Les classes intégrées à .NET Framework offrent des avantages non négligeables par rapport à l'écriture et à la maintenance de code auxiliaire dans Visual Basic 6.0. En ce qui concerne l'utilisation de Services Web, un complément .NET n'a pas besoin des classes de proxy qui sont indispensables aux compléments Visual Basic pour Applications ou Visual Basic 6.0. Si vous créez un complément Outlook qui utilise un service Web XML et que vous parvenez à installer .NET Framework, envisagez d'écrire votre composant avec Visual Basic .NET.

Dernière mise à jour le mercredi 11 décembre 2002

Pour en savoir plus

• Informations techniques Visaul Basic .NET