Collecte de statistiques Outlook 2007 à l'aide de VSTO 2005 SE

Paru le 22 janvier 2007

Cet article démontre comment créer un complément pour Outlook à l'aide de VSTO 2005 SE pour écouter les événements d'Outlook, stocker les données d'utilisation d'Outlook et produire des rapports sur cette utilisation dans un formulaire personnalisé et une zone de formulaire.

Kevin Marshall, Clarity Consulting, Inc.
Blogs Clarity

Difficulté : Intermédiaire
Durée : 1-3 heures
Coût : Gratuit
Logiciel : Office 2007 Visual Studio Express VSTO 2005 SE Modèles de compléments Outlook
Matériel :
Télécharger : Télécharger

Outlook est utilisé quotidiennement par beaucoup de gens, mais peu d'entre eux connaissent probablement toute la valeur des informations que dévoile leur utilisation d'Outlook. Combien de temps, en moyenne, vous faut-il pour répondre à vos messages électroniques ? Combien d'heures passez-vous en réunion chaque semaine ? À l'aide de Visual Studio Tools for Office Second Edition (VSTO 2005 SE) et Office 2007, vous pouvez trouver facilement les réponses à ces questions et bien plus en créant un complément pour Outlook. Cet article démontre comment vous pouvez écouter les événements Outlook, stocker les données d'utilisation d'Outlook et produire des rapports sur cette utilisation dans un formulaire personnalisé et, nouveauté VSTO 2005 SE, dans une zone de formulaire.

Collecting Outlook 2007 Statistics Using VSTO 2005 SE

Qu'est-ce que VSTO 2005 SE ?

VSTO 2005 SE est un module complémentaire gratuit de Visual Studio 2005 qui permet aux développeurs de créer des applications destinées au système Office 2007. Les développeurs peuvent créer des solutions basées sur Office à l'aide de l'environnement de développement professionnel de Visual Studio 2005 et des nouvelles fonctionnalités de modèle de programmation d'Office 2007 comme la barre de ruban et les zones de formulaire personnalisées.

Création d'un projet de complément Outlook

Après avoir installé VSTO 2005 SE et le modèle de complément Outlook, vous pouvez commencer à créer un complément pour Outlook 2007. Créez un nouveau projet, puis sélectionnez Complément Office Outlook 2007 dans le groupe Mes modèles et cliquez sur OK.

Le projet nouvellement créé contiendra plusieurs fichiers. Connect.cs est le fichier principal qui contient deux méthodes, InitializeAddin et ShutdownAddin, qui vous fournissent un point de départ pour la connexion avec Outlook.

Initialisation du complément

La méthode InitializeAddin est appelée dès que votre complément est chargé dans la mémoire. Pour notre complément, nous ferons trois choses pendant le démarrage :
Créer une instance de notre classe EventTracker. Il s'agit de la classe principale qui contrôle toute la logique du traitement des rendez-vous et éléments de courrier entrants.
Charger les données existantes d'Outlook à l'aide de EventTracker.
Ajouter un élément de menu à la barre d'outils d'Outlook. L'élément de menu est utilisé pour afficher la fenêtre de rapport.

Visual C#

 private void InitalizeAddin()
 {
   //Initialize report menu item
   this.InitializeMenu();
 
   // Initialize the event tracker object.
   _eventTracker = new EventTracker(this.Application);
 
   ListenToEvents(true);
 
   _eventTracker.LoadData();
 }

Visual Basic

 
 Private Sub InitalizeAddin()
    '//Initialize report menu item
   InitializeMenu()
    '// Initialize the event tracker object.
   _eventTracker = New EventTracker(Me.Application)
    ListenToEvents(True)
   _eventTracker.LoadData()
 End Sub

Les éléments de menu au plus haut niveau peuvent être créés de la même façon dans l'application office. Pour ce complément, nous créons un nouveau menu â€oeRapports”, avec un seul élément de menu pour lancer la fenêtre contextuelle du rapport.

