Conversió de LME i MSG

Conversió de LME i MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) i de la MSG (Outlook MAPI) formats utilitzant mapi_message.La ruta de conversió és: load_from_eml() → en memòria mapi_message → save() per EML→MSG, i from_file() / from_stream() → save_to_eml() per MSG→EML.

Converteix EML en MSG

Carregar un fitxer EML amb: mapi_message::load_from_eml(), després serialitzar a MSG amb 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() analisa l’estructura MIME i omplea el subjecte de MAPI, text sencer. cos, HTML body, identitat del remitent, llista de destinataris i totes les parts d’anunci.

Converteix MSG en EML

Carregar un fitxer MSG amb mapi_message::from_file(), llavors trucar 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";
}

Conversió basada en flux

Tots els quatre mètodes pertinents accepten: std::istream / std::ostream sobrecarrega per a: Processament de tipus pipeline sense tocar el sistema de fitxers:

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

Sempre en un flux obert amb std::ios::binary. Els flux de text traduir els finals de línia en Windows, corrompt dades CFB binàries.

Conversió en memòria (Bytes)

save() i de la save_to_eml() ambdues tenen sobrecarres d’argument zero que retornen: std::vector<std::uint8_t>.Utilitza-les per evitar totes les entrades i sortides del sistema de fitxers:

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

Conversió de directori per batxeres

Iterar un directori amb: std::filesystem::directory_iterator Convertir tots els .eml Arxius en un pas:

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

Consells i millors pràctiques

• Obrir tots els flux de fitxers amb: std::ios::binary tant la entrada com l’exportació.
• Preferir load_from_eml(path) sobre la sobretaxa de corrent quan tens un camí; el camí La sobrecarrega gestiona l’obertura de fitxers internament i és una mica més senzilla.
• Utilitzar els bytes de sobrecarrega (save() i de la save_to_eml() sense args) quan es fa la canonada de dades. entre serveis per evitar arxius temporals.
• El subjecte, el cos, HTML, remitent, destinatari i MIME s’han preservat durant tot el viatge.
• Les banderes IMAP, els encabezaments d’enrutament i el contingut codificat per TNEF no es transfereixen a través de la conversió.

Problemàtiques comuns

FAQ

L’EML → MSG conserva el cos HTML?

Sí, una. text/html La part MIME s’emmagatzema en la propietat de cos HTML del MAPI i és accessible. per mitjà de: message.html_body() després de la càrrega.

Els ataixaments es conserven en les dues direccions?

Sí. Totes les parts de l’acoplament MIME es transporten a través del sistema d’enllaç Mime i la seva part posterior s’ha de fer circular per un canal de sortida. mapi_message llista de lligats. Les dades de l’apunt binari estan disponibles com a: attachment.data (a) std::vector<std::uint8_t>).

Puc convertir un sol EML en múltiples formats de sortida simultàniament?

Si, carrega l’EML una vegada amb load_from_eml(), llavors crida’ls a tots dos . save() i de la save_to_eml() en la mateixa memòria interna. mapi_message objecte.

És load_from_eml() Segur per a fil?

Cada trucada crea un independent mapi_message Instança. Molts fils poden cridar a la pàgina de l’exemple. load_from_eml() simultàniament sempre que cada fil utilitzi el seu propi objecte de sortida.

Què passa amb els missatges sense text sencer?

Si l’EML conté només una text/html part, message.body() Retorna una cadena buida. i de la message.html_body() amb el contingut HTML. Ambdues estan conservades a través de MSG serialització.

Resum de referència d’API