Das ist ein Scherz.
C++
Wie konvertiert man EML in MSG im C++

Wie konvertiert man EML in MSG im C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / Die Aussicht auf die Plätze und die Ausrichtung der Pläne. mapi_message::load_from_eml() Importieren Sie ein Die Datei, dann mapi_message::save() als MSG zu schreiben – und umgekehrt mit mapi_message::from_file() gefolgt von mapi_message::save_to_eml().

Schritt 1 – Set up the Project 

git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.git
add_subdirectory(Aspose.Email-FOSS-for-Cpp)
target_link_libraries(your_target PRIVATE AsposeEmailFoss::AsposeEmailFoss)

Schritt 2 — Konvertieren Sie EML in MSG (Datei-Pfad)

mapi_message::load_from_eml() Parsiert die EML Datei und zeigt ihre Eigenschaften durch Der Standard mapi_message Interface - Anrufe save() Das Ergebnis als MSG zu schreiben:

#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';
    std::cout << "From:    " << message.sender_email_address() << '\n';

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

Schritt 3 — Konvertieren Sie EML in MSG (Stream)

Verwenden Sie den Stream-Überladung von load_from_eml() Wenn die EML Daten aus einem Netzwerk stammen, - Socket, Speicherpuffer oder ein anderes std::istream:

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

int main()
{
    std::ifstream eml_stream("message.eml", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(eml_stream);

    message.save(std::filesystem::path("converted.msg"));
}

Schritt 4 — Konvertieren Sie MSG in EML

Laden Sie eine vorhandene MSG Datei mit mapi_message::from_file(),Dann serialisieren Sie es auf EML Format mit 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";
}

Schritt 5 – Vollständige Rundreise (EML → MSG→ EML)

Das folgende Beispiel zeigt, dass Subjekt, Körper, Sender, Empfänger und Anhänge alle durch einen kompletten Rundgang erhalten bleiben:

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

int main()
{
    const auto msg_path = std::filesystem::path("roundtrip.msg");
    const auto eml_out  = std::filesystem::path("roundtrip.eml");

    // EML → MSG
    auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("original.eml"));
    message.save(msg_path);

    // MSG → EML
    auto reloaded = aspose::email::foss::msg::mapi_message::from_file(msg_path);
    reloaded.save_to_eml(eml_out);

    std::cout << "Subject preserved: " << reloaded.subject() << '\n';
    std::cout << "Attachments: " << reloaded.attachments().size() << '\n';
}

Schritt 6 — Konvertieren Sie in EML Bytes im Speicher

Beide save() und save_to_eml() haben Null-Argumentüberschüssigkeiten, die zurückkehren std::vector<std::uint8_t>, nützlich für das Streamen von Ergebnissen zu einer Netzwerkverbindung oder Datenbank ohne das Dateisystem zu berühren:

#include <filesystem>
#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"));

    // In-memory MSG bytes
    const auto msg_bytes = message.save();

    // In-memory EML bytes
    const auto eml_bytes = message.save_to_eml();
}

Häufige Probleme und Lösungen

load_from_eml() auf eine gültige aussehende EML Datei werfen. Überprüfen Sie die Datei verwendet RFC 5322 EML Dateien, die von einigen Tools exportiert werden, können nur LF verwenden. Erwartet standardmäßig konforme Linieendungen.

Fehlende Anhänge nach EML → MSG Konvertierung. Bestätigen Sie, dass EML Standard enthält MIME multipart/mixed oder multipart/related Inline Bilder Referenz via cid: Sie werden als Anhänge in der MSG transportiert und sollten vorhanden sein.

HTML-Körper verloren nach MSG → EML. HTML-Inhalte werden während der Rundreise erhalten Wann message.html_body() ist nicht leer. wenn nur message.body() ist in der Bevölkerung des Die Quelle MSG enthält nur einen einfachen Textteil.

save_to_eml() Der Stream-Ausgang ist leer. Open Output Streams mit std::ios::binary.Text-Modus-Streams verderben die MIME Struktur in Windows.

Thema enthält ?= Die Artefakte kodieren. Dies sind RFC 2047 coded-word sequences in der Originalmedizin EML. Die Bibliothek behält sie so, wie es ist. Decodieren Sie mit einer RFC 2047 Bibliotheque Wenn Sie ein Unicode-Theme benötigen.

Häufig gestellte Fragen

Sind Anhänge in beiden Konvertierungsrichtungen erhalten?

Sowohl die EML → MSG als auch die → die konvertierungen führen alle MIME Anhänge über den mapi_message Binäre Anhänge werden als Rohbytes in mapi_attachment::data.

Kann der HTTP-Code den HTML-Körper bewahren?

Wenn das Buch enthält eine text/html MIME Teil, es wird im HTML-Körper MAPI gespeichert Eigentum und zurückgegeben von message.html_body() Nach dem Laden.

Kann ich eine Datei mit einem Katalog von EML konvertieren?

Ja. Iterieren Sie das Verzeichnis mit std::filesystem::directory_iterator und Call mapi_message::load_from_eml() auf jeder .eml Weg, dann mit dem Rettung save():

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

int main()
{
    for (const auto& entry : std::filesystem::directory_iterator("emails/"))
    {
        if (entry.path().extension() == ".eml")
        {
            auto msg = aspose::email::foss::msg::mapi_message::load_from_eml(entry.path());
            auto out = entry.path();
            out.replace_extension(".msg");
            msg.save(out);
        }
    }
}

Was wird während der EML ↔ MSG Umwandlung beibehalten?

Subject, einfacher Textkörper, HTML-Körper und Absendername und E-Mail-Adresse, Empfängerliste sowie alle MIME Anhänge. IMAP Flaggen, Routing-Header jenseits der grundlegenden Transportheader und TNEF-verschlüsselte Daten werden nicht beibehalten.

ist load_from_eml() Threadsicherheit ?

Jeder Anruf an die load_from_eml() Erstellt eine unabhängige mapi_message Die Veranstaltung.de kann es von mehreren Threads gleichzeitig anrufen, solange jeder Thread seinen eigenen verwendet. Nachricht Objekt .

Siehe auch

 Deutsch