Visual C#

 // Get the Outlook menu bar.
 _menuBar = this.Application.ActiveExplorer().CommandBars.ActiveMenuBar;
  
// Get the index of the Help menu item on the Outlook menu bar.
 _helpMenuIndex = _menuBar.Controls[_MENU_BEFORE].Index;
 // Add the top-level menu right before the Help menu.
 _topMenu = 
 (Office.CommandBarPopup)_menuBar.Controls.Add(Office.MsoControlType.msoControlPopup,
   Type.Missing, Type.Missing, _helpMenuIndex, true);
 _topMenu.Caption = "Reports";
 _topMenu.Visible = true;
 
 // Add the menu item for loading email reports.
 _reports = 
   (Office.CommandBarButton)_topMenu.Controls.Add(Office.MsoControlType.msoControlButton, 
   Type.Missing, Type.Missing, Type.Missing, true);           
   Type.Missing, Type.Missing, Type.Missing, true);
 
 _reports.Caption = "Calendar / Email Reports";
 _reports.Visible = true;

Visual Basic

 '// Get the Outlook menu bar.
 _menuBar = Me.Application.ActiveExplorer().CommandBars.ActiveMenuBar
 
 '// Get the index of the Help menu item on the Outlook menu bar.
 _helpMenuIndex = _menuBar.Controls(_MENU_BEFORE).Index
 
 '// Add the top-level menu right before the Help menu.
 _topMenu = 
   CType(_menuBar.Controls.Add(Office.MsoControlType.msoControlPopup, _
      Type.Missing, Type.Missing, _helpMenuIndex, True), Office.CommandBarPopup)
 _topMenu.Caption = "Reports"
 _topMenu.Visible = True
 
 ' Add the menu item for loading email reports.
 _reports = _topMenu.Controls.Add(Office.MsoControlType.msoControlButton, _
         Type.Missing, Type.Missing, Type.Missing, True)
 _reports.Caption = "Calendar / Email Reports"
 _reports.Visible = True

Chargement des statistiques basées sur les données existantes d'Outlook

Les données permettant de générer des rapports sur l'utilisation d'Outlook sont enregistrées dans une base de données SQL Express. Lorsque le complément se charge pour la première fois, il doit analyser les dossiers de courrier et calendrier pour rassembler les statistiques sur les éléments existants. La classe EventTracker gère le chargement de données initial, ainsi que les événements liés déclenchés lorsque de nouveaux éléments sont ajoutés à ces dossiers.
Le schéma de la base de données contient des tableaux pour enregistrer les informations relatives à trois types d'éléments pour lesquelles nous collectons des statistiques : les éléments de boîte de réception, les éléments de courrier envoyé et les éléments de rendez-vous.

Puisque l'analyse des dossiers peut prendre du temps si vous êtes comme moi et conservez tous les messages électroniques reçus, il vaut mieux démarrer le chargement de données initial sur un thread séparé. Outlook peut maintenant continuer à répondre à l'entrée de l'utilisateur, pendant que le complément fait son travail.

Visual C#

 public void LoadData()
 {
   //create new thread for large inboxes
   Thread thread = new Thread(new ThreadStart(CheckInitialLoad));
   thread.IsBackground = true;
   thread.Start();
 }
 
 Visual Basic
 Public Sub LoadData()
   Dim thread As Thread = New Thread(AddressOf CheckInitialLoad)
   thread.IsBackground = True
   thread.Start()
 End Sub

Le chargement de données initial déclenche une erreur pour notifier l'autre code, comme le formulaire d'affichage des rapports, que les données ne sont pas encore prêtes pour la génération des rapports. Si la base de données ne contient aucune donnée existante, le chargement des données ajoute alors des enregistrements pour chaque élément existant. Autoriser le thread à dormir brièvement entre les itérations empêche le chargement de données d'interférer avec la réceptivité du thread Outlook principal.

