Neues für Entwickler in Outlook 2010

Zusammenfassung: Dieser Artikel enthält eine allgemeine Übersicht über die Erweiterungen und Ergänzungen für Entwickler in Microsoft Outlook 2010. Außerdem werden einige der neuen und erweiterten Objekte im Outlook-Objektmodell einschließlich der zugehörigen Eigenschaften, Methoden und Ereignisse im Detail untersucht. Für Entwickler, die sich über die Outlook-Plattform informieren möchten, enthält der Artikel genug Details, um mit der Codierung für Outlook 2010 zu beginnen.

Letzte Änderung: Mittwoch, 30. Januar 2013

Gilt für: Office 2010 | Outlook 2010

Inhalt dieses Artikels
Outlook 2010-Plattform (Übersicht)
Änderungen im Outlook-Objektmodell
Add-In-Widerstandsfähigkeit
Verbesserte Erweiterbarkeit der Benutzeroberfläche
Umfassendes Objektmodell
Unterstützung für 32-Bit- und 64-Bit-Plattformen
Mehrere Exchange-Konten
Schlussbemerkung
Weitere Ressourcen

Inhalt

• Outlook 2010-Plattform (Übersicht)

• Änderungen im Outlook-Objektmodell

• Add-In-Widerstandsfähigkeit

• Verbesserte Erweiterbarkeit der Benutzeroberfläche

• Umfassendes Objektmodell

• Unterstützung für 32-Bit- und 64-Bit-Plattformen

• Mehrere Exchange-Konten

• Schlussbemerkung

• Weitere Ressourcen

Outlook 2010-Plattform (Übersicht)

Mit den Änderungen im Outlook 2010-Objektmodell werden Kundenwünsche erfüllt bezüglich der Erweiterbarkeit der Benutzeroberfläche und der Bereitstellung von Unterstützung für die neuen Features im Objektmodell, die für die Outlook 2010-Endbenutzer entwickelt wurden. Zur Outlook 2010-Plattform gehören die folgenden Features:

• Add-In-Widerstandsfähigkeit

  Durch Add-Ins sollte die Leistung oder Widerstandsfähigkeit von Outlook nicht beeinträchtigt werden. Von Outlook wird eine Liste der verbundenen Add-Ins in das Windows-Ereignisprotokoll geschrieben, und für jedes verbundene Add-In wird die Startzeit aufgezeichnet. Außerdem wird in das Windows-Ereignisprotokoll geschrieben, wenn ein Add-In bei einem Ereignisrückruf abstürzt. Um nachteilige Auswirkungen von Add-Ins auf die Leistung von Outlook beim Schließen der Outlook-Anwendung durch eine Benutzeraktion zu verhindern, wird in neuer Vorgang für schnelles Herunterfahren verwendet. Weitere Informationen zum neuen Vorgang für das Herunterfahren finden Sie unter Änderungen beim Herunterfahren für Outlook 2010.

• Verbesserte Erweiterbarkeit der Benutzeroberfläche

  Sie können viele neue Bereiche der Outlook-Benutzeroberfläche anpassen, beispielsweise ein benutzerdefiniertes Navigationsmodul im Navigationsbereich, das als Lösungsmodul bezeichnet wird. Sie können mithilfe des Lösungsmoduls benutzerdefinierte Ordnersymbole für Outlook-Ordner festlegen oder abrufen. Mithilfe des Lösungsmoduls kann der Inhalt eines benutzerdefinierten Lösungsordners leichter gefunden werden. Mithilfe der Erweiterbarkeit für die Microsoft Office Fluent-Benutzeroberfläche können Sie Bereiche der Benutzeroberfläche anpassen, die in vorherigen Versionen von Outlook nicht erweitert werden konnten. Weitere Informationen zum Lösungsmodul finden Sie unter Programmieren des Outlook 2010-Lösungsmoduls. Weitere Informationen zur Verwendung der Menübanderweiterbarkeit zum Anpassen der Outlook-Benutzeroberfläche finden Sie unter Erweitern der Benutzeroberfläche von Outlook 2010.

• Unterstützung für 32-Bit- und 64-Bit-Plattformen

  Sie können Lösungen für 32-Bit- und 64-Bit-Plattformen entwickeln, indem Sie als einzige API das Outlook-Objektmodell verwenden.

• Umfassendes Objektmodell

  Für die Mehrheit der Entwickler ist das Objektmodell umfassend und ausreichend, um eine professionelle Lösung zu schreiben, ohne Code auf MAPI-Ebene (Messaging-API) schreiben zu müssen.

• Mehrere Exchange-Konten

  Sie können in einem einzigen Profil mehrere Microsoft Exchange-Konten definieren. Das Objektmodell wurde ursprünglich in der Annahme entworfen, dass pro Profil nur ein Exchange-Konto ausgeführt wird. Dank der Verbesserungen des aktualisierten Objektmodells können mehrere Exchange-Konten verwendet werden.

In diesem Artikel werden wichtige neue Features im Objektmodell erörtert. Außerdem sind Codebeispiele in C# enthalten, mit deren Hilfe Sie neue Lösungen schreiben oder vorhandenen Code für Outlook 2010 anpassen können.

Änderungen im Outlook-Objektmodell

