Einleitung

Die Arbeit mit Outlook‑MSG‑Dateien in C++ erforderte historisch Windows‑exklusive COM‑Automatisierung
oder schwere Drittanbieter‑Bibliotheken mit restriktiven Lizenzen. Aspose.Email FOSS for C++
ändert das: Es ist eine reine C++17‑Bibliothek ohne externe Abhängigkeiten, ohne COM und ohne
plattformabhängigen Code. Es wird identisch unter Linux, macOS und Windows gebaut.

Die Bibliothek wird unter der MIT-Lizenz veröffentlicht und als Quellcode über GitHub verteilt.
Sie integrieren sie, indem Sie das Repository klonen und es als CMake‑Unterverzeichnis hinzufügen — eine Registrierung bei einem Paketmanager ist nicht erforderlich, und es müssen keine Binärdateien vorab erstellt werden.

Dieser Beitrag führt durch den Kern‑Workflow: das Lesen einer bestehenden MSG‑Datei, das Untersuchen ihrer Eigenschaften, das programmgesteuerte Erstellen einer neuen Nachricht und die Rundumkonvertierung zwischen MSG‑ und EML‑Formaten.

Hauptmerkmale

Vorhandene MSG-Dateien lesen

Verwenden Sie msg_reader, um eine .msg‑Datei zu öffnen, und msg_document, um auf deren strukturierte Inhalte zuzugreifen.
Beide Klassen befinden sich im aspose::email::foss::msg‑Namespace.

#include "aspose/email/foss/msg/msg_reader.hpp"
#include "aspose/email/foss/msg/msg_document.hpp"
#include <filesystem>

namespace aef = aspose::email::foss;

auto reader   = aef::msg::msg_reader::from_file(std::filesystem::path("message.msg"));
auto document = aef::msg::msg_document::from_reader(reader);

msg_reader hat auch eine from_stream‑Überladung zum Lesen aus einem std::istream, die in serverseitigen oder Pipeline‑Kontexten nützlich ist, in denen Dateien nicht auf der Festplatte vorhanden sind.

Nachrichten programmgesteuert erstellen

mapi_message::create erzeugt eine neue In‑Memory‑Nachricht mit Betreff und Text.
Sie können dann Absenderdetails festlegen, Empfänger hinzufügen und binäre oder Text‑Payloads anhängen, bevor Sie speichern.

#include "aspose/email/foss/msg/mapi_message.hpp"

namespace aef = aspose::email::foss;

auto msg = aef::msg::mapi_message::create(
    "Quarterly status update",
    "Hello team,\n\nPlease find the rollout summary attached.\n\nRegards");

msg.set_sender_name("Build Agent");
msg.set_sender_email_address("build.agent@example.com");
msg.add_recipient("alice@example.com", "Alice Example");
msg.save(std::filesystem::path("output.msg"));

MSG in EML konvertieren

mapi_message unterstützt die direkte MSG-zu-EML-Konvertierung über die save_to_eml‑Methode.
EML‑Ausgabe entspricht RFC 5322 (MIME) und ist damit mit jedem Standard‑Mail
Client oder Verarbeitungspipeline kompatibel.

auto loaded = aef::msg::mapi_message::from_file(
    std::filesystem::path("message.msg"), /*strict=*/false);

// Save as EML to a file
loaded.save_to_eml(std::filesystem::path("message.eml"));

// Or capture as bytes
std::vector<std::uint8_t> eml_bytes = loaded.save_to_eml();

Aus EML laden

Die umgekehrte Richtung ist ebenso unkompliziert: load_from_eml liest eine EML‑Datei und erzeugt ein mapi_message im Speicher, das dann zurück in MSG gespeichert werden kann.

auto from_eml = aef::msg::mapi_message::load_from_eml(
    std::filesystem::path("message.eml"));

from_eml.save(std::filesystem::path("restored.msg"));

Low-Level CFB‑Zugriff

Für erweiterte Anwendungsfälle — wie das Lesen roher MAPI‑Eigenschaften, die von der High‑Level‑API nicht bereitgestellt werden — cfb_reader bietet direkten Zugriff auf den Compound‑File‑Binary‑Container, der dem MSG‑Format zugrunde liegt.

#include "aspose/email/foss/cfb/cfb_reader.hpp"

namespace aef = aspose::email::foss;

auto cfb = aef::cfb::cfb_reader::from_file(std::filesystem::path("message.msg"));
auto storage_ids = cfb.storage_ids();
auto stream_ids  = cfb.stream_ids();

Schnellstart

Schritt 1 — Klonen und als Unterverzeichnis hinzufügen

git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.git

In Ihrem Projekt CMakeLists.txt:

cmake_minimum_required(VERSION 3.26)
project(my_project)

add_subdirectory(Aspose.Email-FOSS-for-Cpp)

add_executable(my_app main.cpp)
target_link_libraries(my_app PRIVATE AsposeEmailFoss::AsposeEmailFoss)

Schritt 2 — Einbinden und Verwenden

#include <iostream>
#include "aspose/email/foss/msg/mapi_message.hpp"

namespace aef = aspose::email::foss;

int main()
{
    // Create a message
    auto msg = aef::msg::mapi_message::create("Hello from C++", "Body text here");
    msg.save(std::filesystem::path("hello.msg"));

    // Round-trip to EML
    auto loaded = aef::msg::mapi_message::from_file(
        std::filesystem::path("hello.msg"), false);
    loaded.save_to_eml(std::filesystem::path("hello.eml"));

    std::cout << "Done\n";
}

Schritt 3 — Build

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build

Unterstützte Formate

FormatErweiterungLesenSchreiben
MSG (Outlook Message).msg✓✓
EML (RFC 5322 / MIME).eml✓✓
CFB (Compound File Binary).msg, .cfb✓✓

Open Source & Lizenzierung

Aspose.Email FOSS für C++ wird unter der MIT-Lizenz veröffentlicht. Der vollständige Quellcode ist verfügbar
auf GitHub unter aspose-email-foss/Aspose.Email-FOSS-for-Cpp.
Kommerzielle Nutzung ist ohne Lizenzgebühren gestattet. Die Bibliothek hat keine Laufzeitabhängigkeiten
außer einem C++17-Compiler und CMake 3.26 oder höher.

Erste Schritte