Visual C#

 private void CheckInitialLoad()
 {
   if (!object.Equals(StartDataLoad,null))
   {
      StartDataLoad(this, null);
   }
  
ReportDBDataSetTableAdapters.SentMailTableAdapter sentItemTA = 
   new ReportDBDataSetTableAdapters.SentMailTableAdapter();
 ReportDBDataSetTableAdapters.InboxTableAdapter inboxTA = 
   new ReportDBDataSetTableAdapters.InboxTableAdapter();
 ReportDBDataSetTableAdapters.CalendarTableAdapter calTA = 
   new ReportDBDataSetTableAdapters.CalendarTableAdapter();
   
//check to see if calendar stats have been loaded
   if (calTA.GetData().Rows.Count == 0)
   {
      foreach (object item in _calendarItems)
      {
         if (item is Outlook.AppointmentItem)
         {
            AddCalendarItem(item as Outlook.AppointmentItem);
         }
         Thread.Sleep(10);
      }
   }
   if (!object.Equals(StopDataLoad, null))
   {
      StopDataLoad(this, null);
   }
 }

Visual Basic

 Private Sub CheckInitialLoad()
 
   RaiseEvent StartDataLoad(Me, Nothing)
 
   Dim sentItemTA As ReportDBDataSetTableAdapters.SentMailTableAdapter = _
      New ReportDBDataSetTableAdapters.SentMailTableAdapter
   Dim inboxTA As ReportDBDataSetTableAdapters.InboxTableAdapter = _
      New ReportDBDataSetTableAdapters.InboxTableAdapter
   Dim calTA As ReportDBDataSetTableAdapters.CalendarTableAdapter = _
      New ReportDBDataSetTableAdapters.CalendarTableAdapter
   
If calTA.GetData.Rows.Count = 0 Then
      For Each item As Object In _calendarItems
         If TypeOf item Is Outlook.AppointmentItem Then
            AddCalendarItem(CType(item, Outlook.AppointmentItem))
         End If
         Thread.Sleep(10)
      Next
   End If
   If inboxTA.GetData.Rows.Count = 0 Then
       For Each item As Object In _inboxItems
          If TypeOf item Is Outlook.MailItem Then
             AddInboxItem(CType(item, Outlook.MailItem))
          End If
          Thread.Sleep(10)
        Next
    End If
    If sentItemTA.GetData.Rows.Count = 0 Then
       For Each item As Object In _sentMailItems
          If TypeOf item Is Outlook.MailItem Then
             AddSentMailItem(CType(item, Outlook.MailItem))
          End If
      Thread.Sleep(10)
      Next
   End If
   RaiseEvent StopDataLoad(Me, Nothing)
 End Sub

En écoutant les événements StartDataLoad et StopDataLoad, nous pouvons afficher un message à l'utilisateur s'il essaie de charger un rapport.

Visual C#

 if (_isDataLoading)
 {
 MessageBox.Show("Outlook is currently initializing your folders to 
   enable reporting for the first time.  Try again in a few minutes.", 
   "Loading initial data", MessageBoxButtons.OK, MessageBoxIcon.Warning);
 }