Das Outlook-Objektmodell verfügt über neue Objekte, Methoden, Eigenschaften und Ereignisse, von denen neue Outlook 2010-Features programmatisch unterstützt werden. Weitere Verbesserungen des Objektmodells beziehen sich auf häufige Entwicklerwünsche im Zusammenhang mit bestimmten Änderungen an der Outlook-Plattform.

Erweiterungen für vorhandene Outlook-Objekte und -Auflistungen für Outlook 2010

In der folgenden Tabelle werden Erweiterungen für Objekte und Auflistungen aufgeführt, die in früheren Versionen von Outlook enthalten sind. In der zweiten Spalte werden nur neue Methoden, Eigenschaften und Ereignisse aufgeführt.

Tabelle 1. Erweiterungen des Outlook-Objektmodells

Neue Outlook-Objekte und -Auflistungen für Outlook 2010

In der folgenden Tabelle werden die in Outlook 2010 neu eingeführten Objekte aufgeführt. Alle Objektmember werden in der zweiten Spalte aufgeführt.

Tabelle 1. Ergänzungen des Outlook-Objektmodells

Add-In-Widerstandsfähigkeit

Die Add-In-Widerstandsfähigkeit ist ein wichtiges Feature der Outlook 2010-Plattform. Add-In-Widerstandsfähigkeit bedeutet, dass Outlook vor und nach dem Laden eines Add-Ins normal ausgeführt wird und reagiert. Add-Ins werden im Prozess von Outlook ausgeführt und können die Outlook-Benutzererfahrung potenziell beeinträchtigen. Darüber hinaus haben IT-Administratoren Bedenken, dass sie in nicht verwalteten Umgebungen nicht immer wissen, welche Add-Ins die Benutzer ausführen, und dass schlecht geschriebene Add-Ins zu Anrufen beim Helpdesk und zu den Betriebskosten beitragen. Da alle Aufrufe des Outlook-Objektmodells im wesentlichen Vordergrundthread in Outlook ausgeführt werden, ist es wichtig, dass Sie der Leistung beim Schreiben von Code höchste Priorität einräumen. Wenn Outlook aufgrund Ihres Codes langsam ausgeführt wird oder unbegrenzt lange angehalten wird, führt dies bei den Benutzern zu Frustrationen, und sie verwenden die Lösung nicht.

Inventur und Startzeit von Add-Ins im Windows-Ereignisprotokoll

In Outlook 2010 können Benutzer und IT-Administratoren bestimmen, welche Add-Ins beim Starten von Outlook geladen werden und welche Auswirkungen diese Add-Ins auf die Startzeit haben. Beim Starten von Outlook werden detaillierte Informationen zur Identität der einzelnen verbundenen Add-Ins in das Windows-Ereignisprotokoll geschrieben. Außerdem werden die Startzeiten aller verbundenen Add-Ins (in Millisekunden) in das Ereignisprotokoll geschrieben.

Abbildung 1. Outlook 2010-Add-Ins und Startzeit der einzelnen Add-Ins im Windows-Ereignisprotokoll

Schnelles Herunterfahren von Add-Ins

In Outlook 2010 wird ein neuer Vorgang für das schnelle Herunterfahren von Add-Ins erzwungen. Mit dem neuen schnellen Herunterfahren wird verhindert, dass durch Add-Ins lange Verzögerungen verursacht werden, weil Ressourcen nicht freigegeben werden, wenn der Benutzer Outlook beendet hat. Diese Änderung kann sich zwar nachteilig auf eine kleine Zahl vorhandener Add-Ins auswirken, aber Add-In-Anbieter und IT-Administratoren können diese Effekte abschwächen, indem sie Outlook zwingen, zum standardmäßigen Vorgang für das Herunterfahren von Add-Ins zurückzukehren.

In der folgenden Liste werden einige wichtige Fakten zum Vorgang für das schnelle Herunterfahren von Add-Ins beschrieben:

• Beim Herunterfahren von Outlook durch eine Benutzeraktion tritt das OnDisconnection-Ereignis der IDTExtensibility2-Schnittstelle nicht auf, wenn der RemoveMode-Parameter auf ext_DisconnectMode.ext_dm_HostShutdown festgelegt ist.

• Für verwaltete Add-Ins von Microsoft Visual Studio-Tools für Office wird die Shutdown-Methode der ThisAddin-Klasse nicht aufgerufen, wenn Outlook durch eine Benutzeraktion heruntergefahren wird.

• Wenn das Add-In durch eine Benutzeraktion im Dialogfeld COM-Add-Ins getrennt wird, tritt das OnDisconnection-Ereignis der IDTExtensiblity2-Schnittstelle auf, wenn RemoveMode gleich ext_DisconnectMode.ext_dm_UserClosed ist.

• Wenn Outlook durch eine Benutzeraktion heruntergefahren wird, tritt das Quit-Ereignis des Application-Objekts von Outlook auf.

Weitere Informationen zum Herunterfahren von Add-Ins sowie bewährte Methoden finden Sie unter Änderungen beim Herunterfahren für Outlook 2010.

Verbesserte Erweiterbarkeit der Benutzeroberfläche

Outlook 2010 enthält die folgenden häufig von Entwicklern gewünschten Möglichkeiten zum Erweitern der Benutzeroberfläche:

• Fügen Sie dem neuen Lösungsmodul im Navigationsbereich eine Hierarchie benutzerdefinierter Ordner hinzu. Im Outlook-Objektmodell wird das Lösungsmodul durch das SolutionsModule-Objekt dargestellt. Vom SolutionsModule-Objekt wird die AddSolution-Methode verfügbar gemacht, die Sie zum Hinzufügen eines Lösungsstammordners verwenden können. Alle Unterordner des Lösungsstammordners werden von Outlook 2010 automatisch der im Lösungsmodul angezeigten Lösungsordnerhierarchie hinzugefügt. Ein Beispiel für das Lösungsmodul sehen Sie in Abbildung 2.

• Passen Sie Ordnersymbole für Lösungsordner an. Sie können die Methoden SetCustomIcon und GetCustomIcon des Folder-Objekts verwenden, um Ordnersymbole festzulegen und abzurufen.

• Verwenden Sie die Erweiterbarkeit der Office Fluent-Benutzeroberfläche, um die Outlook-Benutzeroberfläche anzupassen. Dazu gehören beispielsweise folgende Elemente:

  • Explorer-Menübänder

  • Menübänder mit Prüfungsoptionen

  • Kontextmenüs

  • Neue Elementmenüs

  • Kontextmenüs für Visitenkarten

  • Kontextregisterkarten

  • Microsoft Office Backstage-Ansicht

Abbildung 2. Beispiellösungsmodul in Outlook 2010

Wenn mit vorhandenem Code Office-Befehlsleisten angepasst werden, werden diese Benutzeroberflächenanpassungen auf der Registerkarte Add-Ins angezeigt, die Benutzer möglicherweise nicht leicht finden. Folgen Sie den Richtlinien für die Erweiterbarkeit der Office Fluent-Benutzeroberfläche, und schreiben Sie den Code neu, um die Vorteile von Explorer-Menübändern, Kontextmenüs auf der Office Fluent-Benutzeroberfläche und der Backstage-Ansicht zu nutzen. Umfassende Informationen zur Erweiterbarkeit der Benutzeroberfläche in Outlook 2010 sowie Beispielcode finden Sie in den folgenden Artikeln:

• Erweitern der Benutzeroberfläche von Outlook 2010

• Programmieren des Outlook 2010-Lösungsmoduls

Umfassendes Objektmodell

Ein umfassendes Objektmodell soll sicherstellen, dass Entwickler professionelle Lösungen schreiben können, ohne MAPI-Code direkt zu verwenden. In verwaltetem Code können Sie keine Outlook-Lösungen schreiben, von denen MAPI verwendet wird.

Objektmodell für Unterhaltungen

In Outlook 2010 wird als leistungsstarkes neues Feature die Unterhaltungsansicht und als neues Objekt das Conversation-Objekt eingeführt. Sie können das Conversation-Objekt verwenden, um Unterhaltungsverben auszuführen und die Unterhaltungsstruktur zu traversieren. Die Elemente der Unterhaltung können sich in verschiedenen Speichern und Ordnern befinden.

Zum Zugreifen auf Elemente in einem Unterhaltungsthread rufen Sie die GetConversation-Methode eines Elements auf, um ein Conversation-Objekt zurückzugeben. Das Conversation-Objekt stellt eine Unterhaltung dar, zu der das übergeordnete Element gehört.

Von GetConversation wird Null (Nothing in Visual Basic) zurückgegeben, wenn keine Unterhaltung für das Element vorhanden ist. Unter folgenden Umständen sind keine Unterhaltungen für ein Element vorhanden:

• Das Element wurde nicht gespeichert. Ein Element kann programmatisch, durch eine Benutzeraktion oder durch automatisches Speichern gespeichert werden.

• Ein Element kann gesendet werden, wurde aber nicht gesendet (beispielsweise ein E-Mail-Element, Terminelement oder Kontaktelement).

• Alle Unterhaltungen wurden über die Windows-Registrierung deaktiviert.

• Unterhaltungen werden vom Speicher nicht unterstützt (beispielsweise wenn Outlook im klassischen Modus mit einer früheren Microsoft Exchange-Version als Microsoft Exchange Server 2010 ausgeführt wird). Verwenden Sie die IsConversationEnabled-Eigenschaft des Store-Objekts, um zu ermitteln, ob Unterhaltungen vom Speicher unterstützt werden.

Mit der folgenden DemoConversation-Funktion wird das Conversation-Objekt für ein ausgewähltes Element im Outlook-Explorer-Fenster abgerufen. Zum Auflisten von Elementen in einer Unterhaltung verwenden Sie die GetTable-Methode des Conversation-Objekts, um ein Table-Objekt zurückzugeben. Dann können Sie dem Table-Objekt gegebenenfalls Spalten hinzufügen oder GetNextRow aufrufen, um die einzelnen Zeilen im Table-Objekt zurückzugeben.

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);
            }
        }
    }

