Verwalten von Nachrichtenanhängen

Verwalten von Anhängen in Outlook

Erstellen und Speichern von Outlook‑Nachrichten (MSG)‑Dateien erklärt, wie Nachrichten erstellt und gespeichert werden und wie MSG‑Dateien mit Anhängen erstellt werden. Dieser Artikel erklärt, wie Microsoft‑Outlook‑Anhänge mit Aspose.Email verwaltet werden. Anhänge aus einer Nachrichten‑Datei werden über die MapiMessage Klasse Anhänge Eigenschaft. Die Anhänge Eigenschaft ist eine Sammlung vom Typ MapiAttachmentCollection Klasse.

Anhangstyp prüfen (Inline oder regulär)

Inline‑ und reguläre Anhänge dienen unterschiedlichen Zwecken. Inline‑Anhänge sind visuell in die E‑Mail‑Nachricht integriert und sind typischerweise Bilder oder Mediendateien. Reguläre Anhänge sind hingegen separate Dateien, die an die E‑Mail angehängt werden und verschiedene Dateitypen enthalten können. Der MapiAttachment.IsInline Eigenschaft des MapiAttachment Klasse erhält einen Wert, der angibt, ob der Anhang inline oder regulär ist.

Das folgende Codebeispiel extrahiert und zeigt Informationen zu jedem Anhang in der geladenen MapiMessage an, einschließlich ihrer Anzeigenamen und ob es sich um Inline‑Anhänge handelt oder nicht.

var message = MapiMessage.Load(fileName);

foreach (var attach in message.Attachments)
{
    Console.WriteLine($"{attach.DisplayName} : {attach.IsInline}");
}

Anhangstyp prüfen (IsReference)

Die MapiAttachment Klasse enthält die IsReference Eigenschaft, die es Entwicklern ermöglicht, Referenzanhänge in einer Nachricht zu identifizieren. Mit dem folgenden Codebeispiel können Sie prüfen, ob ein Anhang ein Referenzanhang ist:

foreach (var attachment in msg.Attachments)
{
    if (attachment.IsReference)
    {
        // Process reference attachment
    }
}

Anhänge aus MSG‑Dateien speichern

Um Anhänge aus einer MSG‑Datei zu speichern:

Iterieren Sie durch die MapiAttachmentCollection Sammlung auf und holen Sie die einzelnen Anhänge.
Um die Anhänge zu speichern, rufen Sie die Save()-Methode der MapiAttachment‑Klasse auf.

Das folgende Code‑Snippet zeigt, wie Anhänge auf der lokalen Festplatte gespeichert werden.

// Create an instance of MapiMessage from file
MapiMessage message = MapiMessage.FromFile(dataDir + fileName);

// Iterate through the attachments collection
foreach (MapiAttachment attachment in message.Attachments)
{
    // Save the individual attachment
    attachment.Save(dataDir + attachment.FileName);
}

Anhänge aus RTF‑formatierten MSG‑Dateien extrahieren

Für als RTF formatierte Nachrichten kann der folgende Code verwendet werden, um Anhänge zu unterscheiden und zu extrahieren, die entweder Inline sind oder als Symbol im Nachrichtenkörper erscheinen. Das folgende Code‑Snippet zeigt, wie ein eingebetteter Anhang aus einer als RTF formatierten MSG‑Datei identifiziert und extrahiert wird.


var eml = MapiMessage.Load("MSG file with RTF Formatting.msg");