Visual Basic

 If (_isDataLoading) Then
 MessageBox.Show("Outlook is currently initializing your folders to enable reporting for the first time.  
 Try again in a few minutes.", "Loading initial data", MessageBoxButtons.OK, MessageBoxIcon.Warning)

Écoute des nouveaux éléments

Après le chargement de données initial, le complément peut simplement écouter les éléments entrants pour suivre l'utilisation d'Outlook. Pour écouter les éléments entrants, vous pouvez utiliser les événements de dossier. Pour utiliser des événements de dossier, vous devez d'abord obtenir une référence à un objet Outlook.MAPIFolder qui encapsule un dossier Outlook comme Boîte de réception, Éléments envoyés ou Calendrier. Pour obtenir le dossier Boîte d'envoi par défaut, appelez la méthode GetDefaultFolder de l'objet d'espace de noms MAPI. Vous devez ensuite ajouter des gestionnaires pour l'événement ItemAdd des dossiers d'Outlook. Le code suivant montre comment écouter les éléments de courrier entrant dans le dossier Boîte de réception.

Visual C#

 // Obtain references to the folder objects that fire the events we are interested in.
 Outlook.MAPIFolder inbox = 
   app.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);
 // Store references to the item collection objects.
 _inboxItems = inbox.Items;
 _inboxItems.ItemAdd += new Outlook.ItemsEvents_ItemAddEventHandler(InboxFolderItemAdded)
 /// <summary>
 /// Handles new mail items added to the inbox
 /// </summary>
 /// <param name="Item">Reference to the Outlook object added</param>
 private void InboxFolderItemAdded(object Item)
 {
   if (Item is Outlook.MailItem)
   {
      AddInboxItem(Item as Outlook.MailItem);
   }
 }
 

Visual Basic

 Dim inbox As Outlook.MAPIFolder = _
   app.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox)
 _inboxItems = inbox.Items
 AddHandler _inboxItems.ItemAdd, AddressOf InboxFolderItemAdded
 Private Sub InboxFolderItemAdded(ByVal Item As Object)
   If TypeOf Item Is Outlook.MailItem Then
      AddInboxItem(CType(Item, Outlook.MailItem))
   End If
 End Sub

Vous pouvez suivre les éléments de rendez-vous et de courrier envoyé de la même manière. Par ailleurs, les dossiers d'Outlook prennent en charge les événements de suppression ou de modification des éléments.
Vous pouvez facilement stocker les éléments dans la base de données en utilisant les adaptateurs de table générés automatiquement depuis le DataSet. Chaque élément a un adaptateur de table qui correspond à une table de la base de données.

Visual C#

 /// <summary>
 /// Stores a new message in the database
 /// </summary>
 /// <param name="mailItem"></param>
 private void AddInboxItem(Outlook.MailItem mailItem)
 {
 ReportDBDataSetTableAdapters.InboxTableAdapter ta = 
   new ReportDBDataSetTableAdapters.InboxTableAdapter();
 
   //determine if mail was sent to an alias or group address
   bool isAliased = true;
   if (mailItem.To == mailItem.ReceivedOnBehalfOfName || 
    mailItem.CC == mailItem.ReceivedOnBehalfOfName)
   {
      isAliased = false;
   }
   try
   {
      ta.Insert(mailItem.SenderName, 
      mailItem.SenderName, mailItem.SentOn, isAliased, null, 
      mailItem.Subject, mailItem.EntryID);
   }
   catch (Exception ex)
   {
      System.Diagnostics.Debug.Write(ex);
    }
}

Visual Basic

 Private Sub AddInboxItem(ByVal mailItem As Outlook.MailItem)
   Dim ta As ReportDBDataSetTableAdapters.InboxTableAdapter = 
    New ReportDBDataSetTableAdapters.InboxTableAdapter
   Dim isAliased As Boolean = True
   If mailItem.To = mailItem.ReceivedOnBehalfOfName OrElse mailItem.CC = 
    mailItem.ReceivedOnBehalfOfName Then
                isAliased = False
   End If
   Try
      ta.Insert(mailItem.SenderName, mailItem.SenderName, mailItem.SentOn, 
        isAliased, Nothing, mailItem.Subject, mailItem.EntryID)
   Catch ex As Exception
      System.Diagnostics.Debug.Write(ex)
   End Try
End Sub      

Génération des rapports

Maintenant que nous avons quelques points de données sur notre utilisation d'Outlook, nous pouvons générer des rapports. Les rapports sont affichés dans une grille de données sur un formulaire qui est lancé depuis le menu Rapports. La boîte de dialogue d'affichage des rapports contient un sélectionneur pour divers types de rapports et une plage de date à sélectionner.

