Ändern einer Anlage einer Outlook-E-Mail

  • Artikel

In diesem Thema wird das programmgesteuerte Ändern einer Microsoft Outlook-E-Mail-Anlage ohne Änderung der ursprünglichen Datei beschrieben.

Bereitgestellt von: Ken Getz, MCW Technologies, LLC

Das Senden einer E-Mail-Nachricht mit einer oder mehreren Anlagen ist einfach, sowohl in der Outlook-Benutzeroberfläche als auch programmgesteuert. In einigen Szenarien möchten Sie jedoch die Anlage ändern können, nachdem sie an das E-Mail-Element angefügt wurde, ohne die ursprüngliche Datei im Dateisystem zu ändern. Anders ausgedrückt: Sie benötigen möglicherweise eine programmgesteuerte Möglichkeit, um auf den Inhalt der Anlage im Arbeitsspeicher zuzugreifen.

Stellen Sie sich beispielsweise vor, dass die Anwendung erfordert, dass der Text in allen Anlagen mit TXT-Dateierweiterung in Großbuchstaben geändert werden muss. In einem verwalteten Outlook-Add-In können Sie das ItemSend-Ereignis problemlos behandeln. Führen Sie in diesem Fall diese Aufgabe vor dem Senden des E-Mail-Elements durch. Den schwierigen Teil des Szenarios stellt das Abrufen der Anlageninhalte zum Ändern der Inhalte jeder einzelnen Textdatei

Der Beispielcode in diesem Thema veranschaulicht, wie sie dieses spezielle Problem mithilfe der Methoden GetProperty(String) und SetProperty(String, Object) der Attachment-Schnittstelle lösen. Geben Sie in jedem Fall einen Wert mit der MAPI-Eigenschaft PidTagAttachDataBinary, um die Inhalte der Anlage abzurufen (und dann festzulegen).

Hinweis Die Namespacedarstellung der PidTagAttachDataBinary-Eigenschaft ist https://schemas.microsoft.com/mapi/proptag/0x37010102. Weitere Informationen zur Verwendung des PropertyAccessor-Objekts für Eigenschaften, auf die vom Namespace verwiesen wird, finden Sie unter Verweisen auf Eigenschaften nach Namespace.

Das Codebeispiel veranschaulicht das ItemSend-Ereignis eines E-Mail-Elements. Im benutzerdefinierten Ereignishandler ruft der Code für jede Anlage mit einer .txt-Erweiterung die ConvertAttachmentToUpperCase -Methode auf. ConvertAttachmentToUpperCase akzeptiert ein Attachment-Objekt und ein MailItem-Objekt als Eingabeargumente, ruft ein Bytearray ab, das mit dem Inhalt der Anlage gefüllt ist, konvertiert das Bytearray in eine Zeichenfolge, konvertiert die Zeichenfolge in Großbuchstaben und legt dann den Inhalt der Anlage auf die konvertierte Zeichenfolge als Bytearray fest.

Die folgenden Beispiele für verwalteten Code sind in C# und Visual Basic geschrieben. Um ein verwaltetes Codebeispiel von .NET Framework auszuführen, das ein Component Object Model (COM) aufrufen muss, müssen Sie eine Interopassembly verwenden, die verwaltete Schnittstellen definiert und den COM-Objekten in der Object Model-Typbibliothek zuordnet. Für Outlook können Sie Visual Studio und die Outlook Primary Interop Assembly (PIA) verwenden. Stellen Sie sicher, dass Sie die Outlook 2013 PIA installiert und eine Referenz zur Microsoft Outlook 15.0-Objektbibliothekkomponente in Visual Studio hinzugefügt haben, bevor Sie verwaltete Codebeispiele für Outlook 2013 ausführen.

Sie sollten die folgenden Codebeispiele in der ThisAddIn Klasse eines Outlook-Add-Ins (mit Office Developer Tools für Visual Studio) verwenden. Das Objekt der Anwendung im Code muss ein vertrauenswürdiges Outlook- Anwendungsobjekt sein, das von ThisAddIn.Globals bereitgestellt wird. Weitere Informationen zur Verwendung der Outlook-PIA zur Entwicklung verwalteter Outlook-Lösungen finden Sie auf MSDN unter Willkommen bei der Referenz zur primären Interopassembly von Outlook (PIA).

In folgendem Code wird das programmgesteuerte Ändern einer Outlook-E-Mail-Anlage ohne Änderung der ursprünglichen Datei veranschaulicht. Um diese Funktionalität zu veranschaulichen, erstellen Sie in Visual Studio ein neues verwaltetes Outlook-Add-In namens ModifyAttachmentAddIn. Ersetzen Sie den Code in ThisAddIn.cs oder ThisAddIn.vb durch den folgenden Code.

Hinweis Für den Zugriff auf die Anlagendaten muss das E-Mail-Element mithilfe der MailItem.Save-Methode gespeichert werden.

