Conversia EML și MSG

Conversia EML și MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) și de: MSG (Outlook MAPI) formatele folosind mapi_message.Calea de conversie este: load_from_eml() → în memorie mapi_message → save() pentru EML→MSG și from_file() / from_stream() → save_to_eml() pentru MSG→EML.

Convertiti EML în MSG

Încărcați un fișier EML cu: mapi_message::load_from_eml(), apoi serializat la MSG cu 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() analizează structura MIME și umple subiectul MAPI, text simplu corp, corpul HTML, identitatea expeditorului, lista de destinatar și toate părțile atașate.

Convertiti MSG în EML

Încărcați un fișier MSG cu: mapi_message::from_file(), apoi sună-mă . 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";
}

Conversiunea bazată pe flux

Toate cele patru metode relevante acceptă: std::istream / std::ostream supraîncărcarea pentru: prelucrarea în stil pipeline fără a atinge sistemul de fișiere:

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

Întotdeauna deschise curenți cu std::ios::binary.Fluxuri în mod text traduc sfârșiturile liniilor. pe Windows, coruperea datelor CFB binare.

Conversie în memorie (Byte)

save() și de: save_to_eml() ambele au supraîncărcarea cu argument zero care se întoarce std::vector<std::uint8_t>.Foloseşte-le pentru a evita toate I/O sistemului de fişiere:

#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...
}

Conversiunea directoriului batch

Iterarea unui directory cu: std::filesystem::directory_iterator pentru a converti toate .eml fişiere într-o singură trecere:

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

Sfaturi şi cele mai bune practici

• Deschide toate fluxurile de fişiere cu: std::ios::binary atât input, cât și output.
• Preferă load_from_eml(path) peste supraîncărcarea de flux atunci când aveți o cale; calea Supraîncărcarea se ocupă de deschiderea fişierelor intern şi este puţin mai simplă.
• Folosiți supraîncărcarea de biete (save() și de: save_to_eml() fără arg) atunci când se transmit date prin conducte între servicii pentru a evita fișierele temporare.
• Subiectul, corpul, corp HTML, expeditorul și MIME sunt toate păstrate prin călătoria completă.
• Semnele IMAP, intitulatoarele de rutare și conținutul codificat TNEF nu sunt transmise prin conversie.

Probleme comune

FAQ

EML → MSG păstrează corpul HTML?

Da, un. text/html Partea MIME este stocată în proprietatea corpului HTML MAPI și este accesibilă. prin intermediul message.html_body() după încărcare.

Attachamentele sunt păstrate în ambele direcţii?

Da. Toate părţile de ataşament MIME sunt transportate prin sistemul de control al dispozitivului. mapi_message lista de atașamente. Datele de atașament binar sunt disponibile ca: attachment.data (a) std::vector<std::uint8_t>).

Pot converti un singur EML în mai multe formate de ieșire simultan?

Da, încărcaţi EML-ul o dată cu… load_from_eml(), atunci sunaţi-le pe amândouă . save() și de: save_to_eml() pe aceeași memorie în-memorie mapi_message Obiect.

Este … load_from_eml() - Sigură?

Fiecare apel creează un independent mapi_message Instanţă. mai multe subiecte pot apela la load_from_eml() în paralel, atâta timp cât fiecare thread utilizează propriul obiect de ieșire.

Ce se întâmplă cu mesajele fără text simplu?

Dacă EML conține doar o text/html o parte, message.body() returnă o șir gol și de: message.html_body() Ambele sunt păstrate prin MSG. serializare.

Rezultatele de la data aplicării.