Anfügen einer Datei an eine Outlook-E-Mail-Nachricht

Artikel
04/07/2023

In diesem Artikel wird das programmgesteuerte Anfügen einer oder mehrerer Dateien an eine ausgehende E-Mail-Nachricht in Microsoft Outlook erläutert.

Bereitgestellt von: Ken Getz, MCW Technologies, LLC

Objektmodellunterstützung für Anlagen

In Outlook unterstützt die Attachments-Eigenschaft des MailItem-Objekts das Anfügen einer oder mehrerer Dateien an eine E-Mail-Nachricht. Zum Anfügen einer oder mehrerer Dateien an eine E-Mail-Element müssen Sie vor dem Senden des Elements die Add(Object, Object, Object, Object)-Methode des Attachments-Objekts für jede Anlagendatei aufrufen. Mit der Add-Methode können Sie den Dateinamen (der ParameterSource) und den Anlagentyp (theType-Parameter) mithilfe der OlAttachmentType-Enumeration angeben. Geben Sie für Dateien im Dateisystem den ParameterType als aufgezählten Outlook.olAttachmentType.olByValue-Wert an.

Hinweis Seit Microsoft Office Outlook 2007 würden Sie diesen Wert immer verwenden, um eine Kopie einer Datei im Dateisystem anzufügen. Outlook.olAttachmentType.olByReference wird nicht mehr unterstützt.

Wenn Sie eine E-Mail im Rich-Text-Format (RTF) senden, können Sie beim Aufrufen der Add-Methode auch zwei weitere optionale Parameter angeben: Position undDisplayName. Mit dem ParameterPosition können Sie die Position innerhalb der E-Mail angeben, an der die Anlage angezeigt werden soll. Verwenden Sie einen der folgenden Werte für den ParameterPosition:

Mit dem Wert 0 wird die Anlage im E-Mail-Text ausgeblendet.
Mit dem Wert 1 wird die Anlage vor dem ersten Zeichen platziert.
Mit einer Zahl, die größer als die Anzahl der Zeichen im E-Mail-Text ist, wird die Anlage am Ende des E-Mail-Texts platziert.

Für RTF-E-Mail-Nachrichten können Sie auch den Parameter DisplayName angeben, der den Namen bereitstellt, der im Nachrichtentext für die Anlage angezeigt wird. Bei Nur-Text- oder HTML-E-Mail-Nachrichten zeigt die Anlage nur den Namen der Datei an.

Senden einer Nachricht mit Dateien als Anlagen

Die SendEmailWithAttachments Beispielprozedur im Codebeispiel weiter unten in diesem Thema akzeptiert Folgendes:

Ein Verweis auf das Outlook Application-Objekt .
Zeichenfolgen, die den Betreff und den Text der Nachricht enthalten
Eine generische Liste von Zeichenfolgen mit einer Liste der SMTP-Adressen für Empfänger der Nachricht
Eine Zeichenfolge mit der SMTP-Adresse des Absenders
Eine generische Zeichenfolge mit den Pfaden zu den Dateien, die angefügt werden sollen

Nach dem Erstellen eines neuen E-Mail-Elements fügt der Code jeden Empfänger der Recipients-Auflistungseigenschaft des E-Mail-Elements hinzu. Beim Aufrufen der ResolveAll()-Methode durch den Code werden die Subject- und Body-Eigenschaften des E-Mail-Elements vor der Ausführung der Schleife für jedes Element in der angegebenen Liste der Anlagenpfade festgelegt, indem jedes Element zur Attachments-Eigenschaft des E-Mail-Elements hinzugefügt wird.

Vor dem Senden der E-Mail müssen Sie das Konto angeben, von dem die E-Mail-Nachricht gesendet werden soll. Eine Methode für die Suche nach dieser Information stellt die Verwendung der SMTP-Adresse des Absenders. Die GetAccountForEmailAddress Funktion akzeptiert eine Zeichenfolge, die die SMTP-E-Mail-Adresse des Absenders enthält, und gibt einen Verweis für das entsprechende Account-Objekt zurück. Diese Methode vergleicht die SMTP-Adresse des Absenders mit der SmtpAddress-Eigenschaft für jedes für das Sitzungsprofil konfigurierte E-Mail-Konto. application.Session.Accounts gibt eine Accounts-Auflistung für das aktuelle Profil zurück und verfolgt Informationen für alle Konten einschließlich Exchange-, IMAP- und POP3-Konten, wobei jedes mit einem anderen Zustellungsspeicher verknüpft sein kann. Das Account-Objekt, mit dem ein mit der SMTP-Adresse des Absenders übereinstimmender SmtpAddress-Eigenschaftswert verknüpft ist, stellt das Konto dar, aus dem die E-Mail-Nachricht gesendet wird.

Nach dem Identifizieren des entsprechenden Kontos wird der Code abgeschlossen, indem die SendUsingAccount-Eigenschaft des E-Mail-Elements auf dieses Account-Objekt festgelegt und dann die Send()- Methode aufgerufen wird.

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).