Chaque rapport est renseigné à l'aide d'une méthode de nos adaptateurs de table. Par exemple, pour obtenir le nombre de messages électroniques envoyés sur une période donnée, vous pouvez utiliser le code suivant :

Visual C#

this.inboxTableAdapter.CountEmailsRecieved(this.reportDBDataSet.Inbox, fromDate, toDate);
 this.dataGridView1.Columns.Add("Emails Recieved", "Emails Received");
 this.dataGridView1.Columns["Emails Recieved"].DataPropertyName = "Emails Recieved";
 this.reportDBDataSetBindingSource.DataSource = this.reportDBDataSet.Inbox;

Visual Basic

Me.InboxTableAdapter.CountEmailsRecieved(Me.ReportDBDataSet.Inbox, fromDate, toDate)
Me.dataGridView1.Columns.Add("Emails Recieved", "Emails Received")
Me.dataGridView1.Columns("Emails Recieved").DataPropertyName = "Emails Recieved"
Me.reportDBDataSetBindingSource.DataSource = Me.ReportDBDataSet.Inbox

Création d'une zone de formulaire

Pour afficher les données d'utilisation d'Outlook, vous pouvez également utiliser une zone de formulaire. Vous pouvez ajouter les zones de formulaire à tout formulaire Outlook existant. Vous pouvez également choisir d'afficher la zone dans le volet de visualisation, l'inspecteur ou les nouveaux éléments. Pour ce complément, nous allons ajouter une zone de formulaire sur les messages électroniques pour afficher les statistiques relatives au destinataire/expéditeur.

La première étape dans la création d'une nouvelle zone de formulaire consiste à personnaliser un formulaire Outlook existant. Dans Outlook, cliquez sur Outils -> Formulaires -> Créer un formulaire. Sélectionnez ensuite Message dans la bibliothèque de formulaires standard. Le formulaire Outlook apparaît alors dans l'affichage de conception. Sur le ruban, sélectionnez le bouton permettant de créer une nouvelle zone de formulaire.

Sur le formulaire, ajoutez un nouveau contrôle Textbox. Vous ne pouvez toutefois pas utiliser la zone de texte Outlook régulière. Cliquez avec le bouton droit de la souris sur la fenêtre Boîte à outils et sélectionnez Commandes personnalisées. Défilez dans la liste de contrôles et sélectionnez Commande Textbox Microsoft Office Outlook, puis cliquez sur OK.

Ajoutez la zone de texte au formulaire pour afficher les statistiques Outlook.

Vous pouvez désormais enregistrer la zone de formulaire au format .ofs et l'ajouter au projet en tant que fichier de ressource. Pour connecter la zone de formulaire à notre complément, nous devons créer un fichier de manifeste de zone et une entrée de registre. Le manifeste de zone est un fichier XML qui définit comment Outlook affiche la zone.

 <?xml version="1.0" encoding="utf-8" ?>
 <FormRegion xmlns="http://schemas.microsoft.com/office/12/outlook/formregion.xsd">
  <name>OutlookStatsRegionCS</name>
  <formRegionType>adjoining</formRegionType>
  <title>Outlook Statistics</title>
  <showInspectorRead>true</showInspectorRead>
  <showReadingPane>true</showReadingPane>
  <showInspectorCompose>false</showInspectorCompose>
  <addin>OutlookStatsCS.Connect</addin>
</FormRegion> 

La documentation relative au schéma XML pour les zones de formulaire est disponible ici. Puisque le formulaire de composition d'un nouvel élément de courrier électronique ne doit pas inclure de statistique d'utilisation en bas, définissez la propriété showInspectorCompose sur false.

Pour associer le manifeste de zone à Outlook, vous devez créer une nouvelle clé de registre sous HKEY_CURRENT_USER\Software\Microsoft\Office\Outlook\FormRegions\IPM.Note called OutlookStatsRegionCS. La valeur de la clé doit correspondre au chemin d'accès au fichier XML de manifeste de zone. Un exemple de fichier de registre est inclus dans le dossier \Registry du projet dans le fichier region_registry.reg.