Wenn Sie in den einzelnen Knoten der Unterhaltung navigieren möchten, können Sie alternativ die GetRootItems-Methode aufrufen, um ein oder mehrere Stammelemente der Unterhaltung zurückzugeben. Eine Unterhaltung kann mehrere Stammelemente haben, wenn das ursprüngliche einzige Stammelement gelöscht wurde und untergeordnete Elemente zu Stammelementen heraufgestuft wurden. Wenn Sie die Stammelemente haben, können Sie die SimpleItems-Auflistung für alle untergeordneten Konten der einzelnen Stammelemente abrufen. SimpleItems ist ein Auflistungsobjekt, das Sie zum Aufzählen der untergeordneten Elemente der einzelnen Knoten in der Unterhaltung verwenden können. Wenn Sie eine foreach-Schleife verwenden, um die einzelnen Elemente in der Auflistung aufzuzählen, rufen Sie die EnumerateConversation-Funktion rekursiv auf, um auf jedes einzelne untergeordnete Element in der Unterhaltung zuzugreifen. Für die EnumerateConversation-Funktion können zwei Parameter verwendet werden: ein Parameter, der ein Element wie beispielsweise MailItem darstellt, und ein zweiter, der ein Conversation-Objekt darstellt. Mit der GetChildren-Methode des Conversation-Objekts wird eine SimpleItems-Auflistung zurückgegeben, die die untergeordneten Knoten eines bestimmten Elements in der Unterhaltung darstellt. Wenn SimpleItems.Count größer als null ist, wird die Aufzählung der untergeordneten Knoten fortgesetzt, und EnumerateConversation wird für die einzelnen untergeordneten Knoten aufgerufen.

Mit dem Conversation-Objekt werden außerdem Methoden verfügbar gemacht, die das Anwenden von Unterhaltungsverben auf eine Unterhaltung ermöglichen. Konkret können Sie die folgenden Methoden für das Conversation-Objekt in Outlook 2010 verwenden.

Tabelle 3. Methoden des Conversation-Objekts

Mit der IgnorierenAktion beispielsweise bewirken Sie, dass alle aktuellen und zukünftigen Elemente in der Unterhaltung in den Ordner Gelöschte Elemente verschoben werden. Wenn Sie Code schreiben möchten, in dem die IgnorierenAktion dupliziert wird, verwenden Sie die SetAlwaysDelete-Methode, um immer alle Elemente in der Unterhaltung zu löschen und alle neuen Unterhaltungselemente in den Ordner Gelöschte Elemente zu verschieben. Wenn Sie die IgnorierenAktion programmatisch rückgängig machen möchten, rufen Sie die StopAlwaysDelete-Methode auf. Im folgenden Codebeispiel wird die Verwendung der SetAlwaysDelete-Methode veranschaulicht.

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);
                }
            }
        }
    }

Abrufen der SMTP-Adresse des Absenders

In Microsoft Office Outlook 2007 verwendeten Entwickler das PropertyAccessor-Objekt in Code wie dem folgenden, um die SMTP-Adresse des Absenders abzurufen.

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;
        }
    }

In Outlook 2010 wird mit der Sender-Eigenschaft des MailItem-Objekts ein AddressEntry-Objekt zurückgegeben oder festgelegt, das den Absender des Elements darstellt. Sie müssen nicht mehr das PropertyAccessor-Objekt verwenden, um die PR_SENT_REPRESENTING_ENTRYID-Eigenschaft (PidTagSentRepresentingEntryId) zu ermitteln. Stattdessen können Sie Code schreiben, der ähnlich wie im folgenden Beispiel aussieht.

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;
        }
    }

Verbesserungen bei "PropertyAccessor"

Verwenden Sie das PropertyAccessor-Objekt, um Eigenschaften für Objekte zu erstellen, festzulegen, abzurufen und zu löschen. In Outlook 2007 ergaben sich durch das PropertyAccessor-Objekt Einschränkungen für die Größe der Eigenschaft, die mit dem Aufruf GetProperty oder GetProperties abgerufen werden konnte. In Outlook 2010 bestehen diese Einschränkungen nicht mehr.

Sie können auch das PropertyAccessor-Objekt in Outlook 2010 verwenden, um Anlagen zu ändern, ohne die Anlage auf den Datenträger zu schreiben. Dazu verwenden Sie die SaveAsFile-Methode für das Attachment-Objekt. Im folgenden Codebeispiel wird mit dem PropertyAccessor-Objekt ein Bytearray aus dem Attachment-Objekt abgerufen, das Bytearray wird im Arbeitsspeicher von A in B geändert, und dann wird das Attachment-Objekt auf das geänderte Bytearray festgelegt. Rufen Sie die Save-Methode für das Element auf, um die Änderungen dauerhaft zu speichern.

    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();
    }

Zugreifen auf Rich-Text-Formate (RTF)

In Outlook wird der Zugriff auf umfangreiche Formatierung für den Text eines Elements über die WordEditor-Eigenschaft des Inspector-Objekts unterstützt. WordEditor stellt das Word.Document-Objekt im Microsoft Word-Objektmodell dar. Inspector.WordEditor kann verwendet werden, wenn ein Outlook-Element in einer Prüfung angezeigt wird. Für Fälle, in denen das Prüfungsfenster nicht angezeigt wird, wird in Outlook 2010 die RTFBody-Eigenschaft für Elementobjekte wie beispielsweise MailItem, AppointmentItem usw. eingeführt. RTFBody wird für alle Elementtypen mit Ausnahme von NoteItem und JournalItem verfügbar gemacht. RTFBody ist eine Eigenschaft mit Lese-/Schreibzugriff, und Sie können ein Bytearray festlegen oder abrufen, das den RTF-Stream für das Element darstellt. Abhängig von der Entwicklungsumgebung müssen Sie das von RTFBody zurückgegebene Bytearray in eine Zeichenfolge konvertieren, gegebenenfalls die Zeichenfolge ändern, die den RTF-Text enthält, die Zeichenfolge in ein Bytearray konvertieren und dann RTFBody auf das geänderte Bytearray festlegen.