Der folgende Code veranschaulicht das programmgesteuerte Anfügen von Dateien an eine ausgehende E-Mail-Nachricht in Outlook. Um diese Funktionalität zu veranschaulichen, erstellen Sie in Visual Studio ein neues verwaltetes Outlook-Add-In namens AttachFileAddIn, und ersetzen Sie den Inhalt der Datei ThisAddIn.vb oder ThisAddIn.cs durch den hier gezeigten Beispielcode. Ändern Sie die ThisAddIn_Startup Prozedur, um einen Verweis auf eine Datei in Ihr Dateisystem einzuschließen, und aktualisieren Sie die E-Mail-Adressen entsprechend. Die im Aufruf der SendMailWithAttachments-Vorgehensweise enthaltene SMTP-Adresse muss der SMTP-Adresse eines der ausgehenden E-Mail-Konten entsprechen, die Sie zuvor in Outlook konfiguriert haben.

using System.Collections.Generic;
using Outlook = Microsoft.Office.Interop.Outlook;
 
namespace AttachFileAddIn
{
    public partial class ThisAddIn
    {
        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            List<string> attachments = new List<string>();
            attachments.Add("c:\\somefile.txt");
 
            List<string> recipients = new List<string>();
            recipients.Add("john@contoso.com");
            recipients.Add("john@example.com");
            SendEmailWithAttachments(Application, "Test", "Body", recipients, "john@example.com", 
              attachments);
        }
 
        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {
        }
 
        private void SendEmailWithAttachments(Outlook.Application application, 
            string subject, string body, List<string> recipients, 
            string smtpAddress, List<string> attachments)
        {
 
            // Create a new MailItem and set the To, Subject, and Body properties.
            var newMail = application.CreateItem(Outlook.OlItemType.olMailItem) as Outlook.MailItem;
 
            // Set up all the recipients.
            foreach (var recipient in recipients)
            {
                newMail.Recipients.Add(recipient);
            }
            if (newMail.Recipients.ResolveAll())
            {
                newMail.Subject = subject;
                newMail.Body = body;
                foreach (string attachment in attachments)
                {
                    newMail.Attachments.Add(attachment, Outlook.OlAttachmentType.olByValue);
                }
            }
 
            // Retrieve the account that has the specific SMTP address.
            Outlook.Account account = GetAccountForEmailAddress(application, smtpAddress);
            // Use this account to send the email.
            newMail.SendUsingAccount = account;
            newMail.Send();
        }
 
        private Outlook.Account GetAccountForEmailAddress(Outlook.Application application, 
            string smtpAddress)
        {
 
            // Loop over the Accounts collection of the current Outlook session.
            Outlook.Accounts accounts = application.Session.Accounts;
            foreach (Outlook.Account account in accounts)
            {
                // When the email address matches, return the account.
                if (account.SmtpAddress == smtpAddress)
                {
                    return account;
                }
            }
            // If you get here, no matching account was found.
            throw new System.Exception(string.Format("No Account with SmtpAddress: {0} exists!", 
                smtpAddress));
        }
 
        #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
        Dim attachments As New List(Of String)
        attachments.Add("c:\somefile.txt")
 
        Dim recipients As New List(Of String)
        recipients.Add("john@contoso.com")
        recipients.Add("john@example.com")
        SendEmailWithAttachments(Application, "Test", "Body", recipients, "john@contoso.com", attachments)
    End Sub
 
    Private Sub ThisAddIn_Shutdown() Handles Me.Shutdown
 
    End Sub
 
    Private Sub SendEmailWithAttachments(ByVal application As Outlook.Application, _
        ByVal subject As String, ByVal body As String,
        ByVal recipients As List(Of String),
        ByVal smtpAddress As String,
        ByVal attachments As List(Of String))
 
        ' Create a new MailItem and set the To, Subject, and Body properties.
        Dim newMail As Outlook.MailItem =
            DirectCast(application.CreateItem(Outlook.OlItemType.olMailItem), 
            Outlook.MailItem)
 
        ' Set up all the recipients.
        For Each recipient In recipients
            newMail.Recipients.Add(recipient)
        Next
        If newMail.Recipients.ResolveAll() Then
            newMail.Subject = subject
            newMail.Body = body
            For Each attachment As String In attachments
                newMail.Attachments.Add(attachment, Outlook.OlAttachmentType.olByValue)
            Next
        End If
 
        ' Retrieve the account that has the specific SMTP address.
        Dim account As Outlook.Account = GetAccountForEmailAddress(application, smtpAddress)
        ' Use this account to send the email.
        newMail.SendUsingAccount = account
        newMail.Send()
    End Sub
 
   
    Private Function GetAccountForEmailAddress(
        ByVal application As Outlook.Application,
        ByVal smtpAddress As String) As Outlook.Account
 
        ' Loop over the Accounts collection of the current Outlook session.
        Dim accounts As Outlook.Accounts = application.Session.Accounts
        For Each account In accounts
            ' When the email address matches, return the account.
            If account.SmtpAddress = smtpAddress Then
                Return account
            End If
        Next
        ' If you get here, no matching account was found.
        Throw New System.Exception(
            String.Format("No Account with SmtpAddress: {0} exists!", smtpAddress))
    End Function
End Class

Siehe auch

Anfügen eines Outlook-Kontaktelements an eine Email Nachricht Einschränken der Größe einer Anlage an eine Outlook Email Nachricht Ändern einer Anlage einer Outlook-Email-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.