using Outlook = Microsoft.Office.Interop.Outlook;
 
namespace ModifyAttachmentAddIn
{
    public partial class ThisAddIn
    {
        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            Application.ItemSend += new Outlook.ApplicationEvents_11_ItemSendEventHandler(Application_ItemSend);
        }
 
        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {
        }
 
 
        void Application_ItemSend(object Item, ref bool Cancel)
        {
            Outlook.MailItem mailItem = Item as Outlook.MailItem;
 
            if (mailItem != null)
            {
                var attachments = mailItem.Attachments;
                // If the attachment a text file, convert its text to all uppercase.
                foreach (Outlook.Attachment attachment in attachments)
                {

                    ConvertAttachmentToUpperCase(attachment, mailItem);
                }
            }
        }
 
        private void ConvertAttachmentToUpperCase(Outlook.Attachment attachment, Outlook.MailItem mailItem)
        {
            const string PR_ATTACH_DATA_BIN =
                "https://schemas.microsoft.com/mapi/proptag/0x37010102";
 
            // Confirm that the attachment is a text file.
            if (System.IO.Path.GetExtension(attachment.FileName) == ".txt")
            {
                // There are other heuristics you could use to determine whether the 
                // the attachment is a text file. For now, keep it simple: Only
                // run this code for *.txt.
 
                // Retrieve the attachment as an array of bytes.
                var attachmentData =
                    attachment.PropertyAccessor.GetProperty(
                    PR_ATTACH_DATA_BIN);
 
                // Convert the byte array into a Unicode string.
                string data = System.Text.Encoding.Unicode.GetString(attachmentData);
                // Convert to upper case.
                data = data.ToUpper();
                // Convert the data back to an array of bytes.
                attachmentData = System.Text.Encoding.Unicode.GetBytes(data);
 
                //Set PR_ATTACH_DATA_BIN to attachmentData.
                attachment.PropertyAccessor.SetProperty(PR_ATTACH_DATA_BIN,
                    attachmentData);
            }
        }
 
        #region VSTO generated code
 
        /// <summary>
        /// Required method for Designer support - don't modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisAddIn_Startup);
            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
        }
 
        #endregion
    }
}

Public Class ThisAddIn
 
 
    Private Sub ThisAddIn_Startup() Handles Me.Startup
 
    End Sub
 
    Private Sub ThisAddIn_Shutdown() Handles Me.Shutdown
 
    End Sub
 
    Private Sub Application_ItemSend(ByVal Item As Object, _
        ByRef Cancel As Boolean) Handles Application.ItemSend
 
        Dim mailItem As Outlook.MailItem = TryCast(Item, Outlook.MailItem)
 
        If mailItem IsNot Nothing Then
            Dim attachments = mailItem.Attachments
            For Each attachment As Outlook.Attachment In attachments
                ' If the attachment is a text file, convert to uppercase.
                ConvertAttachmentToUpperCase(attachment, mailItem)
            Next attachment
        End If
    End Sub
 
    Private Sub ConvertAttachmentToUpperCase(ByVal attachment As Outlook.Attachment, _
        ByVal mailItem As Outlook.MailItem)
        Const PR_ATTACH_DATA_BIN As String = "https://schemas.microsoft.com/mapi/proptag/0x37010102"
 
        ' Confirm that the attachment is a text file.
        If System.IO.Path.GetExtension(attachment.FileName) = ".txt" Then
 
            ' There are other heuristics you could use to determine whether the 
            ' the attachment is a text file. For now, keep it simple: Only
            ' run this code for *.txt.
 
            ' Retrieve the attachment as an array of bytes.
            Dim attachmentData = attachment.PropertyAccessor.GetProperty(PR_ATTACH_DATA_BIN)
 
            ' Convert the byte array into a Unicode string.
            Dim data As String = System.Text.Encoding.Unicode.GetString(attachmentData)
            ' Convert to upper case.
            data = data.ToUpper()
            ' Convert the data back to an array of bytes.
            attachmentData = System.Text.Encoding.Unicode.GetBytes(data)
 
            'Set PR_ATTACH_DATA_BIN to attachmentData.
            attachment.PropertyAccessor.SetProperty(PR_ATTACH_DATA_BIN, attachmentData)
         End If
    End Sub
 
End Class

Siehe auch

Anhängen einer Datei an eine E-Mail-Nachricht

Fügen Sie eine Outlook-Kontaktelements an eine E-Mail-Nachricht

Beschränken der Größe von einer Anlage zu einer Outlook-e-Mail-Nachricht

Support und Feedback

Haben Sie Fragen oder Feedback zu Office VBA oder zu dieser Dokumentation? Unter Office VBA-Support und Feedback finden Sie Hilfestellung zu den Möglichkeiten, wie Sie Support erhalten und Feedback abgeben können.