Connexion de la zone au complément Outlook

Comme les zones de formulaire sont basées sur les types Microsoft Forms 2.0, vous devez ajouter une référence dans le projet de complément à la bibliothèque d'objets Microsoft Forms 2.0. Vous pouvez maintenant ajouter une nouvelle classe pour gérer cette zone de formulaire, appelée Outlookstatsregion.cs.

Le constructeur pour cette classe a besoin d'une référence à l'instance de la zone de formulaire.

Visual C#

 public OutlookStatsRegion(Outlook.FormRegion region)
 {
   _region = region;
   _region.Close += new Outlook.FormRegionEvents_CloseEventHandler(Region_Close);
 
   _form = region.Form as Forms.UserForm;
 
   _txtStats = (Outlook.OlkTextBox)_form.Controls.Item("txtStats");
   _txtStats.Text = GetEmailStatistics(region.Item);
 }     

Visual Basic

 Public Sub New(ByVal [region] As Outlook.FormRegion)
   _region = [region]
   AddHandler _region.Close, AddressOf Region_Close
 
   _form = CType([region].Form, Forms.UserForm)
 
   _txtStats = CType(_form.Controls.Item("txtStats"), Outlook.OlkTextBox)
   _txtStats.Text = GetEmailStatistics([region].Item)
 End Sub ‘New

À l'aide de la référence à la zone, nous pouvons obtenir l'accès à l'élément de courrier. Le nom de l'expéditeur et l'adresse électronique doivent donc afficher les statistiques.

Visual C#

 private string GetEmailStatistics(object Item)
 {
   string result = string.Empty;
   if (Item is Outlook.MailItem)
   {
      Outlook.MailItem mailItem = Item as Outlook.MailItem;
 
 ReportDBDataSetTableAdapters.InboxTableAdapter inboxTA = 
  new ReportDBDataSetTableAdapters.InboxTableAdapter();
 
      int? countEmailsReceived = inboxTA.CountEmailsReceivedFrom(mailItem.SenderName);
 
      sb.Append("Emails received from ");
      sb.Append(mailItem.SenderName);
      sb.Append(": ");
      sb.Append(countEmailsReceived.Value.ToString());
      sb.Append("  [");
      sb.Append(percentTotalReceived);
      sb.AppendLine("% of total received]");
 
      result = sb.ToString();
   }
   return result;
 }

Visual Basic

 Private Function GetEmailStatistics(ByVal Item As Object) As String
   Dim result As String = String.Empty
 
   If TypeOf Item Is Outlook.MailItem Then
      Dim mailItem As Outlook.MailItem = CType(Item, Outlook.MailItem)
      Dim inboxTA As New ReportDBDataSetTableAdapters.InboxTableAdapter()
      Dim inbox As New ReportDBDataSet.InboxDataTable()
      Dim countEmailsReceived As Nullable(Of Integer) = _
         inboxTA.CountEmailsReceivedFrom(mailItem.SenderName)
 
      sb.Append("Emails received from ")
      sb.Append(mailItem.SenderName)
      sb.Append(": ")
      sb.Append(countEmailsReceived.Value.ToString())
      sb.Append("  [")
      sb.Append(percentTotalReceived)
 
      result = sb.ToString()
   End If
    Return result
 End Function 'GetEmailStatics

Nous y sommes presque. Nous devons ensuite modifier la classe Connect pour implémenter l'interface de zone de formulaire.

Visual C#

public partial class Connect : Outlook.FormRegionStartup 

Visual Basic

Partial Public Class Connect
 Implements Outlook.FormRegionStartup