Im folgenden Codebeispiel wird der RTF-Text für das erste Element im Selection-Objekt für das aktive Explorer-Fenster in das Fenster des Listeners für die Debugablaufverfolgung in Visual Studio geschrieben. Mit dem Code wird das Bytearray aus dem E-Mail-Objekt abgerufen, und dann wird das Bytearray mit System.Text.AsciiEncoding in eine Zeichenfolge konvertiert.

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);
        }
    }
}

Abrufen von Elementen, die in einer Ansicht angezeigt werden

Sie können mit Outlook 2010 in einer Ansicht angezeigte Elemente abrufen, in dem Sie die GetTable-Methode für das TableView-Objekt aufrufen. Von GetTable wird ein Table-Objekt zurückgegeben, Sie können jedoch nicht wie bei Folder.GetTable Parameter für die Methode angeben. Verwenden Sie GetTable, wenn die Ansicht eine Einschränkung enthält, aufgrund derer sich die Elemente in der Ansicht von den Elementen im Ordner unterscheiden, oder wenn von einer Sofortsuchabfrage Elemente aus mehreren Ordnern oder Speichern zurückgegeben werden. Im folgenden Codebeispiel wird ein Table-Objekt aus der aktuellen Ansicht im Posteingang abgerufen. Der TableView.GetTable-Aufruf ist nur erfolgreich, wenn der Posteingang der aktuelle Ordner ist. Wenn Sie TableView.GetTable für einen Ordner aufrufen, bei dem es sich nicht um den aktuellen Ordner in einem sichtbaren Explorer-Fenster handelt, wird von Outlook ein Fehler ausgelöst.

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"]);
            }
        }
    }

Verbesserungen beim Selection-Objekt

Das Selection-Objekt wurde um eine Location-Eigenschaft erweitert, über die der Entwickler Informationen zum Benutzeroberflächenbereich für die Auswahl erhält. Die Location-Eigenschaft ist schreibgeschützt und gibt einen Wert in der OlSelectionLocation-Aufzählung zurück. In früheren Versionen von Outlook enthielt das Selection-Objekt nur in der Ansichtsliste ausgewählte Elemente. In Outlook 2010 kann mit Selection.Location einer der folgenden OlSelectionLocation-Werte zurückgegeben werden.

Tabelle 4. Rückgabewerte von "OlSelectionLocation"

Wenn die Auswahl geändert wird, tritt das SelectionChange-Ereignis für alle vorher aufgelisteten Auswahlpositionen mit Ausnahme von olAttachmentWell auf. Wenn eine Anlage auf der Anlageleiste ausgewählt ist, tritt das AttachmentSelectionChange-Ereignis auf. Die Ereignisse SelectionChange und AttachmentSelectionChange gelten für das Explorer-Objekt.

Wenn Sie das Selection-Objekt beim Auftreten des SelectionChange-Ereignisses aufzählen, müssen Sie sicherstellen, dass verschiedene Elementtypen vom Code richtig behandelt werden können. Erwarten Sie nicht, dass das Selection-Objekt nur ein MailItem-Objekt enthält.

Das erweiterte Selection-Objekt in Outlook 2010 kann für alle Ansichtstypen verwendet werden, einschließlich der neuen Unterhaltungsansicht in Outlook 2010. Mithilfe der folgenden Eigenschaften können Sie ermitteln, ob es sich bei der aktuellen Ansicht um eine Unterhaltungsansicht handelt.

Tabelle 5. TableView-Eigenschaften

Wenn der Wert von TableView.ShowConversationByDate gleich true ist, wird für die Ansicht die neue Unterhaltungsanordnung in Outlook 2010 verwendet. Wenn es sich bei der aktuellen Ansicht um eine Unterhaltungsansicht handelt, kann es sich bei einer Unterhaltung um eine Unterhaltung mit einem einzigen Element, eine geteilte Unterhaltung oder eine erweiterte Unterhaltung handeln. Die Auswahl wird abhängig davon geändert, ob das ausgewählte Element eine Unterhaltungskopfzeile oder eine erweiterte Unterhaltung ist (in der erweiterten Unterhaltung können mehrere Elemente ausgewählt sein). Außerdem wird in Outlook 2010 ein neues ConversationHeader-Objekt hinzugefügt, und in einer Ansicht können eine oder mehrere Unterhaltungskopfzeilen ausgewählt sein. Wenn Sie ermitteln möchten, ob Unterhaltungskopfzeilen in einer Ansicht ausgewählt sind, verwenden Sie die neue GetSelection-Methode für das Selection-Objekt, und übergeben Sie der Methode OlSelectionContents.olConversationHeaders. Durch Aufrufen der GetSelection-Methode wird ein Selection-Objekt zurückgegeben. In diesem Fall enthält das Selection-Objekt jedoch ConversationHeader-Objekte anstelle von Elementobjekten wie beispielsweise MailItem oder MeetingItem. Mit der DemoConversationHeadersFromSelection-Funktion werden alle Elemente in ausgewählten Unterhaltungskopfzeilen in einer Unterhaltungsansicht aufgezählt.

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);
                        }
                    }
                }
            }
        }
    }
}

