Conversione EML e MSG

Conversione EML e MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) e di cui al punto 2 MSG (Outlook MAPI) formati che utilizzano mapi_message.Il percorso di conversione è: load_from_eml() → in-memory mapi_message → save() per EML→MSG, e from_file() / from_stream() → save_to_eml() per MSG→EML.

Convertire EML in MSG

Caricare un file EML con mapi_message::load_from_eml(), poi serializzato in MSG con 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() analizza la struttura MIME e riempie il soggetto MAPI, testo semplice corpo, HTML body, identità del mittente, lista dei destinatari e tutte le parti allegate.

Convertire MSG in EML

Caricare un file MSG con mapi_message::from_file(), allora chiama . 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";
}

Conversione basata su flusso

Tutti e quattro i metodi pertinenti accettano: std::istream / std::ostream sovraccarichi per: elaborazione in pipeline senza toccare il file system:

#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 in contatto con i nostri clienti. std::ios::binary. I flussi in modalità testo traducono le fine delle righe su Windows, corrompendo i dati CFB binari.

Conversione in memoria (byte)

save() e di cui al punto 2 save_to_eml() entrambi hanno sovratrasporto di argomento zero che restituisce std::vector<std::uint8_t>.Usate questi per evitare tutte le entrate/uscite del file system:

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

Conversione batch di directory

Iterare una directory con: std::filesystem::directory_iterator per convertire tutti i .eml file in un passaggio:

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

Suggerimenti e migliori pratiche

• Aprire tutti i flussi di file con: std::ios::binary sia l’ingresso che il risultato.
• Preferenza load_from_eml(path) sopra il flusso sovraccarico quando si ha un percorso; il percorsi Il sovraccarico gestisce l’apertura dei file internamente ed è leggermente più semplice.
• Utilizzare i byte di sovraccarico (save() e di cui al punto 2 save_to_eml() senza arg) quando si trasmettono dati di condotte tra i servizi per evitare file temporanei.
• Il soggetto, il corpo, l’HTML body, i mittenti, gli destinatari e le allegati MIME sono tutti conservati durante la corsa completa.
• I flag IMAP, gli header di routing e i contenuti codificati con TNEF non vengono trasferiti durante la conversione.

Problemi comuni

FAQ

EML → MSG conserva il corpo HTML?

Sì, sì. text/html La parte MIME è memorizzata nella proprietà del corpo HTML di MAPI ed è accessibile. via: message.html_body() dopo il caricamento.

Gli attaccamenti sono conservati in entrambe le direzioni?

Sì. Tutte le parti di attacco MIME sono trasportate attraverso il sistema di controllo del dispositivo, e tutte le componenti dell’attaccamento Mime vengono utilizzate per la gestione dei dati. mapi_message lista di attacchi. I dati di allegato binario sono disponibili come: attachment.data (a) std::vector<std::uint8_t>).

Posso convertire un singolo EML in più formati di output contemporaneamente?

Sì, carica l’EML una volta con… load_from_eml(), allora chiamate entrambi . save() e di cui al punto 2 save_to_eml() sullo stesso in-memory mapi_message Oggetto.

È load_from_eml() - Sicuro?

Ogni chiamata crea un’interfaccia indipendente. mapi_message In questo caso, più thread possono chiamare: load_from_eml() contemporaneamente, purché ogni thread utilizzi il proprio oggetto di uscita.

Cosa succede ai messaggi senza corpus di testo semplice?

Se l’ EML contiene solo un text/html parte, message.body() restituisce una stringa vuota e di cui al punto 2 message.html_body() Entrambi sono conservati attraverso MSG. - Serializzazione.

Riassunto di riferimento API