Umwandlung von EML und MSG

Umwandlung von EML und MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) und . MSG (Outlook MAPI) Formate mit der Verwendung von mapi_message.Der Umwandlungsweg lautet: load_from_eml() → im Speicher mapi_message → save() für EML→MSG und from_file() / from_stream() → save_to_eml() für MSG→EML.

Umwandeln von EML in MSG

Eine EML-Datei mit mapi_message::load_from_eml(), dann zu MSG mit save():

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

int main()
{
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("message.eml"));

    std::cout << "Subject: " << message.subject() << '\n';
    message.save(std::filesystem::path("converted.msg"));
    std::cout << "Saved converted.msg\n";
}

load_from_eml() Parsiert die MIME-Struktur und füllt das MAPI-Subjekt, Plaintext Body, HTML-Body, Absenderidentität, Empfängerliste und alle Anhänge.

Umwandeln von MSG in EML

Eine MSG-Datei mit mapi_message::from_file(),Dann ruf an . save_to_eml():

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

int main()
{
    const auto message = aspose::email::foss::msg::mapi_message::from_file(
        std::filesystem::path("sample.msg"));

    message.save_to_eml(std::filesystem::path("exported.eml"));
    std::cout << "Saved exported.eml\n";
}

Strömungsbasierte Umwandlung

Alle vier relevanten Methoden akzeptieren die std::istream / std::ostream Überlastungen für Pipeline-Verarbeitung ohne Berührung des Dateisystems:

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

int main()
{
    // EML → MSG via streams
    std::ifstream eml_in("message.eml", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(eml_in);

    std::ofstream msg_out("converted.msg", std::ios::binary);
    message.save(msg_out);

    // MSG → EML via streams
    std::ifstream msg_in("converted.msg", std::ios::binary);
    const auto reloaded = aspose::email::foss::msg::mapi_message::from_stream(msg_in);

    std::ofstream eml_out("roundtrip.eml", std::ios::binary);
    reloaded.save_to_eml(eml_out);
}

Immer offenen Strömen mit std::ios::binary.Text-Modus Ströme übersetzen Zeilenenden auf Windows, Korrektur von CFB-Daten.

In-Memory Umwandlung (Bytes)

save() und . save_to_eml() Beide haben null-Argument Überlastungen zurückkehrend std::vector<std::uint8_t>.Verwenden Sie diese, um alle E-/A-Dateien zu vermeiden:

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

int main()
{
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("message.eml"));

    const std::vector<std::uint8_t> msg_bytes  = message.save();
    const std::vector<std::uint8_t> eml_bytes  = message.save_to_eml();

    // Write to a database, network socket, or other destination...
}

Batch-Verzeichnisumwandlung

Iteration eines Verzeichnisses mit: std::filesystem::directory_iterator Um alle zu konvertieren. .eml Akten in einem Durchgang:

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

int main()
{
    const std::filesystem::path input_dir("emails/eml");
    const std::filesystem::path output_dir("emails/msg");
    std::filesystem::create_directories(output_dir);

    for (const auto& entry : std::filesystem::directory_iterator(input_dir))
    {
        if (entry.path().extension() != ".eml")
            continue;

        const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
            entry.path());

        auto out_path = output_dir / entry.path().filename();
        out_path.replace_extension(".msg");
        message.save(out_path);

        std::cout << "Converted: " << entry.path().filename() << '\n';
    }
}

Tipps und beste Praktiken

• Öffnen Sie alle Dateiföhren mit: std::ios::binary sowohl Eingangs- als auch Ausgangsprodukte.
• Vorzug nehmen. load_from_eml(path) Über die Strömung überlastet, wenn Sie einen Weg haben; der Pfad Überlastung verwaltet die Dateiöffnung intern und ist etwas einfacher.
• Verwenden Sie die Bytes-Überlastungen (save() und . save_to_eml() ohne Arg) bei der Übertragung von Daten durch die Leitungen. zwischen den Diensten, um vorübergehende Dateien zu vermeiden.
• Subjekt, Körper, HTML-Körper, Absender, Empfänger und MIME-Anhänge werden alle während des gesamten Rundgangs erhalten.
• IMAP-Flaggen, Routing-Header und TNEF-kodierte Inhalte werden nicht durch die Konvertierung übertragen.

Häufige Probleme

FAQ

Erhält EML → MSG den HTML-Boden?

Ja, das ist A. text/html MIME-Teil wird in der Eigenschaft des MAPI HTML Body gespeichert und ist zugänglich. über die message.html_body() nach dem Laden.

Sind Anlagen in beide Richtungen erhalten?

Ja. Alle MIME-Anbauteile werden durch die mapi_message Liste der Anhängen. Binäre Anlage-Daten sind als: attachment.data (a) Die Kommission hat die std::vector<std::uint8_t>).

Kann ich eine einzelne EML gleichzeitig in mehrere Ausgabeformate konvertieren?

Ja, laden Sie die EML einmal mit dem load_from_eml(),Dann rufen Sie beide an . save() und . save_to_eml() auf demselben In-Memory mapi_message Gegenstand.

Ist . load_from_eml() - Schnürsicher?

Jeder Anruf erzeugt eine unabhängige mapi_message In diesem Fall können mehrere Threads aufgerufen werden. load_from_eml() Gleichzeitig, solange jeder Thread sein eigenes Ausgangsobjekt verwendet.

Was passiert mit Nachrichten ohne einfachen Text?

Wenn die EML nur eine text/html Teil, message.body() gibt eine leere Zeichenfolge zurück. und . message.html_body() Beide werden durch MSG erhalten. Serialisierung.

Zusammenfassung der API-Referenzen