Unterstützung für 32-Bit- und 64-Bit-Plattformen

In diesem Abschnitt werden einige der Probleme besprochen, die sich auf die Erweiterbarkeit von Outlook auswirken, wenn Sie 32-Bit- oder 64-Bit-Versionen von Windows verwenden und 32-Bit- oder 64-Bit-Versionen Outlook 2010 installiert sind.

Betriebssystem- und Office-Unterstützung für 64-Bit-Versionen von Outlook

Beginnend mit Microsoft Office 2010 steht Outlook als 32-Bit- oder 64-Bit-Anwendung zur Verfügung. Die Bitanzahl von Outlook auf einem bestimmten Computer hängt von der Bitanzahl des Windows-Betriebssystems (x86 oder x64) sowie, falls Office auf dem Computer installiert ist, von der Bitanzahl von Office ab. Nachstehend finden Sie einige der Faktoren, von denen es abhängt, ob Sie eine 32-Bit- oder 64-Bit-Version von Outlook installieren können:

• 32-Bit-Versionen von Office (und 32-Bit-Versionen von Outlook) können unter einer 32-Bit- oder 64-Bit-Version des Windows-Betriebssystems installiert werden. 64-Bit-Versionen von Office (und 64-Bit-Versionen von Outlook) können nur unter einem 64-Bit-Betriebssystem installiert werden.

• Die Standardinstallation von Office unter einer 64-Bit-Version des Windows-Betriebssystems ist eine 32-Bit-Version von Office.

• Die Bitanzahl einer installierten Version von Outlook entspricht immer der Bitanzahl von Office, wenn Office auf dem gleichen Computer installiert ist. Mit anderen Worten, eine 32-Bit-Version von Outlook kann nicht auf einem Computer installiert werden, auf dem bereits 64-Bit-Versionen anderer Office-Anwendungen (beispielsweise eine 64-Bit-Version von Word oder von Microsoft Excel) installiert sind. Analog kann eine 64-Bit-Version von Outlook nicht auf einem Computer installiert werden, auf dem bereits 32-Bit-Versionen anderer Office-Anwendungen installiert sind.

Überlegungen für vorhandene Anwendungen, die in 64-Bit-Versionen von Outlook ausgeführt werden

Wenn eine 32-Bit-Anwendung unter einer 64-Bit-Version des Windows-Betriebssystems ausgeführt wird und eine 64-Bit-Version von Office installiert ist, sollten Sie die folgenden Probleme berücksichtigen:

• Objektmodellaufrufe sollten für 32-Bit- und 64-Bit-Versionen von Outlook ohne Änderungen möglich sein.

• Systemeigene Add-Ins, die für 32-Bit-Versionen von Outlook kompiliert wurden (dazu gehören alle Versionen von Outlook vor Outlook 2010) müssen für die 64-Bit-Version von Outlook erneut kompiliert werden.

• Outlook-Add-Ins, die mit Microsoft Visual Studio-Tools für Microsoft Office System 3.0 und Microsoft Office-Entwicklungstools in Visual Studio 2010 erstellt wurden, können in 32-Bit- und 64-Bit-Versionen von Office verwendet werden. Voraussetzung ist, dass die Add-Ins für die Zielplattform mit der Option Beliebige CPU auf der Registerkarte Erstellen im Dialogfeld Projekteigenschaften kompiliert wurden.

• Eigenständige 32-Bit-Anwendungen (EXE), für die das Outlook-Objektmodell verwendet wird, müssen für die 64-Bit-Version von Outlook erneut kompiliert werden.

Änderungen bei der Messaging-API (MAPI) für 64-Bit-Versionen von Outlook

Obwohl sich die Outlook 2010-Objektmodelle für die 32-Bit- und 64-Bit-Versionen von Outlook nicht unterscheiden, gibt es kleine Änderungen bei MAPI-Funktionen, die sich durch die Einführung der 64-Bit-MAPI in 64-Bit-Versionen von Outlook ergeben haben. In der Regel beziehen sich diese Änderungen auf 64-Bit-Typen wie beispielsweise ULONG_PTR, die MAPI-Funktionen übergeben werden müssen.

Zu den MAPI-Anwendungen gehören eigenständige Anwendungen wie beispielsweise Microsoft Communicator und MFCMAPI sowie Dienstanbieter wie beispielsweise Adressbuch-, Speicher- und Transportanbieter. Damit MAPI-Methoden und -Funktionsaufrufe in einer MAPI-Anwendung verwendet werden können (mit Ausnahme der einfachen MAPI-Funktion MAPISendMail), muss die Bitanzahl der MAPI-Anwendung der Bitanzahl des MAPI-Subsystems auf dem Computer entsprechen, auf dem die Anwendung ausgeführt werden soll. Die Bitanzahl des MAPI-Subsystems wiederum wird durch die Bitanzahl der installierten Version von Outlook bestimmt und muss dieser immer entsprechen.

Wenn es sich um eine systemeigene Lösung handelt, in der MAPI direkt aufgerufen wird, lesen Sie unter Welcome to the Outlook 2010 MAPI Reference die Ratschläge zum Portieren der Lösung für den Einsatz in einer 64-Bit-Version von Outlook. Die folgenden Themen sind für MAPI-Entwickler von besonderem Interesse:

• Erstellen von MAPI-Anwendungen auf 32-Bit- und 64-Bit-Plattformen

• How to: Link to MAPI Functions

• Herunterfahren von Clients in MAPI

Veraltete Exchange-Clienterweiterungen

Exchange-Clienterweiterungen (Exchange Client Extensions, ECEs) sind in Outlook 2010 veraltet. ECEs wurden 1995 für den Microsoft Exchange-Client eingeführt, als der Client als 16-Bit-Mailanwendung mit den frühesten Versionen von Exchange Server ausgeführt wurde. ECEs müssen in systemeigenem Code geschrieben sein, in der Regel mit C++, und beruhen in hohem Maß auf MAPI. Als der Exchange-Client durch Outlook ersetzt wurde, wurden ECEs zum Erweitern von Outlook 97-98 verwendet, bis ECEs in Outlook 2000 durch COM-Add-Ins ersetzt wurden.

ECEs können weiter wie erwartet in Outlook 2007 und früher verwendet werden. In 32-Bit- und 64-Bit-Versionen von Outlook 2010 werden die ECEs jedoch nicht geladen. Ziehen Sie zum Neuentwerfen vorhandener ECE-Lösungen folgende Optionen in Betracht:

• Schreiben Sie ECEs neu als COM-Add-Ins, indem Sie systemeigenen oder verwalteten Code verwenden. Im Gegensatz zu ECEs stellt ein Add-In eine strategische Erweiterbarkeitstechnologie dar, die in Outlook 2010 vollständig unterstützt wird. Mithilfe eines Outlook-Add-Ins können Sie Outlook-Formularbereiche erstellen und die Office Fluent-Benutzeroberfläche erweitern. Weitere Informationen finden Sie unter Erstellen eines Outlook 2007-Formularbereichs mit einem verwalteten Add-In, im Entwicklercenter für die Office Fluent-Benutzeroberfläche und im Outlook Developer Center auf MSDN.

• Schreiben Sie die ECE neu als Windows-Anwendung, indem Sie systemeigenen Code und MAPI verwenden. Wenn Sie eine Windows-Dienstanwendung schreiben, müssen Sie MAPI anstelle des Outlook-Objektmodells für den Zugriff auf Outlook-Elemente verwenden.

CDO 1.21 für Outlook 2010 nicht unterstützt

Datenobjekte für die Zusammenarbeit (Collaboration Data Objects (CDO) 1.2.1) ist eine Clientbibliothek, mit der über erweiterte MAPI-Funktionalität ein kompakter Wrapper bereitgestellt wird. CDO wird nicht zusammen mit Outlook 2010 installiert und steht nur als Download zur Verfügung. Weitere Informationen finden Sie unter Datenobjekte für die Zusammenarbeit (Collaboration Data Objects), Version 1.2.1 im Microsoft Download Center. CDO kann nicht zwangsläufig in einer Umgebung mit mehreren Exchange-Konten einwandfrei verwendet werden. CDO 1.2.1 ist eine 32-Bit-Clientbibliothek und kann nicht für 64-Bit-Versionen von Outlook 2010 verwendet werden. Daher wird die Verwendung von CDO 1.2.1 in Outlook 2010 nicht unterstützt. Der größte Teil der CDO 1.2.1-Funktionalität wurde in das Outlook 2010-Objektmodell integriert. Als Alternative zu CDO 1.2.1 können Sie vorhandene Lösungen, für die CDO benötigt wird, so aktualisieren, dass das Outlook-Objektmodell verwendet wird, oder MAPI direkt verwenden.

Mehrere Exchange-Konten

Eines der wichtigen neuen Features in Outlook 2010 ist die Möglichkeit zum Ausführen mehrerer Exchange-Konten. Das Outlook-Objektmodell wurde ursprünglich für ein einziges Exchange-Konto pro Profil entworfen. In Outlook 2007 stehen einem Exchange-Konto zugeordnete Eigenschaften und Methoden im Namespace-Objekt zur Verfügung. Zur Unterstützung mehrerer Exchange-Konten werden vom Account-Objekt jetzt verschiedene neue Eigenschaften und Methoden verfügbar gemacht. Eigenschaften wie beispielsweise ExchangeMailboxServerName, ExchangeMailboxServerVersion und ExchangeConnectionMode gelten noch für das Namespace-Objekt, geben jedoch Werte zurück, die nur für das primäre Exchange-Konto gelten. Für Exchange-Eigenschaften, die sich auf alle Exchange-Konten in einem Profil beziehen, verwenden Sie das Account-Objekt. In der folgenden Tabelle werden die Eigenschaften und Methoden aufgeführt, die dem Account-Objekt in Outlook 2010 hinzugefügt wurden, um mehrere Exchange-Konten zu unterstützen.

Tabelle 6. Dem Account-Objekt hinzugefügte Member

Aufzählen von Konten in einem Profil

Die folgende EnumerateAccounts-Funktion ist ein einfaches Beispiel für die Verwendung der neuen Eigenschaften für das Account-Objekt.

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);
            }
        }
    }

Erstellen eines versendbaren Elements und Festlegen des Felds "Von"

