Hur man konverterar EML till MSG i C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / MIME) och MSG (Outlook MAPI) format. mapi_message::load_from_eml() att importera en EML-filen och sedan mapi_message::save() att skriva det som MSG - och vice versa med mapi_message::from_file() Följer av mapi_message::save_to_eml().

Steg 1 – Ställ in projektet

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)

Steg 2 – Konvertera EML till MSG (File Path)

mapi_message::load_from_eml() Parsera EML-filen och avslöjar dess egenskaper genom att Den standard mapi_message Interface - ringa save() För att skriva resultatet som MSG:

#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";
}

Steg 3 – Konvertera EML till MSG (Stream)

Använd ström överbelastning av load_from_eml() När EML-data kommer från ett nätverk Socket, minnesbuffer eller annat 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"));
}

Steg 4 – Konvertera MSG till EML

Ladda upp en befintlig MSG-fil med mapi_message::from_file(),och sedan serialisera till EML. Format med 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";
}

Steg 5 – Full rundtur (EML → MSG → EML)

Följande exempel visar att ämnet, kroppen, avsändaren, mottagarna och tillägg är alla bevarade genom en komplett rundtur:

#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';
}

Steg 6 – Konvertera till EML-bitar i minne

Båda save() och save_to_eml() har nollargument överbelastning som återvänder std::vector<std::uint8_t>,användbar för streamingresultat till en nätverksanslutning eller Databas utan att röra filsystemet:

#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();
}

Vanliga problem och fixar

load_from_eml() kastas på en giltig-looking EML-fil. Kontrollera filen med RFC 5322 CRLF-linjeändningar. EML-filer som exporteras av vissa verktyg kan använda bara LF. Biblioteket förväntas standard-kompatibla linjeavslut.

Saknas bifogningar efter EML → MSG konvertering. Kontrollera att EML innehåller standard MIME multipart/mixed eller multipart/related anslutningar delar. inline bilder refererade via cid: De är föremål för anslutningar i MSG och bör vara närvarande.

HTML-kropp förlorad efter MSG → EML. HTML-innehåll bevaras genom rundturen När message.html_body() är inte öppen, om bara message.body() är befolkade i källor MSG, EML kommer att innehålla endast en platt text del.

save_to_eml() Stream utgången är tom. Öppna utgångströmmar med std::ios::binary.Text-läge strömmar korrupta MIME strukturen på Windows.

Subjektet innehåller ?= Kodning av artefakter. Detta är RFC 2047 kodade ord sekvenser i den ursprungliga EML. biblioteket bevarar dem som-is. Decod med en RFC 2047 bibliotek Om du behöver den enkla Unicode-tema.

Ofta ställda frågor

Är bifogade filer bevarade i båda omvandlings riktningarna?

Både EML → MSG och MSM → EMl konverteringar bär alla MIME-filer genom mapi_message bifogade listor. binära bifoga är representerade som rå byter i mapi_attachment::data.

Försvårar EML → MSG HTML-kroppen?

Om EML innehåller en text/html MIME-del, det är lagrat i MAPI HTML-kroppen fastighet och återlämnats av message.html_body() efter laddning.

Kan jag batch-konvertera en katalog av EML-filer?

Ja, skicka in katalogen med std::filesystem::directory_iterator och ringer mapi_message::load_from_eml() på varje .eml Vägen, så spara med 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);
        }
    }
}

Vad är bevarat under EML ↔ MSG-konvertering?

Subject, plain-text body, HTML body och avsändarnamn och e-postadress, mottagarlista och alla MIME-flaggor. IMAP-lagstiftningar, routing headers utanför grundläggande transport headels och TNEF-kodade data bevaras inte.

är `load_from_eml()` Trådsäkerhet ?

Varje kallelse till load_from_eml() Skapar en oberoende mapi_message instans. du kan ringa det från flera trådar samtidigt så länge varje tråd använder sin egen meddelande objekt.