Nouveautés pour les développeurs dans Outlook 2010
Synthèse : cet article fournit une présentation de haut niveau des améliorations et ajouts à l’intention des développeurs dans Microsoft Outlook 2010. Il examine également en profondeur certains nouveaux objets améliorés du modèle objet Outlook, notamment leurs propriétés, méthodes et événements. Pour les développeurs souhaitant vivement découvrir la plateforme Outlook, cet article fournit suffisamment de détails pour commencer le codage pour Outlook 2010.
Dernière modification : mercredi 30 janvier 2013
S’applique à : Office 2010 | Outlook 2010
Dans cet article
Vue d’ensemble de la plate-forme Outlook 2010
Modifications du modèle objet Outlook
Résilience des compléments
Extensibilité de l’interface utilisateur améliorée
Modèle objet complet
Prise en charge des plateformes 32 bits et 64 bits
Comptes Exchange multiples
Conclusion
Ressources supplémentaires
S'applique à : Microsoft Outlook 2010
Publié en : novembre 2009 | Mis à jour en : avril 2010
Fourni par : Randy Byrne, Microsoft Corporation
Sommaire
Vue d’ensemble de la plate-forme Outlook 2010
Modifications du modèle objet Outlook
Résilience des compléments
Extensibilité de l’interface utilisateur améliorée
Modèle objet complet
Prise en charge des plateformes 32 bits et 64 bits
Comptes Exchange multiples
Conclusion
Ressources supplémentaires
Vue d’ensemble de la plate-forme Outlook 2010
Les modifications apportées au modèle objet Outlook 2010 répondent au souhait des clients de pouvoir étendre l’interface utilisateur et fournir une prise en charge dans le modèle objet des nouvelles fonctions qui ont été conçues pour l’utilisateur final d’Outlook 2010. La plateforme Outlook 2010 inclut les fonctionnalités suivantes :
Résilience des compléments
Les compléments ne doivent pas altérer les performances ni la résilience d’Outlook. Outlook consigne la liste des compléments connectés dans le journal des événements de Windows et enregistre l’heure de démarrage de chaque complément connecté. En outre, Outlook consigne dans le journal des événements de Windows les incidents de complément qui se produisent lors d’un appel d’événement. Pour empêcher le complément de compromettre les performances d’Outlook lorsqu’une action d’utilisateur ferme l’application Outlook, Outlook utilise un nouveau processus d’arrêt rapide. Pour plus d’informations sur le nouveau processus d’arrêt, consultez Modifications de l’arrêt d’Outlook 2010.
Extensibilité de l’interface utilisateur améliorée
Vous pouvez personnaliser de nombreuses nouvelles composantes de l’interface utilisateur d’Outlook, notamment un module de navigation personnalisée nommé module Solutions dans le volet de navigation. Vous pouvez définir ou obtenir des icônes de dossiers personnalisées pour les dossiers Outlook sous le module Solutions. Le module Solutions simplifie la recherche du contenu d’un dossier de solutions personnalisée. Avec l’extensibilité de l’interface utilisateur Microsoft Office Fluent, vous pouvez personnaliser des parties de l’interface utilisateur qui n’étaient pas extensibles dans les versions précédentes d’Outlook. Pour plus d’informations sur le module Solutions, consultez Programmation du module Solutions d’Outlook 2010. Pour plus d’informations sur l’utilisation de l’extensibilité du Ruban pour personnaliser l’interface utilisateur d’Outlook, consultez Extension de l’interface utilisateur dans Outlook 2010.
Prise en charge des plateformes 32 bits et 64 bits
Vous pouvez développer des solutions pour les plateformes 32 bits et 64 bits en utilisant une API, le modèle objet Outlook.
Modèle objet complet
Pour une grande majorité de développeurs, le modèle objet est complet et suffisant pour créer une solution professionnelle sans devoir écrire du code au niveau MAPI (Messaging API).
Comptes Exchange multiples
Vous pouvez définir de multiples comptes Microsoft Exchange sous un profil unique. Le modèle objet a été initialement conçu en partant du principe qu’un seul compte Exchange s’exécuterait dans un profil unique. Le modèle objet mis à jour est amélioré pour gérer de multiples comptes Exchange.
Cet article présente d’importantes nouvelles fonctionnalités dans le modèle objet et inclut des exemples de code en C# qui vous aideront à écrire de nouvelles solutions ou à adapter du code existant pour Outlook 2010.
Notes
Les objets, propriétés, méthodes et événements présentés dans cet article pourraient changer dans la version finale d’Outlook 2010, et des fonctions supplémentaires pourraient également être introduites. Veillez à tester vos modifications de code dans la version finale d’Outlook 2010 avant de distribuer votre solution.
Modifications du modèle objet Outlook
Le modèle objet Outlook comporte des objets, des méthodes, des propriétés et des événements qui prennent en charge les nouvelles fonctionnalités d’Outlook 2010 par programme. D’autres améliorations au modèle objet répondent à de fréquentes demandes de développeurs visant des modifications spécifiques à la plateforme Outlook.
Améliorations d’objets et de collections Outlook existants pour Outlook 2010
Le tableau suivant répertorie les améliorations apportées à des objets et des collections déjà présents dans les versions antérieures d’Outlook. La deuxième colonne répertorie uniquement les nouvelles méthodes, nouvelles propriétés et nouveaux événements.
Tableau 1. Améliorations du modèle objet Outlook
Objets et collections |
Nouveaux membres |
Méthodes Propriétés |
|
Événements |
|
Méthodes RefreshFormRegionDefinition(String) Propriétés |
|
Méthodes CopyTo(MAPIFolder, OlAppointmentCopyOptions) Propriétés Événements |
|
Méthodes |
|
Méthodes GetSelection(OlSelectionContents) Propriétés |
|
Propriétés |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes Propriétés |
|
Événements AfterWrite BeforeRead |
|
Méthodes |
|
Méthodes IsItemSelectableInView(Object) Propriétés Événements |
|
Méthodes |
|
Propriétés |
|
Méthodes SetSchedulingStartTime(DateTime) Propriétés Événements |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Propriétés |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes GetSelection(OlSelectionContents) Propriétés |
|
Méthodes Propriétés Événements AfterWrite BeforeRead |
|
Méthodes GetDefaultFolder(OlDefaultFolders) Propriétés |
|
Méthodes Propriétés |
|
Méthodes GetConversation Propriétés ConversationID RTFBody |
|
Propriétés |
Nouveaux objets et une nouvelles collections pour Outlook 2010
Le tableau suivant répertorie les nouveaux objets introduits dans Outlook 2010. Tous les membres objets sont répertoriés dans la seconde colonne.
Tableau 2. Ajouts au modèle objet Outlook
Objets |
Méthodes, propriétés et événements |
Propriétés Événements |
|
Méthodes ClearAlwaysAssignCategories(Store) GetAlwaysAssignCategories(Store) SetAlwaysAssignCategories(String, Store) SetAlwaysDelete(OlAlwaysDeleteConversation, Store) SetAlwaysMoveToFolder(MAPIFolder, Store) Propriétés |
|
Méthodes Propriétés |
|
Méthodes Propriétés Événements AfterWrite BeforeAttachmentWriteToTempFile BeforeRead |
|
Propriétés |
|
Méthodes AddSolution(MAPIFolder, OlSolutionScope) Propriétés |
Résilience des compléments
La résilience des compléments est une importante fonction de la plateforme Outlook 2010. Avec la résilience des compléments, avant et après le chargement d’un complément, Outlook continue à fonctionner et à répondre normalement. Les compléments s’exécutent en mode in-process dans Outlook et peuvent potentiellement altérer l’expérience de l’utilisateur d’Outlook. En outre, les administrateurs informatiques savent que dans des environnements non gérés ils ne connaissent pas toujours les compléments qu’emploient les utilisateurs, et des compléments mal écrits favorisent l’augmentation du nombre de demandes d’assistance et du coût de possession. Comme tous les appels du modèle objet Outlook s’exécutent sur la thread principale au premier plan dans Outlook, il est important que vous écriviez votre code en ayant pour principal objectif de maintenir les performances. Si votre code ralentit ou bloque Outlook, les utilisateurs éprouveront de la frustration et abandonneront rapidement votre solution.
Inventaire et durée de démarrage des compléments dans le journal des événements de Windows
Outlook 2010 offre aux utilisateurs et aux administrateurs informatiques la possibilité d’identifier les compléments qui se chargent au démarrage d’Outlook, et de déterminer leur impact sur la durée de démarrage. Lorsque Outlook démarre, des informations détaillées sur l’identité de chacun des compléments connectés sont consignées dans le journal des événements de Windows. En outre, la durée de démarrage de chaque complément connecté est enregistrée en millisecondes dans le journal des événements.
Figure 1. Compléments d’Outlook 2010 et durée de démarrage par complément dans le journal des événements de Windows
.gif "Compléments dans le journal des événements Windows")
Arrêt rapide des compléments
Outlook 2010 applique un nouveau processus d’arrêt rapide pour les compléments. Ce nouveau processus d’arrêt empêche le complément de provoquer de longs retards en monopolisant les ressources après qu’un utilisateur a demandé la fermeture d’Outlook. Bien que cette modification puisse affecter négativement un petit nombre de compléments existants, les fournisseurs de compléments et administrateurs informatiques peuvent atténuer ces effets en imposant le rétablissement du processus d’arrêt standard des compléments.
La liste suivante décrit des aspects importants du processus d’arrêt rapide des compléments :
Lorsqu’une action d’utilisateur arrête Outlook, l’événement OnDisconnection de l’interface IDTExtensibility2 ne se produit pas lorsque le paramètre RemoveMode a la valeur ext_DisconnectMode.ext_dm_HostShutdown.
Pour les compléments Microsoft Visual Studio Tools pour Office, la méthode Shutdown de la classe ThisAddin ne sera pas appelée lorsqu’une action d’utilisateur arrête Outlook.
Lorsqu’une action d’utilisateur dans la boîte de dialogue Compléments COM déconnecte le complément, l’événement OnDisconnection de l’interface IDTExtensiblity2 se produit lorsque RemoveMode égale ext_DisconnectMode.ext_dm_UserClosed.
Lorsqu’une action d’utilisateur arrête Outlook, l’événement Quit de l’objet Application d’Outlook se produit.
Pour plus d’informations sur l’arrêt des compléments et les méthodes recommandées, consultez Modifications de l’arrêt d’Outlook 2010.
Extensibilité de l’interface utilisateur améliorée
Outlook 2010 fournit les moyens suivants d’étendre l’interface utilisateur que les développeurs ont souvent demandés :
Ajout d’une hiérarchie de dossiers personnalisés dans le nouveau module Solutions du volet de navigation. Dans le modèle objet Outlook, le module Solutions est représenté par l’objet SolutionsModule. L’objet SolutionsModule expose la méthode AddSolution que vous pouvez utiliser pour ajouter un dossier racine de solution. Outlook 2010 ajoute automatiquement tous les sous-dossiers du dossier racine de solution à la hiérarchie des dossiers de la solution qui s’affiche dans le module Solutions. Voir la figure 2 pour un exemple du module Solutions.
Personnalisation des icônes de dossiers pour les dossiers de solutions. Vous pouvez utiliser les méthodes SetCustomIcon et GetCustomIcon de l’objet Folder pour définir et obtenir des icônes de dossiers.
Utilisation de l’extensibilité de l’interface utilisateur Office Fluent pour personnaliser l’interface utilisateur d’Outlook, notamment :
Rubans de l’explorateur
Rubans de l’inspecteur
Menus contextuels
Menus Nouvel élément
Menus contextuels Carte de visite
Onglets contextuels
Mode Microsoft Office Backstage
Figure 2. Exemple de module Solutions dans Outlook 2010
.jpg "Exemple de module Solutions dans Outlook 2010")
Si votre code existant personnalise les barres de commandes d’Office, ces personnalisations d’interface utilisateur apparaissent dans l’onglet Compléments, que les utilisateurs risquent de ne pas trouver facilement. Suivez les directives d’extensibilité de l’interface utilisateur Office Fluent pour réécrire votre code afin de tirer parti des rubans de l’explorateur, des menus contextuels de l’interface utilisateur Office Fluent et du mode Backstage. Pour obtenir des informations complètes sur l’extensibilité de l’interface utilisateur dans Outlook 2010, ainsi qu’un exemple de code, consultez les articles suivants :
Modèle objet complet
L’objectif d’un modèle objet complet est de garantir que les développeurs peuvent écrire des solutions professionnelles sans directement utiliser du code MAPI. Dans du code géré, vous ne pouvez pas développer des solutions Outlook qui utilisent MAPI.
Modèle objet pour conversations
Outlook 2010 introduit une puissante nouvelle fonction nommée affichage Conversation, et le nouvel objet Conversation. Vous pouvez utiliser l’objet Conversation pour exécuter des verbes de conversation et accéder à l’arborescence des conversations. Les éléments dans la conversation peuvent se trouver dans différents magasins et dossiers.
Pour accéder aux éléments dans un fil de conversation, appelez la méthode GetConversation sur un élément pour renvoyer un objet Conversation. L’objet Conversation représente une conversation à laquelle l’élément parent appartient.
GetConversation renvoie Null (Nothing en Visual Basic) si aucune conversation n’existe pour l’élément. Aucune conversation n’existe pour un élément dans les conditions suivantes :
L’élément n’a pas été enregistré. Un élément peut être enregistré par programme, par une action d’utilisateur ou par enregistrement automatique (AutoSave).
Si un élément peut être envoyé, mais n’a pas été envoyé (par exemple, un élément de courrier, un élément de rendez-vous ou un élément de contact ).
Toutes les conversations ont été désactivées au moyen du Registre de Windows.
Le magasin ne prend pas en charge les conversations (par exemple, lorsque Outlook s’exécute en mode en ligne classique avec une version de Microsoft Exchange antérieure à Microsoft Exchange Server 2010). Utilisez la propriété IsConversationEnabled de l’objet Store pour déterminer si le magasin prend en charge les conversations.
La fonction DemoConversation suivante obtient l’objet Conversation pour un élément sélectionné dans la fenêtre de l’explorateur Outlook. Pour répertorier les éléments dans une conversation, utilisez la méthode GetTable sur l’objet Conversation pour renvoyer un objet Table. Vous pouvez alors ajouter des colonnes, si nécessaire, à l’objet Table, ou appeler GetNextRow pour renvoyer chaque ligne dans Table.
void DemoConversation()
{
object selectedItem = Application.ActiveExplorer().Selection[1];
// For this example, you work only with
// MailItem. Other item types such as
// MeetingItem and PostItem can participate
// in a conversation.
if (selectedItem is Outlook.MailItem)
{
// Cast selectedItem to MailItem.
Outlook.MailItem mailItem =
selectedItem as Outlook.MailItem; ;
// Determine store of MailItem.
Outlook.Folder folder = mailItem.Parent
as Outlook.Folder;
Outlook.Store store = folder.Store;
if (store.IsConversationEnabled == true)
{
// Obtain a Conversation object.
Outlook.Conversation conv =
mailItem.GetConversation();
// Check for null conversation.
if (conv != null)
{
// Obtain Table that contains rows
// for each item in the conversation.
Outlook.Table table = conv.GetTable();
Debug.WriteLine("Conversation Items Count: " +
table.GetRowCount().ToString());
Debug.WriteLine("Conversation Items from Table:");
while (!table.EndOfTable)
{
Outlook.Row nextRow = table.GetNextRow();
Debug.WriteLine(nextRow["Subject"]
+ " Modified: "
+ nextRow["LastModificationTime"]);
}
Debug.WriteLine("Conversation Items from Root:");
// Obtain root items and enumerate Conversation.
Outlook.SimpleItems simpleItems
= conv.GetRootItems();
foreach (object item in simpleItems)
{
// In this example, enumerate only the MailItem type.
// Other types such as PostItem or MeetingItem
// can appear in a conversation.
if (item is Outlook.MailItem)
{
Outlook.MailItem mail = item
as Outlook.MailItem;
Outlook.Folder inFolder =
mail.Parent as Outlook.Folder;
string msg = mail.Subject
+ " in folder " + inFolder.Name;
Debug.WriteLine(msg);
}
// Call EnumerateConversation
// to access child nodes of root items.
EnumerateConversation(item, conv);
}
}
}
}
}
void EnumerateConversation(object item,
Outlook.Conversation conversation)
{
Outlook.SimpleItems items =
conversation.GetChildren(item);
if (items.Count > 0)
{
foreach (object myItem in items)
{
// In this example, enumerate only MailItem type.
// Other types such as PostItem or MeetingItem
// can appear in a conversation.
if (myItem is Outlook.MailItem)
{
Outlook.MailItem mailItem =
myItem as Outlook.MailItem;
Outlook.Folder inFolder =
mailItem.Parent as Outlook.Folder;
string msg = mailItem.Subject
+ " in folder " + inFolder.Name;
Debug.WriteLine(msg);
}
// Continue recursion.
EnumerateConversation(myItem, conversation);
}
}
}
Si vous souhaitez naviguer dans chaque nœud de la conversation, une autre approche consiste à appeler la méthode GetRootItems pour envoyer un ou plusieurs éléments racines de la conversation. Une conversation peut avoir de multiples éléments racines si l’élément racine unique d’origine a été supprimé, et si des éléments ont été promus au rang d’éléments racines. Une fois que vous avez les éléments racines, vous pouvez obtenir la collection SimpleItems pour tous les nœuds enfants de chaque élément racine. SimpleItems est un objet de collection que vous pouvez utiliser pour énumérer les éléments enfants de chaque nœud dans la conversation. Lorsque vous utilisez une boucle foreach pour énumérer chaque élément dans la collection, appelez la fonction EnumerateConversation de manière récursive pour accéder à chaque élément enfant dans la conversation. La fonction EnumerateConversation accepte deux paramètres, l’un représente un élément tel que MailItem, un autre représente un objet Conversation. La méthode GetChildren de l’objet Conversation renvoie une collection SimpleItems qui représente les nœuds enfants d’un élément donné dans la conversation. Si SimpleItems.Count est supérieur à zéro, l’énumération des nœuds enfants continue et EnumerateConversation est appelé sur chaque nœud enfant.
L’objet Conversation expose également des méthodes qui permettent aux verbes de conversation d’être appliqués à une conversation. Plus spécifiquement, vous pouvez utiliser les méthodes suivantes sur l’objet Conversation dans Outlook 2010.
Tableau 3. Méthodes de l’objet Conversation
Méthode |
Description |
ClearAlwaysAssignCategories |
Supprime toutes les catégories de tous les éléments dans la conversation et oblige Outlook de cesser de toujours affecter des catégories à des éléments. |
GetAlwaysAssignCategories |
Renvoie une String qui indique la ou les catégories qui sont affectées à tous les nouveaux éléments qui arrivent dans la conversation. |
GetAlwaysDelete |
Renvoie une constante dans l’énumération OlAlwaysDeleteConversation qui indique si les nouveaux éléments qui arrivent dans la conversation sont toujours transférés dans le dossier Éléments supprimés dans le magasin de livraison. |
GetAlwaysMoveToFolder |
Obtient un objet Folder dans le magasin de livraison spécifié où tous les nouveaux éléments qui arrivent dans la conversation sont toujours transférés. |
MarkAsRead |
Marque tous les éléments dans la conversation comme étant lus. |
MarkAsUnread |
Marque tous les éléments dans la conversation comme étant non lus. |
SetAlwaysAssignCategories |
Applique une ou plusieurs catégories à tous les éléments existants et futurs de la conversation. |
SetAlwaysDelete |
Définit une constante dans l’énumération OlAlwaysDeleteConversation qui indique si tous les éléments existants et tous les nouveaux éléments qui arrivent dans la conversation sont toujours transférés dans le dossier Éléments supprimés du magasin de livraison spécifié. |
SetAlwaysMoveToFolder |
Définit un objet Folder dans le magasin de livraison spécifié dans lequel tous les éléments existants et tous les nouveaux éléments qui arrivent dans la conversation sont toujours transférés. |
StopAlwaysDelete |
Arrête l’action de toujours transférer les éléments de conversation sur le magasin spécifié dans le dossier Éléments supprimés de ce magasin. |
StopAlwaysMoveToFolder |
Arrête l’action de toujours transférer les éléments de conversation du magasin spécifié dans un dossier spécifique. |
Par exemple, l’action ignore entraîne le transfert de tous les éléments actuels et futurs de la conversation dans le dossier Éléments supprimés. Pour écrire un code qui reproduit l’action ignore, utilisez la méthode SetAlwaysDelete pour toujours supprimer tous les éléments dans la conversation et transférer d’éventuels nouveaux éléments de conversation dans le dossier Éléments supprimés. Pour inverser l’action ignore par programme, appelez la méthode StopAlwaysDelete. L’exemple de code suivant illustre l’utilisation de la méthode SetAlwaysDelete.
void DemoIgnoreConversation()
{
// Obtain the selection.
object selectedItem =
Application.ActiveExplorer().Selection[1];
if (selectedItem is Outlook.MailItem)
{
// Cast the object to MailItem.
Outlook.MailItem mail = selectedItem
as Outlook.MailItem;
// Determine the store of mail.
Outlook.Folder folder = mail.Parent
as Outlook.Folder;
Outlook.Store store = folder.Store;
if (store.IsConversationEnabled == true)
{
Outlook.Folder delItems =
store.GetDefaultFolder(
Outlook.OlDefaultFolders.olFolderDeletedItems)
as Outlook.Folder;
Outlook.Conversation conv = mail.GetConversation();
if (conv != null)
{
conv.SetAlwaysDelete(
Outlook.OlAlwaysDeleteConversation.olAlwaysDelete,
delItems.Store);
}
}
}
}
Obtention de l’adresse SMTP de l’expéditeur
Dans Microsoft Office Outlook 2007, les développeurs utilisaient l’objet PropertyAccessor dans un code similaire à celui présenté cdessous pour obtenir l’adresse SMTP de l’expéditeur.
private string GetSenderSMTPAddress(Outlook.MailItem mail)
{
if (mail == null)
{
throw new ArgumentNullException();
}
string PR_SENT_REPRESENTING_ENTRYID =
@"https://schemas.microsoft.com/mapi/proptag/0x00410102";
string PR_SMTP_ADDRESS =
@"https://schemas.microsoft.com/mapi/proptag/0x39FE001E";
if (mail.SenderEmailType == "EX")
{
string senderEntryID =
mail.PropertyAccessor.BinaryToString(
mail.PropertyAccessor.GetProperty(
PR_SENT_REPRESENTING_ENTRYID));
Outlook.AddressEntry sender =
Application.Session.
GetAddressEntryFromID(senderEntryID);
if (sender != null)
{
// Now there is an AddressEntry that represents the sender.
if (sender.AddressEntryUserType ==
Outlook.OlAddressEntryUserType.
olExchangeUserAddressEntry
|| sender.AddressEntryUserType ==
Outlook.OlAddressEntryUserType.
olExchangeRemoteUserAddressEntry)
{
// Use the PrimarySMTPAddress property of the
// ExchangeUser object.
Outlook.ExchangeUser exchUser =
sender.GetExchangeUser();
if (exchUser != null)
{
return exchUser.PrimarySmtpAddress;
}
else
{
return null;
}
}
else
{
return sender.PropertyAccessor.GetProperty(
PR_SMTP_ADDRESS) as string;
}
}
else
{
return null;
}
}
else
{
return mail.SenderEmailAddress;
}
}
Dans Outlook 2010, la propriété Sender de l’objet MailItem renvoie ou définit un objet AddressEntry qui représente l’expéditeur de l’élément. Il n’est plus nécessaire d’utiliser l’objet PropertyAccessor pour déterminer la propriété PR_SENT_REPRESENTING_ENTRYID (PidTagSentRepresentingEntryId). Vous pouvez plutôt écrire un code similaire à l’exemple suivant.
private string GetSenderSMTPAddress2010(Outlook.MailItem mail)
{
string PR_SMTP_ADDRESS =
@"https://schemas.microsoft.com/mapi/proptag/0x39FE001E";
if (mail == null)
{
throw new ArgumentNullException();
}
if (mail.SenderEmailType == "EX")
{
Outlook.AddressEntry sender =
mail.Sender;
if (sender != null)
{
// Now there is an AddressEntry that represents the sender.
if (sender.AddressEntryUserType ==
Outlook.OlAddressEntryUserType.
olExchangeUserAddressEntry
|| sender.AddressEntryUserType ==
Outlook.OlAddressEntryUserType.
olExchangeRemoteUserAddressEntry)
{
// Use the PrimarySMTPAddress property of the
// ExchangeUser object.
Outlook.ExchangeUser exchUser =
sender.GetExchangeUser();
if (exchUser != null)
{
return exchUser.PrimarySmtpAddress;
}
else
{
return null;
}
}
else
{
return sender.PropertyAccessor.GetProperty(
PR_SMTP_ADDRESS) as string;
}
}
else
{
return null;
}
}
else
{
return mail.SenderEmailAddress;
}
}
Améliorations de l’objet PropertyAccessor
Utilisez l’objet PropertyAccessor pour créer, définir, obtenir et supprimer des propriétés sur des objets. Dans Outlook 2007, l’objet PropertyAccessor imposait des limitations quant à la taille de la propriété pouvant être récupérée avec un appel GetProperty ou GetProperties. Dans Outlook 2010, ces limitations ont été supprimées.
Vous pouvez également utiliser l’objet PropertyAccessor dans Outlook 2010 pour manipuler des pièces jointes sans écrire la pièce jointe sur le disque en utilisant la méthode SaveAsFile sur l’objet Attachment. L’exemple de code suivant utilise l’objet PropertyAccessor pour récupérer un tableau d’octets de l’objet Attachment, changer le tableau d’octets de A à B en mémoire, puis définir l’objet Attachment au tableau d’octets modifié. Pour rendre les modifications persistantes, appelez la méthode Save sur l’élément.
private void DemoAttachmentStream()
{
const string PR_ATTACH_DATA_BIN =
"https://schemas.microsoft.com/mapi/proptag/0x37010102";
// Create a mail item.
Outlook.MailItem mail =
Application.CreateItem(Outlook.OlItemType.olMailItem)
as Outlook.MailItem;
mail.Subject = "Demo Attachment Stream";
// Create the c:\demo folder if it does not exist.
if(!Directory.Exists(@"c:\demo"))
{
Directory.CreateDirectory(@"c:\demo");
}
// Write to the attach.txt file.
StreamWriter sw = new StreamWriter(@"c:\demo\attach.txt");
char charA = 'A';
string myString = new string(charA ,4096);
sw.WriteLine(myString);
sw.Close();
// Add attach.txt as an attachment.
Outlook.Attachment attach =
mail.Attachments.Add(@"c:\demo\attach.txt",
Outlook.OlAttachmentType.olByValue,
Type.Missing,
Type.Missing);
// Save the item.
mail.Save();
// Use PropertyAccessor to retrieve attachment byte stream.
byte[] attachStream =
attach.PropertyAccessor.GetProperty(
PR_ATTACH_DATA_BIN) as byte[];
// Iterate the stream and change "A" to "B".
for (int i = 0; i < attachStream.Length; i++)
{
attachStream[i] = 0x42; //Hex for "B"
}
// Set PR_ATTACH_DATA_BIN to attachStream.
attach.PropertyAccessor.SetProperty(PR_ATTACH_DATA_BIN,
attachStream);
// Save the item again.
mail.Save();
}
Accès aux formats RTF (Rich Text Format)
Outlook prend en charge la mise en forme enrichie du corps d’un élément au moyen de la propriété WordEditor de l’objet Inspector. WordEditor représente l’objet Word.Document dans le modèle objet Microsoft Word. Inspector.WordEditor fonctionne bien lorsqu’un élément Outlook est affiché dans un inspecteur. Pour les cas où la fenêtre d’inspecteur n’est pas affichée, Outlook 2010 introduit la propriété RTFBody sur un objet d’élément tel que MailItem, AppointmentItem, etc. RTFBody est exposé sur tous les types d’éléments à l’exception de NoteItem et de JournalItem. RTFBody est une propriété en lecture/écriture, et vous pouvez définir ou obtenir un tableau d’octets qui représentent le flux RTF pour l’élément. Selon votre environnement de développement, vous devez convertir le tableau d’octets renvoyé par RTFBody en une chaîne, modifier la chaîne qui contient le RTF, si nécessaire, convertir la chaîne un tableau d’octets, puis définir le RTFBody au tableau d’octets modifié.
L’exemple de code suivant écrit le RTF pour le premier élément dans l’objet Selection pour la fenêtre d’explorateur active dans la fenêtre des écouteurs de trace du débogage dans Visual Studio. Le code obtient le tableau d’octets de l’objet courrier, puis utilise System.Text.AsciiEncoding pour convertir le tableau d’octets en une chaîne.
private void GetRTFBodyForMail()
{
Outlook.Selection selection =
Application.ActiveExplorer().Selection;
if(selection.Count >= 1)
{
if (selection[1] is Outlook.MailItem)
{
Outlook.MailItem mail =
selection[1] as Outlook.MailItem;
byte[] byteArray = mail.RTFBody as byte[];
System.Text.Encoding encoding =
new System.Text.ASCIIEncoding();
string RTF = encoding.GetString(byteArray);
Debug.WriteLine(RTF);
}
}
}
Obtention d’éléments contenus dans un affichage
Avec Outlook 2010, vous pouvez obtenir des éléments contenus dans un affichage en appelant la méthode GetTable sur l’objet TableView. GetTable renvoie un objet Table, mais vous ne pouvez pas spécifier les paramètres à la méthode de la manière possible avec Folder.GetTable. Utilisez GetTable lorsque l’affichage contient une restriction créant une différence entre les éléments contenus dans l’affichage et ceux du dossier, ou lorsqu’une requête de Recherche instantanée renvoie des éléments provenant de plusieurs dossiers ou magasins. L’exemple de code suivant récupère un objet Table de l’affichage actuel dans la boîte de réception. Notez que la boîte de réception doit être le dossier en cours pour que l’appel TableView.GetTable aboutisse. Si vous appelez TableView.GetTable sur un dossier qui n’est pas le dossier en cours dans une fenêtre d’explorateur visible, Outlook déclenche une erreur.
private void DemoViewGetTable()
{
// Obtain the Inbox folder.
Outlook.Folder inbox =
Application.Session.GetDefaultFolder(
Outlook.OlDefaultFolders.olFolderInbox)
as Outlook.Folder;
// Set ActiveExplorer.CurrentFolder to Inbox.
// Inbox must be the current folder
// for View.GetTable to work correctly.
Application.ActiveExplorer().CurrentFolder = inbox;
// Ensure that the current view is TableView.
if (inbox.CurrentView.ViewType ==
Outlook.OlViewType.olTableView)
{
Outlook.TableView view =
inbox.CurrentView as Outlook.TableView;
// No arguments are needed for View.GetTable.
Outlook.Table table = view.GetTable();
Debug.WriteLine("View Count="
+ table.GetRowCount().ToString());
while (!table.EndOfTable)
{
// First row in Table.
Outlook.Row nextRow = table.GetNextRow();
Debug.WriteLine(nextRow["Subject"]
+ " Modified: "
+ nextRow["LastModificationTime"]);
}
}
}
Améliorations apportées à l’objet Selection
L’objet Selection a été amélioré avec une propriété Location qui indique au développeur la zone de l’interface utilisateur correspondant à la sélection. La propriété Location est en lecture seule et renvoie une valeur dans l’énumération OlSelectionLocation. Dans les versions précédentes d’Outlook, l’objet Selection contenait uniquement les éléments sélectionnés dans la liste de l’affichage. Dans Outlook 2010, Selection.Location peut renvoyer n’importe laquelle des valeurs OlSelectionLocation suivantes.
Tableau 4. Valeurs OlSelectionLocation renvoyées
Valeur |
Description |
olViewList |
Éléments sélectionnés dans la liste de l’affichage. |
olToDoBarTaskList |
Éléments sélectionnés dans la liste des tâches de la barre des tâches. |
olToDoBarAppointmentList |
Éléments sélectionnés dans la liste des rendez-vous de la barre des tâches. |
olDailyTaskList |
Éléments sélectionnés dans la liste des tâches quotidiennes d’un affichage Calendrier. |
olAttachmentWell |
Pièces jointes sélectionnées qui se trouvent dans la bande de pièces jointes dans un volet de lecture de l’explorateur Outlook, ou la bande de pièces jointes dans un inspecteur Outlook. |
Lorsque la sélection change, l’événement SelectionChange se produit pour tous les emplacements de sélection qui était précédemment indiqués avec l’exception de olAttachmentWell. Lorsqu’une pièce jointe est sélectionnée dans la bande de pièces jointes, l’événement AttachmentSelectionChange se produit. Les événements SelectionChange et AttachmentSelectionChange se produisent tous deux sur l’objet Explorer.
Si vous énumérez l’objet Selection lorsque l’événement SelectionChange se produit, assurez-vous que votre code peut gérer différents types d’éléments de manière appropriée. Ne partez pas du principe que le seul objet dans l’objet Selection soit un objet MailItem.
L’objet Selection amélioré dans Outlook 2010 fonctionne pour tout type d’affichage, notamment le nouvel affichage Conversation dans Outlook 2010. Les propriétés suivantes vous aident à déterminer si l’affichage actuel est un affichage de conversation.
Tableau 5. Propriétés TableView
Propriété TableView |
Description |
AlwaysExpandConversation |
Renvoie ou définit une valeur qui indique si les conversations sont toujours entièrement développées dans l’affichage Tableau. Lecture/écriture. |
ShowConversationByDate |
Renvoie ou définit une valeur Boolean qui indique si des éléments dans l’affichage Tableau sont organisés selon la date de conversation et la conversation. Lecture/écriture. |
ShowFullConversations |
Renvoie ou définit une valeur Boolean qui indique si des éléments de conversation d’autres dossiers, par exemple le dossier Éléments envoyés, doivent être affichés comme partie intégrante de la conversation dans l’affichage Tableau. Lecture/écriture. |
Si la valeur de TableView.ShowConversationByDate est true, l’affichage utilise la nouvelle disposition Conversation dans Outlook 2010. Lorsque l’affichage actuel est en mode Conversation, une conversation peut être une conversation à élément unique, une conversation scindée ou une conversation développée. La sélection change selon que l’élément sélectionné soit un en-tête de conversation ou une conversation développée (plusieurs éléments peuvent être sélectionnés dans la conversation développée). En outre, Outlook 2010 ajoute un nouvel objet ConversationHeader, et un ou plusieurs en-têtes de conversation peuvent être sélectionnés dans un affichage. Pour déterminer si des en-têtes de conversation sont sélectionnés dans un affichage, utilisez la nouvelle méthode GetSelection sur l’objet Selection et passez OlSelectionContents.olConversationHeaders à la méthode. L’appel de la méthode GetSelection renvoie un objet Selection, mais dans ce cas l’objet Selection contient des objets ConversationHeader et non des objets d’éléments tels que des objets MailItem ou MeetingItem. La fonction DemoConversationHeadersFromSelection énumère tous les éléments dans les en-têtes de conversation sélectionnés dans un affichage Conversation.
private void DemoConversationHeadersFromSelection()
{
// Obtain the Inbox folder.
Outlook.Folder inbox =
Application.Session.GetDefaultFolder(
Outlook.OlDefaultFolders.olFolderInbox)
as Outlook.Folder;
// Set ActiveExplorer.CurrentFolder to the Inbox.
// Inbox must be the current folder.
Application.ActiveExplorer().CurrentFolder = inbox;
//Ensure that current view is a TableView object.
if (inbox.CurrentView.ViewType ==
Outlook.OlViewType.olTableView)
{
Outlook.TableView view =
inbox.CurrentView as Outlook.TableView;
if (view.ShowConversationByDate == true)
{
Outlook.Selection selection =
Application.ActiveExplorer().Selection;
Debug.WriteLine("Selection.Count = " + selection.Count);
// Call GetSelection to create
// a Selection object that contains ConversationHeader objects.
Outlook.Selection convHeaders =
selection.GetSelection(
Outlook.OlSelectionContents.olConversationHeaders)
as Outlook.Selection;
Debug.WriteLine("Selection.Count (ConversationHeaders) = "
+ convHeaders.Count);
if (convHeaders.Count >= 1)
{
foreach (Outlook.ConversationHeader convHeader in
convHeaders)
{
// Enumerate the items in the ConversationHeader.
Outlook.SimpleItems items = convHeader.GetItems();
for (int i = 1; i <= items.Count; i++)
{
// Enumerate only MailItem objects in this example.
if (items[i] is Outlook.MailItem)
{
Outlook.MailItem mail =
items[i] as Outlook.MailItem;
Debug.WriteLine(mail.Subject
+ " Received:" + mail.ReceivedTime);
}
}
}
}
}
}
}
Prise en charge des plateformes 32 bits et 64 bits
Cette section décrit des problèmes pouvant compromettre l’extensibilité d’Outlook lorsque vous utilisez Windows 32 bits ou 64 bits alors que Outlook 2010 32 bits ou 64 bits est installé.
Prise en charge du système d’exploitation et d’Office pour Outlook 64 bits
À partir de Microsoft Office 2010, Outlook est proposé sous forme d’application 32 bits ou 64 bits. Sur le même ordinateur, le nombre de bits d’Outlook dépend du nombre de bits du système d’exploitation Windows (x86 ou x64), et d’Office, si Office est déjà installé sur cet ordinateur. Les facteurs suivants déterminent la possibilité d’installer une version 32 bits ou 64 bits d’Outlook :
Office 32 bits (et Outlook 32 bits) peuvent être installés sur une version 32 bits ou 64 bits du système d’exploitation Windows. Office 64 bits (Outlook 64 bits) peuvent uniquement être installés sur un système d’exploitation 64 bits.
L’installation par défaut d’Office sur une version 64 bits du système d’exploitation Windows est Office 32 bits.
Le nombre de bits d’une version installée d’Outlook est toujours le même que le nombre de bits d’Office, si Office est installé sur le même ordinateur. En d’autres mots, une version 32 bits d’Outlook ne peut pas être installée sur le même ordinateur sur lequel des versions 64 bits d’autres applications Office sont déjà installées, par exemple Word 64 bits ou Microsoft Excel 64 bits. De même, une version 64 bits d’Outlook ne peut pas être installée sur un ordinateur où des versions 32 bits d’autres applications Office sont déjà installées.
Considérations pour des applications existantes qui s’exécutent sur Outlook 64 bits
Si vos applications 32 bits s’exécutent sur une version 64 bits du système d’exploitation Windows où Office 64 bits est installé, tenez compte des problèmes suivants :
Le modèle objet devrait fonctionner sans modification pour des versions 32 bits et 64 bits d’Outlook.
Les compléments natifs compilés pour les versions 32 bits d’Outlook (qui incluent toutes les versions d’Outlook antérieures à Outlook 2010) doivent être recompilés pour Outlook 64 bits.
Les compléments Outlook créés à l’aide de Microsoft Visual Studio Tools pour Microsoft Office System 3.0, et des outils de développement Microsoft Office dans Visual Studio 2010, fonctionnent sur les versions 32 bits et 64 bits d’Office, à condition d’être compilés avec l’option Tout processeur pour la plateforme cible dans l’onglet Générer de la boîte de dialogue Propriétés du projet.
Les applications 32 bits autonomes (.exe) qui utilisent le modèle objet Outlook doivent être recompilées pour Outlook 64 bits.
Modifications dans MAPI (Messaging API) pour Outlook 64 bits
Bien qu’il n’y ait aucune différence entre les modèles objet Outlook 2010 pour les versions 32 bits et 64 bits d’Outlook, quelques petites modifications dans des fonctions MAPI ont nécessité l’introduction de MAPI 64 bits avec Outlook 64 bits. Généralement, ces modifications sont liées aux types 64 bits, tels que ULONG_PTR, devant être passés à des fonctions MAPI.
Les applications MAPI incluent des applications autonomes telles que Microsoft Communicator et MFCMAPI (éventuellement en anglais), ainsi que des fournisseurs de services tels que des fournisseurs de carnets d’adresses, de magasins et de transport. Pour permettre le fonctionnement des appels de méthode et de fonction MAPI dans une application MAPI (à l’exception d’une fonction MAPI très simple, MAPISendMail), le nombre de bits de l’application MAPI doit être le même que le nombre de bits du sous-système MAPI sur l’ordinateur où l’application doit être exécutée. Le nombre de bits du sous-système MAPI est quant à lui déterminé et correspond toujours à celui de la version installée d’Outlook.
Si votre solution est native et appelle MAPI directement, consultez le document Welcome to the Outlook 2010 MAPI Reference pour obtenir des instructions sur un portage de votre solution garantissant son fonctionnement avec Outlook 64 bits. Les rubriques suivantes sont particulièrement intéressantes pour les développeurs MAPI :
Extensions de client Exchange désapprouvées
Les extensions de client Exchange (ECE) ont été désapprouvées dans Outlook 2010. Les extensions de client Exchange ont été introduites avec le client Microsoft Exchange en 1995, lorsque le client était une application courrier 16 bits s’exécutant sur les premières versions d’Exchange Server. Les extensions de client Exchange doivent être écrites en code natif, généralement en utilisant C++ et en s’appuyant fortement sur MAPI. Lorsque Outlook a remplacé le client Exchange, les ECE étaient utilisées pour étendre Outlook 97-98 jusqu’à ce que les Compléments COM (éventuellement en anglais) aient remplacé les extensions de client Exchange dans Outlook 2000.
Les extensions de client Exchange continueront à fonctionner de la manière prévue dans Outlook 2007 et versions antérieures. Cependant, elles ne se chargeront pas dans les versions 32 bits et 64 bits d’Outlook 2010. Pour revoir la conception de votre solution ECE existante, envisagez les options suivantes :
Réécrivez votre extension de client Exchange sous la forme d’un complément COM en utilisant du code natif ou géré. Contrairement aux extensions de client Exchange, un complément représente une technologie d’extensibilité stratégique qui est entièrement prise en charge dans Outlook 2010. En utilisant un complément Outlook, vous pouvez construire des zones de formulaire Outlook et étendre l’interface utilisateur Office Fluent. Pour plus d’informations, consultez Construction d’une zone de formulaire Outlook 2007 avec un complément géré (éventuellement en anglais), le Centre des développeurs d’interface utilisateur Office Fluent (éventuellement en anglais) et le Centre des développeurs Outlook (éventuellement en anglais) sur MSDN.
Réécrivez votre extension de client Exchange sous la forme d’une application de service Windows en utilisant un code natif et MAPI. Si vous écrivez une application de service Windows, vous devez utiliser MAPI pour accéder à des éléments Outlook à la place du modèle objet Outlook.
CDO 1.21 non pris en charge pour Outlook 2010
CDO (Collaboration Data Objects) 1.2.1 est une bibliothèque cliente qui fournit une fine couche qui enveloppe la fonctionnalité MAPI étendue. CDO ne s’installe pas avec Outlook 2010, et est uniquement disponible sous forme de téléchargement. Pour plus d’informations, consultez Collaboration Data Objects, version 1.2.1 (éventuellement en anglais) dans le Centre de téléchargement Microsoft. Le fonctionnement de CDO n’est pas garanti dans un environnement comportant de multiples comptes Exchange. CDO 1.2.1 est une bibliothèque cliente 32 bits et ne fonctionne pas avec Outlook 2010 64 bits. Par conséquent, l’utilisation de CDO 1.2.1 n’est pas prise en charge avec Outlook 2010. La plupart des fonctionnalités de CDO 1.2.1 ont été incorporées dans le modèle objet Outlook 2010. En tant qu’option de remplacement à CDO 1.2.1, mettez à jour les solutions existantes qui dépendent de CDO pour utiliser le modèle objet Outlook ou pour utiliser MAPI directement.
Comptes Exchange multiples
L’une des nouvelles fonctionnalités très intéressantes d’Outlook 2010 est la capacité d’exécuter de multiples comptes Exchange. Le modèle objet Outlook avait été initialement conçu autour d’un seul compte Exchange dans un profil donné. Dans Outlook 2007, les propriétés et les méthodes associées à un compte Exchange sont disponibles sur l’objet Namespace. Pour gérer de multiples comptes Exchange, l’objet Account expose dorénavant plusieurs nouvelles propriétés et méthodes. Des propriétés telles que ExchangeMailboxServerName, ExchangeMailboxServerVersion et ExchangeConnectionMode sont toujours présentes sur l’objet Namespace, mais renvoie des valeurs qui s’appliquent uniquement au compte Exchange principal. Pour les propriétés Exchange liées à tous les comptes Exchange d’un profil, utilisez l’objet Account. Le tableau suivant montre les propriétés et les méthodes qui ont été ajoutées à l’objet Account dans Outlook 2010 pour prendre en charge plusieurs comptes Exchange.
Tableau 6. Ajouts de membres d’objets de comptes
Nom |
Type |
Description |
AutoDiscoverConnectionMode |
Propriété |
Renvoie une constante OlAutoDiscoverConnectionMode qui spécifie le type de connexion à utiliser pour le service de découverte automatique du serveur Exchange qui héberge la boîte aux lettres du compte. Lecture seule. |
AutoDiscoverXml |
Propriété |
Renvoie une chaîne qui représente des informations en code XML qui sont récupérées du service de découverte automatique du serveur Exchange qui est associé au compte. Lecture seule. |
CurrentUser |
Propriété |
Renvoie un objet Recipient qui représente l’identité de l’utilisateur actuel du compte. Lecture seule. |
DeliveryStore |
Propriété |
Renvoie un objet Store qui représente le magasin de livraison par défaut du compte. Renvoie Null (Nothing dans Visual Basic) s’il ne compte n’a pas de magasin de livraison par défaut. |
ExchangeConnectionMode |
Propriété |
Renvoie une constante OlExchangeConnectionMode qui indique le mode de connexion actuel du serveur Exchange qui héberge la boîte aux lettres du compte. Lecture seule. |
ExchangeMailboxServerName |
Propriété |
Renvoie une chaîne qui représente le nom du serveur Exchange qui héberge la boîte aux lettres du compte. |
ExchangeMailboxServerVersion |
Propriété |
Renvoie le numéro de version complet du serveur Exchange qui héberge la boîte aux lettres du compte. Lecture seule. |
GetAddressEntryFromID |
Méthode |
Renvoie un objet AddressEntry qui représente l’entrée d’adresse spécifiée par ID. |
GetRecipientFromID |
Méthode |
Renvoie un objet Recipient identifié par l’ID d’entrée spécifié. |
Énumération de comptes dans un profil
La fonction EnumerateAccounts suivante fournit un exemple très simple d’utilisation des nouvelles propriétés sur l’objet Account.
private void EnumerateAccounts()
{
Outlook.Accounts accounts =
Application.Session.Accounts;
foreach (Outlook.Account account in accounts)
{
try
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Account: " + account.DisplayName);
if (string.IsNullOrEmpty(account.SmtpAddress)
|| string.IsNullOrEmpty(account.UserName))
{
Outlook.AddressEntry oAE =
account.CurrentUser.AddressEntry
as Outlook.AddressEntry;
if (oAE.Type == "EX")
{
Outlook.ExchangeUser oEU =
oAE.GetExchangeUser()
as Outlook.ExchangeUser;
sb.AppendLine("UserName: " +
oEU.Name);
sb.AppendLine("SMTP: " +
oEU.PrimarySmtpAddress);
sb.AppendLine("Exchange Server: " +
account.ExchangeMailboxServerName);
sb.AppendLine("Exchange Server Version: " +
account.ExchangeMailboxServerVersion);
}
else
{
sb.AppendLine("UserName: " +
oAE.Name);
sb.AppendLine("SMTP: " +
oAE.Address);
}
}
else
{
sb.AppendLine("UserName: " +
account.UserName);
sb.AppendLine("SMTP: " +
account.SmtpAddress);
if (account.AccountType ==
Outlook.OlAccountType.olExchange)
{
sb.AppendLine("Exchange Server: " +
account.ExchangeMailboxServerName);
sb.AppendLine("Exchange Server Version: " +
account.ExchangeMailboxServerVersion);
}
}
If (account.DeliveryStore !=null)
{
sb.AppendLine("Delivery Store: " +
account.DeliveryStore.DisplayName);
}
sb.AppendLine("---------------------------------");
Debug.Write(sb.ToString());
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
Création d’un élément expédiable et définition du champ De
L’une des méthodes les plus couramment utilisées dans le modèle objet Outlook est la méthode CreateItem sur l’objet Application. Cette méthode n’a aucune information sur des comptes multiples, et crée toujours l’élément pour le compte principal du profil. Si vous souhaitez créer un élément expédiable qui « comprend » le compte associé à un dossier donné, vous devez déterminer la propriété Store du dossier actuel, puis énumérer la collection Accounts pour déterminer si la propriété DeliveryStore d’un compte donné correspond à la propriété Store du dossier actuel. Une fois que vous avez déterminé l’objet Account approprié pour la propriété Store du dossier actuel, vous pouvez définir la propriété Sender d’un objet MailItem ou la propriété SendUsingAccount d’un objet AppointmentItem. Les fonctions CreateMailItemUsingAccount et CreateMeetingRequestUsingAccount vous montrent comment gérer cette fonctionnalité dans un scénario à comptes multiples.
private void CreateMailItemFromAccount()
{
Outlook.AddressEntry addrEntry = null;
Outlook.Folder folder =
Application.ActiveExplorer().CurrentFolder
as Outlook.Folder;
Outlook.Store store = folder.Store;
Outlook.Accounts accounts =
Application.Session.Accounts;
foreach (Outlook.Account account in accounts)
{
if (account.DeliveryStore == store)
{
addrEntry =
account.CurrentUser.AddressEntry;
break;
}
}
Outlook.MailItem mail =
Application.CreateItem(
Outlook.OlItemType.olMailItem)
as Outlook.MailItem;
if (addrEntry != null)
{
mail.Sender = addrEntry;
}
mail.Display(false);
}
private void CreateMeetingRequestFromAccount()
{
Outlook.Account acct = null;
Outlook.Folder folder =
Application.ActiveExplorer().CurrentFolder
as Outlook.Folder;
Outlook.Store store = folder.Store;
Outlook.Accounts accounts =
Application.Session.Accounts;
foreach (Outlook.Account account in accounts)
{
if (account.DeliveryStore == store)
{
acct = account;
break;
}
}
Outlook.AppointmentItem appt =
Application.CreateItem(
Outlook.OlItemType.olAppointmentItem)
as Outlook.AppointmentItem;
appt.MeetingStatus =
Outlook.OlMeetingStatus.olMeeting;
if (acct != null)
{
appt.SendUsingAccount=acct;
}
appt.Display(false);
}
Détermination de la liste d’adresses globale pour un magasin Exchange
Lorsque plusieurs comptes Exchange sont disponibles dans un profil, vous pouvez énumérer la collection AddressLists disponible pour un objet Store donné et déterminer la liste d’adresses globale (GAL) d’un magasin Exchange donné. L’exemple de code suivant renvoie un objet AddressList qui représente la liste d’adresses globale de l’objet Store passé à la fonction GetGlobalAddressList. Vous pouvez utiliser la fonction GetGlobalAddressList dans l’exemple de code pour renvoyer un objet AddressList qui représente la liste d’adresses globale pour l’objet Store de ActiveExplorer().CurrentFolder. L’exemple de code vous indique un moyen de reproduire le comportement natif d’Outlook dans un environnement comportant plusieurs comptes Exchange. Lorsque l’utilisateur clique sur Nouveau courrier, la première liste d’adresses affichées dans la boîte de dialogue du carnet d’adresses d’Outlook est la liste d’adresses globale de l’objet Store du dossier actuel si le magasin est le magasin de livraison d’un compte Exchange. Utilisez les fonctions DisplayGlobalAddressListForStore et GetGlobalAddressList pour reproduire le comportement par programme.
void DisplayGlobalAddressListForStore()
{
Outlook.Folder currentFolder =
Application.ActiveExplorer().CurrentFolder
as Outlook.Folder;
Outlook.Store currentStore = currentFolder.Store;
if (currentStore.ExchangeStoreType !=
Outlook.OlExchangeStoreType.olNotExchange)
{
Outlook.SelectNamesDialog snd =
Application.Session.GetSelectNamesDialog();
Outlook.AddressList addrList =
GetGlobalAddressList(currentStore);
if (addrList != null)
{
snd.InitialAddressList = addrList;
snd.Display();
}
}
}
public Outlook.AddressList GetGlobalAddressList(Outlook.Store store)
{
string PR_EMSMDB_SECTION_UID =
@"https://schemas.microsoft.com/mapi/proptag/0x3D150102";
if (store == null)
{
throw new ArgumentNullException();
}
Outlook.PropertyAccessor oPAStore = store.PropertyAccessor;
string storeUID = oPAStore.BinaryToString(
oPAStore.GetProperty(PR_EMSMDB_SECTION_UID));
foreach (Outlook.AddressList addrList
in Application.Session.AddressLists)
{
Outlook.PropertyAccessor oPAAddrList =
addrList.PropertyAccessor;
string addrListUID = oPAAddrList.BinaryToString(
oPAAddrList.GetProperty(PR_EMSMDB_SECTION_UID));
// Return addrList if match on storeUID
// and type is olExchangeGlobalAddressList.
if (addrListUID == storeUID && addrList.AddressListType ==
Outlook.OlAddressListType.olExchangeGlobalAddressList)
{
return addrList;
}
}
return null;
}
Énumération d’objets AddressList pour un magasin de livraison
L’exemple de code suivant utilise une propriété dans Outlook 2010 qui sert d’identificateur unique pour les objets Store et AddressList. Cette propriété, nommée PR_EMSMDB_SECTION_UID dans l’exemple de code suivant, sert à évaluer si un objet AddressList donné appartient à un objet Store particulier. L’objet Store doit représenter un magasin de livraison. Dans le cas de comptes Exchange multiples, un objet Store agit comme magasin de livraison d’un compte Exchange donné. La fonction EnumerateAddressListsForStore énumère les listes d’adresses pour ActiveExplorer().CurrentFolder.Store.
private void EnumerateAddressListsForStore()
{
Outlook.Folder currentFolder =
Application.ActiveExplorer().CurrentFolder
as Outlook.Folder;
Outlook.Store currentStore = currentFolder.Store;
List<Outlook.AddressList> addrListsForStore =
GetAddressLists(currentStore);
foreach (Outlook.AddressList addrList in addrListsForStore)
{
Debug.WriteLine(addrList.Name
+ " " + addrList.AddressListType.ToString()
+ " Resolution Order: " +
addrList.ResolutionOrder);
}
}
public List<Outlook.AddressList> GetAddressLists(Outlook.Store store)
{
List<Outlook.AddressList> addrLists =
new List<Microsoft.Office.Interop.Outlook.AddressList>();
string PR_EMSMDB_SECTION_UID =
@"https://schemas.microsoft.com/mapi/proptag/0x3D150102";
if (store == null)
{
throw new ArgumentNullException();
}
Outlook.PropertyAccessor oPAStore = store.PropertyAccessor;
string storeUID = oPAStore.BinaryToString(
oPAStore.GetProperty(PR_EMSMDB_SECTION_UID));
foreach (Outlook.AddressList addrList
in Application.Session.AddressLists)
{
Outlook.PropertyAccessor oPAAddrList =
addrList.PropertyAccessor;
string addrListUID = oPAAddrList.BinaryToString(
oPAAddrList.GetProperty(PR_EMSMDB_SECTION_UID));
// Return addrList if match on storeUID
// and type is olExchangeGlobalAddressList.
if (addrListUID == storeUID)
{
addrLists.Add(addrList);
}
}
return addrLists;
}
Conclusion
Outlook 2010 vous ouvre, en tant que développeur, de formidables perspectives. Vous pouvez améliorer l’interface utilisateur de votre solution pour une intégration transparente avec la nouvelle interface utilisateur d’Outlook 2010, et si votre solution utilise des dossiers personnalisés pour stocker des informations, vous pouvez employer le nouveau module Solutions et des icônes de dossiers personnalisées pour améliorer le confort et l’efficacité d’exploration. Votre code doit pouvoir gérer plusieurs comptes Exchange et tirer parti des modifications apportées au modèle objet s’appuyant sur les nouvelles fonctionnalités puissantes d’Outlook 2010, telles que les affichages de conversation et la sélection d’éléments. Enfin, des modifications à la plateforme, par exemple la prise en charge des versions 32 bits et 64 bits d’Outlook, introduisent d’autres modifications et une évolution, notamment pour les applications avancées écrites au niveau MAPI.
Ressources supplémentaires
MAPI
Welcome to the Outlook 2010 MAPI Reference
Outlook 2010 : fichiers d’en-têtes MAPI (éventuellement en anglais)
Exemple MAPI (Messaging API) Outlook 2010 (éventuellement en anglais)
SGriffin’s MAPI Internals (éventuellement en anglais)
Extensibilité de l’interface utilisateur Office Fluent
Personnalisation des menus contextuels dans Office 2010
Introduction au mode Backstage Office 2010 pour les développeurs
Extensibilité du Ruban dans Office 2010 : Activation d’onglet et mise à l’échelle automatique
Schéma de l’interface utilisateur Microsoft Office 2010 Fluent (éventuellement en anglais)