foreach (var attachment in eml.Attachments)
{
    if (IsAttachmentInline(attachment))
    {
        try
        {
            SaveAttachment(attachment, Guid.NewGuid().ToString());
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

static bool IsAttachmentInline(MapiAttachment attachment)
{
    foreach (var property in attachment.ObjectData.Properties.Values)
    {
        if (property.Name == "\x0003ObjInfo")
        {
            var odtPersist1 = BitConverter.ToUInt16(property.Data, 0);
            return (odtPersist1 & (1 << (7 - 1))) == 0;
        }
    }
    return false;
}

static void SaveAttachment(MapiAttachment attachment, string fileName)
{
    foreach (var property in attachment.ObjectData.Properties.Values)
    {
        if (property.Name == "Package")
        {
            using var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
            fs.Write(property.Data, 0, property.Data.Length);
        }
    }
}

Verschachtelte Mail‑Nachrichtenanhänge erhalten

Eingbettete OLE‑Anhänge erscheinen auch in der MapiMessage Klasse Attachment‑Sammlung. Das folgende Codebeispiel analysiert eine Nachrichten‑Datei nach eingebetteten Nachrichtenanhängen und speichert sie auf dem Datenträger. Die MapiMessage Die statische Methode FromProperties() der Klasse kann eine neue Nachricht aus einem eingebetteten Anhang erstellen. Das folgende Code‑Snippet zeigt, wie verschachtelte Mail‑Nachrichtenanhänge abgerufen werden.

// Create a MapiMessage object from the individual attachment
MapiMessage getAttachment = MapiMessage.FromProperties(attachment.ObjectData.Properties);

// Convert the embedded message to a MailMessage and save it to disk
MailMessage mailMessage = getAttachment.ToMailMessage(new MailConversionOptions());
mailMessage.Save(dataDir + @"NestedMailMessageAttachments_out.eml", SaveOptions.DefaultEml);

Anhänge entfernen

Die Aspose‑Outlook‑Bibliothek bietet die Möglichkeit, Anhänge aus Microsoft Outlook‑Nachrichten (.msg)-Dateien zu entfernen:

Rufen Sie die Methode RemoveAttachments() auf. Sie erhält den Pfad der Nachrichten‑Datei als Parameter. Sie ist als öffentliche statische Methode implementiert, sodass Sie kein Objekt instanziieren müssen.

Das folgende Code‑Snippet zeigt, wie Sie Anhänge entfernen.

MapiMessage.RemoveAttachments(dataDir + "AttachmentsToRemove_out.msg");

Sie können auch die MapiMessage Klassen‑statische Methode DestroyAttachments(). Sie arbeitet schneller als RemoveAttachments(), weil die Methode RemoveAttachments() die Nachrichtendatei analysiert.

MapiMessage.DestroyAttachments(dataDir + "AttachmentsToDestroy_out.msg");

MSG‑Anhänge hinzufügen

Eine Outlook‑Nachricht kann andere Microsoft‑Outlook‑Nachrichten als Anhänge enthalten, entweder als reguläre oder eingebettete Nachrichten. Die MapiAttachmentCollection stellt überladene Mitglieder von Add Methode zum Erstellen von Outlook‑Nachrichten mit beiden Anhangtypen:

Add(string name, byte[] data) – fügt einen regulären Anhang aus einem Byte‑Array hinzu.
Add(string name, MapiMessage message) – fügt eine weitere Outlook‑Nachricht als eingebettete Nachricht hinzu.

Das folgende Code‑Snippet zeigt, wie Sie beiden Arten von Anhängen zu einer Nachricht hinzufügen.

MapiMessage message = new MapiMessage("from@test.com", "to@test.com", "Subj", "This is a message body");

// Add a regular attachment from a byte array
message.Attachments.Add("note.txt", File.ReadAllBytes(dataDir + "note.txt"));

// Add another Outlook message as an embedded message
MapiMessage attachMsg = MapiMessage.FromFile(dataDir + "Message.msg");
message.Attachments.Add("Weekly report.msg", attachMsg);

message.Save(dataDir + "WithAttachments_out.msg");

Probieren Sie es aus!

E‑Mail‑Anhänge hinzufügen oder entfernen mit dem kostenlosen Aspose.Email Editor App.

Referenzanhänge zu MapiMessages hinzufügen

Die ReferenceAttachmentOptions Klasse vereinfacht das Hinzufügen von Referenzanhängen, indem sie alle notwendigen Eigenschaften in einem einzigen Objekt kapselt.

Parameter von ReferenceAttachmentOptions:

sharedLink: Ein vollständig qualifizierter Shared‑Link zum Anhang, bereitgestellt vom Web‑Service, der die Datei hostet.
url: Der Dateistandort oder die Ressourcen‑URL.
providerName: Der Name des Referenzanhangs‑Anbieters (z. B. Google Drive, Dropbox).
Beispiel: Hinzufügen eines Referenzanhangs mit ReferenceAttachmentOptions

var options = new ReferenceAttachmentOptions(
    "https://drive.google.com/file/d/1HJ-M3F2qq1oRrTZ2GZhUdErJNy2CT3DF/",
    "https://drive.google.com/drive/my-drive",
    "GoogleDrive");

// Add reference attachment
msg.Attachments.Add("Document.pdf", options);

Nachrichten als Anhänge einbetten

Das folgende Code‑Snippet zeigt, wie ein MSG‑Dateianhang in eine Nachricht eingebettet wird.

MapiMessage message = new MapiMessage("from@test.com", "to@test.com", "Subj", "This is a message body");
MapiMessage attachMsg = MapiMessage.FromFile(dataDir + "Message.msg");
message.Attachments.Add("Weekly report.msg", attachMsg);
message.Save(dataDir + "WithEmbeddedMsg_out.msg");

Eingebettete Nachrichten aus Anhängen lesen

Das folgende Code‑Snippet zeigt, wie eingebettete Nachrichten aus Anhängen gelesen werden.

var message = MapiMessage.FromFile(fileName);
if (message.Attachments[0].ObjectData.IsOutlookMessage)
{
    var getData = message.Attachments[0].ObjectData.ToMapiMessage();
}

Einfügen und Ersetzen von Anhängen

Die Aspose.Email‑API ermöglicht das Einfügen von Anhängen an einem bestimmten Index in die übergeordnete Nachricht. Sie bietet außerdem die Möglichkeit, den Inhalt eines Anhangs durch einen anderen Nachrichten‑Anhang zu ersetzen.

Probieren Sie es aus!

Führen Sie das ReplaceAttach einfaches App‑Projekt und testen Sie die Aspose.Email‑Funktionen, um Anhänge in der Praxis zu ersetzen.

Anhänge an bestimmten Positionen einfügen

Die Aspose.Email‑API bietet die Möglichkeit, einen MSG‑Anhang in eine übergeordnete MSG mithilfe der Insert‑Methode der MapiAttachmentCollection (MapiAttachmentCollection Insert(int index, string name, MapiMessage msg)) einzufügen. Das folgende Code‑Snippet zeigt, wie ein Anhang an einer bestimmten Position eingefügt wird.

var message = MapiMessage.FromFile(fileName);
var memoryStream = new MemoryStream();
message.Attachments[2].Save(memoryStream);
           
var getData = MapiMessage.FromStream(memoryStream);
message.Attachments.Insert(1, "new 11", getData);

Anhangsinhalte ersetzen

Damit können Sie Inhalte eingebetteter Anhänge mit neuen Inhalten über die Replace‑Methode ersetzen. Sie kann jedoch nicht verwendet werden, um einen Anhang mit PR_ATTACH_NUM = 4 (zum Beispiel) in eine Auflistung einzufügen, deren collection.Count = 2 ist. Das folgende Code‑Snippet zeigt, wie man Anhangsinhalte ersetzt.

var message = MapiMessage.FromFile(fileName);
var memoryStream = new MemoryStream();
message.Attachments[2].Save(memoryStream);
var getData = MapiMessage.FromStream(memoryStream);
message.Attachments.Replace(1, "new 1", getData);

Anhänge in MapiMessage umbenennen

Es ist möglich, den Wert der DisplayName‑Eigenschaft in MapiMessage‑Anhängen zu bearbeiten.

var msg = MapiMessage.Load(fileName);
msg.Attachments[0].DisplayName = "New display name 1";
msg.Attachments[1].DisplayName = "New display name 2";

Anhänge aus digital signierten Nachrichten speichern

Die Aspose.Email‑API bietet die Möglichkeit, einen Wert zu erhalten oder zu setzen, der angibt, ob eine klar signierte Nachricht dekodiert wird.

Extrahiere eingebettete OLE‑Objekte aus oledata.mso

Manchmal werden eingebettete OLE‑Daten als ein oledata.mso Anhang in einem MapiAttachment und muss manuell extrahiert werden. Diese oledata.mso Dateien im Microsoft Compound Document File (MCDF)‑Format bereit, und die Unterstützung solcher Dateien liegt außerhalb des Geltungsbereichs von Aspose.Email. Allerdings kann Aspose.Email in Kombination mit anderen Open‑Source‑Bibliotheken verwendet werden, wie zum Beispiel OpenMCDF, um den Inhalt dieser Dateien zu lesen und auf die Festplatte zu speichern. Aspose.Email stellt die InlineAttachmentExtractor Klasse zum Aufzählen der MSO‑Pakete, die in den Binärdaten von oledata.mso, die dann an eine Bibliothek zum Lesen von Compound‑Files übergeben werden können, um den Inhalt zu extrahieren.

Wenn ein Nachrichten‑Body‑Typ HTML (nicht RTF) ist und OLE‑Objekte in der Nachricht enthalten sind, die MapiPropertyTag.PR_ATTACH_DATA_OBJ Eigenschaft fehlt. In diesem Fall sind die Informationen über die OLE‑Objekte in oledata.mso.

Um den Inhalt mit Aspose.Email und OpenMCDF zu extrahieren:

Zählen Sie die MSO‑Pakete aus den Binärdaten des oledata.mso Anhang.
Für jedes OLE‑Element lesen Sie die zusammengesetzte Datei.
Lesen Sie den Stream mit dem Namen CONTENTS.
Speichern Sie den Inhalt in einer FileStream.

// The path to the File directory
string dataDir = RunExamples.GetDataDir_Email();

MapiMessage msg = MapiMessage.FromFile(dataDir + "double.msg");
foreach (MapiAttachment mapiAttachment in msg.Attachments)
{
    if (mapiAttachment.LongFileName == "oledata.mso")
    {
        IDictionary<string, byte[]> oledata = InlineAttachmentExtractor.EnumerateMsoPackage(new MemoryStream(mapiAttachment.BinaryData));
        int index = 0;
        foreach (var oleItem in oledata)
        {
            // Using the OpenMCDF library
            CompoundFile cf = new CompoundFile(new MemoryStream(oleItem.Value));
            CFStream contents = cf.RootStorage.GetStream("CONTENTS");
            using (FileStream fs = File.OpenWrite(index + ".pdf"))
            {
                byte[] data = contents.GetData();
                fs.Write(data, 0, data.Length);
                fs.Flush();
                fs.Close();
            }
            index++;
        }
    }
}

Arbeiten mit MAPI‑Eigenschaften Verwaltung von Outlook‑Kontakten