Les deux méthodes définies dans cette interface sont appelées quand Outlook charge un élément et se prépare à afficher un formulaire. Lorsque Outlook commence à charger l'interface utilisateur pour une classe de message qui a une zone de formulaire inscrite, il appelle d'abord la méthode GetFormRegionStorage pour charger les informations de disposition de la zone de formulaire. GetFormRegionStorage doit renvoyer une chaîne (correspondant aux chemins d'accès du fichier .ofs), une instance IStorage pour le contenu du fichier .ofs ou un tableau d'octets qui renferme le contenu du fichier .ofs. Avant qu'Outlook n'affiche la zone de formulaire à l'utilisateur, il appelle la méthode BeforeFormRegionShow et transmet une référence à l'objet de zone de formulaire.

Visual C#

 public object GetFormRegionStorage(string FormRegionName, object Item,
   int LCID, Outlook.OlFormRegionMode FormRegionMode,
   Outlook.OlFormRegionSize FormRegionSize)
 {
   if (FormRegionName == "OutlookStatsRegionCS")
   {
      // Return the storage only when there are headers
      return Properties.Resources.OutlookStatsRegionCS;
   }
   return null;
 }
 
 public void BeforeFormRegionShow(Outlook.FormRegion FormRegion)
 {
   if (FormRegion.InternalName == "OutlookStatsRegionCS")
   {
      OutlookStatsRegion newRegion = new OutlookStatsRegion(FormRegion);
      newRegion.Closed += new EventHandler(Region_Closed);
      _openRegions.Add(newRegion);
    }
 }

Visual Basic

 Public Sub BeforeFormRegionShow(ByVal FormRegion As Microsoft.Office.Interop.Outlook.FormRegion) 
  Implements Microsoft.Office.Interop.Outlook._FormRegionStartup.BeforeFormRegionShow
   If FormRegion.InternalName = "OutlookStatsRegionVB" Then
      Dim newRegion As New OutlookStatsRegion(FormRegion)
      AddHandler newRegion.Closed, AddressOf Region_Closed
      _openRegions.Add(newRegion)
   End If
 End Sub
 
 Public Function GetFormRegionStorage(ByVal FormRegionName As String, _
   ByVal Item As Object, ByVal LCID As Integer, _
   ByVal FormRegionMode As Microsoft.Office.Interop.Outlook.OlFormRegionMode, _
   ByVal FormRegionSize As Microsoft.Office.Interop.Outlook.OlFormRegionSize) As 
    Object Implements Microsoft.Office.Interop.Outlook._FormRegionStartup.GetFormRegionStorage
 
   If FormRegionName = "OutlookStatsRegionVB" Then
      Return My.Resources.OutlookStatsRegionVB
   End If
 
   Return Nothing
 End Function

La dernière étape consiste à enregistrer le complément avec Outlook. Le modèle de complément fourni avec cet article produit automatiquement un fichier .reg avec les paramètres nécessaires pour enregistrer le complément COM créé par le projet avec Outlook. Double-cliquez sur le fichier .reg dans l'Explorateur Windows pour enregistrer le complément. Vous pouvez maintenant modifier les propriétés de débogage du projet pour démarrer Outlook lors du débogage en définissant l'option Action de démarrage sur Démarrer le programme externe, puis allez dans le répertoire d'Outlook 2007.

Conclusion

Comme vous pouvez le voir, VSTO 2005 SE offre aux développeurs un outil puissant de personnalisation d'Office 2007. Les nouvelles fonctionnalités qu'il renferme, comme le ruban et les zones de formulaire personnalisées, permettent une meilleure intégration que les versions précédentes de VSTO. Les événements Outlook nous ont permis de calculer les statistiques d'utilisation des messages électroniques et du calendrier. D'autres composants peuvent être ajoutés aux rapports de ce complément. Par exemple :

Ajouter une zone personnalisée sur les contacts pour afficher le nombre d'heures qu'une personne passe en réunion

Suivre le temps passé à lire et écrire des messages électroniques

Suivre le temps passé sur les tâches ou le pourcentage de tâches accomplies à l'heure.

Haut de page