Kako konvertovati EML u MSG u C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / MIME) i MSG (Outlook MAPI) formati. Koristite mapi_message::load_from_eml() za uvoz EML datoteku, zatim mapi_message::save() da je zapišete kao MSG — i obrnuto sa mapi_message::from_file() prateći mapi_message::save_to_eml().

Korak 1 — Postavite projekat

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)

Korak 2 — Konvertujte EML u MSG (Putanja do fajla)

mapi_message::load_from_eml() parsira EML datoteku i izlaže njena svojstva kroz standardni mapi_message interfejs. Pozovite save() da se rezultat zapiše kao 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";
}

Korak 3 — Konvertujte EML u MSG (Tok)

Koristite overload stream-a load_from_eml() kada EML podaci dolaze sa mreže socket, memorijski bafer ili drugi 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"));
}

Korak 4 — Konvertujte MSG u EML

Učitajte postojeću MSG datoteku pomoću mapi_message::from_file(), zatim serijalizujte u EML format uz 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";
}

Korak 5 — Potpuni ciklus (EML → MSG → EML)

Sledeći primer pokazuje da su predmet, telo, pošiljalac, primaoci i prilozi svi očuvani kroz kompletan ciklus:

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

Korak 6 — Pretvori u EML bajtove u memoriji

Oba save() i save_to_eml() imaju preopterećenja bez argumenata koja vraćaju std::vector<std::uint8_t>, korisno za strimovanje rezultata na mrežnu vezu ili bazu podataka bez dodirivanja sistema datoteka:

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

Uobičajeni problemi i rešenja

load_from_eml() baci izuzetak na validno‑izgledajuću EML datoteku. Proverite da datoteka koristi RFC 5322 CRLF završetke linija. EML datoteke izvezene nekim alatima mogu koristiti samo LF. Biblioteka očekuje završetke linija u skladu sa standardom.

Nedostaju prilozi nakon konverzije EML → MSG. Potvrdite da EML sadrži standard MIME multipart/mixed ili multipart/related delove priloga. Umetnute slike na koje se referiše preko cid: se prenose kao prilozi u MSG i treba da budu prisutni.

HTML telo izgubljeno nakon MSG → EML. Sadržaj HTML je očuvan kroz round-trip kada message.html_body() nije prazan. Ako je samo message.body() je popunjen u izvor MSG, EML će sadržati samo deo u običnom tekstu.

save_to_eml() izlaz toka je prazan. Otvorite izlazne tokove sa std::ios::binary. Tokovi u tekstualnom režimu oštećuju strukturu MIME na Windowsu.

Tema sadrži ?= artefakti kodiranja. Ovo su RFC sekvence 2047 encoded-word u originalnom EML. Biblioteka ih čuva nepromenjene. Dekodirajte pomoću RFC 2047 biblioteke ako vam je potreban čist Unicode naslov.

Često postavljana pitanja

Da li se prilozi čuvaju u oba smera konverzije?

Da. I EML → MSG i MSG → EML konverzije prenose sve MIME priloge kroz mapi_message listu priloga. Binarni prilozi su predstavljeni kao sirovi bajtovi u mapi_attachment::data.

Da li EML → MSG čuva HTML telo?

Da. Ako EML sadrži text/html MIME deo, čuva se u MAPI HTML telu svojstvo i vraća se od message.html_body() nakon učitavanja.

Mogu li paketno konvertovati direktorijum EML fajlova?

Da. Prođite kroz direktorijum pomoću std::filesystem::directory_iterator i pozovite mapi_message::load_from_eml() na svakom .eml putanju, zatim sačuvajte pomoću 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);
        }
    }
}

Šta se čuva tokom konverzije EML ↔ MSG?

Naslov, telo u običnom tekstu, HTML telo, ime pošiljaoca i e‑mail adresa, lista primalaca i svi MIME prilozi. IMAP zastavice, zaglavlja za usmeravanje izvan osnovnih transportnih zaglavlja i TNEF‑kodirani podaci se ne čuvaju.

Da li je `load_from_eml()` bezbedan za više niti?

Svaki poziv na load_from_eml() kreira nezavisnu mapi_message instancu. Vi možete je pozvati iz više niti istovremeno sve dok svaka nit koristi svoj objekat poruke.