Eine der am häufigsten verwendeten Methoden im Outlook-Objektmodell ist die CreateItem-Methode für das Application-Objekt. Diese Methode verfügt nicht über Informationen zu mehreren Konten, und das Element wird immer für das primäre Konto im Profil erstellt. Wenn Sie ein versendbares Element erstellen möchten, das "weiß", welches Konto einem bestimmten Ordner zugeordnet ist, müssen Sie die Store-Eigenschaft des aktuellen Ordners ermitteln und dann die Accounts-Auflistung aufzählen, um zu ermitteln, ob das DeliveryStore-Objekt für ein bestimmtes Konto der Store-Eigenschaft des aktuellen Ordners entspricht. Wenn Sie das richtige Account-Objekt für die Store-Eigenschaft des aktuellen Ordners ermittelt haben, können Sie die Sender-Eigenschaft eines MailItem-Objekts oder die SendUsingAccount-Eigenschaft eines AppointmentItem-Objekts verwenden. Anhand der Funktionen CreateMailItemUsingAccount und CreateMeetingRequestUsingAccount wird gezeigt, wie Sie diese Funktionalität in einem Szenario mit mehreren Konten behandeln.

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);
    }

Ermitteln der globalen Adressliste für einen Exchange-Speicher

Wenn in einem Profil mehrere Exchange-Konten verfügbar sind, können Sie die AddressLists-Eigenschaften für ein bestimmtes Store-Objekt aufzählen oder die globale Adressliste (Global Address List, GAL) für einen bestimmten Exchange-Speicher ermitteln. Im folgenden Codebeispiel wird ein AddressList-Objekt zurückgegeben, das die GAL für das Store-Objekt darstellt, das der GetGlobalAddressList-Funktion übergeben wurde. Sie können die GetGlobalAddressList-Funktion im Codebeispiel verwenden, um ein AddressList-Objekt zurückzugeben, das die GAL für die Store-Eigenschaft von ActiveExplorer().CurrentFolder darstellt. Anhand des Beispielcodes können Sie das systemeigene Verhalten von Outlook in einer Umgebung mit mehreren Exchange-Konten duplizieren. Wenn der Benutzer auf Neue E-Mail-Nachricht klickt, wird im Dialogfeld des Outlook-Adressbuchs als erste Adressliste die globale Adressliste für das Store-Objekt des aktuellen Ordners angezeigt, sofern der Speicher der Übermittlungsspeicher für ein Exchange-Konto ist. Verwenden Sie die Funktionen DisplayGlobalAddressListForStore und GetGlobalAddressList, um das Verhalten programmatisch zu duplizieren.

        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;
        }

Aufzählen von AddressList-Objekten für einen Übermittlungsspeicher

Im nächsten Codebeispiel wird eine Eigenschaft in Outlook 2010 verwendet, die als eindeutiger Bezeichner für Store- und AddressList-Objekte dient. Diese Eigenschaft, die im folgenden Codebeispiel den Namen PR_EMSMDB_SECTION_UID hat, wird verwendet, um zu bewerten, ob ein bestimmtes AddressList-Objekt zu einem bestimmten Store-Objekt gehört. Das Store-Objekt muss einen Übermittlungsspeicher darstellen. Wenn mehrere Exchange-Konten vorhanden sind, wird ein Store-Objekt als Übermittlungsspeicher für ein bestimmtes Exchange-Konto verwendet. Mit der EnumerateAddressListsForStore-Funktion werden die Adresslisten für ActiveExplorer().CurrentFolder.Store aufgezählt.

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;
        }

Schlussbemerkung

Outlook 2010 hält interessante Herausforderungen für Sie als Entwickler bereit. Sie können die Benutzeroberfläche einer Lösung verbessern, um diese nahtlos in die neue Benutzeroberfläche von Outlook 2010 zu integrieren. Wenn Sie in der Lösung benutzerdefinierte Ordner zum Speichern von Informationen verwenden, können Sie mithilfe des neuen Lösungsmoduls und benutzerdefinierter Ordnersymbole die Auffindbarkeit verbessern. Der Code sollte mehrere Exchange-Konten unterstützen und die Änderungen im Objektmodell nutzen, die aus den leistungsstarken neuen Features in Outlook 2010 (beispielsweise Unterhaltungsansichten und Elementauswahl) hervorgegangen sind. Schließlich ergeben sich durch die Änderungen an der Plattform (beispielsweise die Unterstützung für 32-Bit- und 64-Bit-Versionen von Outlook) weitere Änderungen und eine höhere Komplexität, insbesondere für erweiterte Anwendungen, die auf MAPI-Ebene geschrieben wurden.

Weitere Ressourcen

MAPI

Welcome to the Outlook 2010 MAPI Reference

Outlook 2010: MAPI-Headerdateien

Beispiele für die Outlook 2010-Messaging-API (MAPI)

SGriffin's MAPI Internals

Erweiterbarkeit der Office Fluent-Benutzeroberfläche

Anpassen von Kontextmenüs in Office 2010

Einführung in die Office 2010-Backstage-Ansicht für Entwickler

Erweiterbarkeit des Menübands in Office 2010: Registerkartenaktivierung und Automatische Skalierung

Schema der Microsoft Office 2010 Fluent-Benutzeroberfläche

Steuerelement-IDs der Microsoft Office 2010 Fluent-Benutzeroberfläche