Come convertire il codice in C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / Il sistema di controllo e il sistema operativo (il sistema) sono in grado di utilizzare mapi_message::load_from_eml() Per importare un Il file, quindi mapi_message::save() per scrivere come MSG - e viceversa con mapi_message::from_file() Seguita da mapi_message::save_to_eml().

Passo 1 - Impostare il progetto

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)

Passo 2 — Convertire EML in MSG (Cammino file)

mapi_message::load_from_eml() analizza il file EML e espone le sue proprietà attraverso Il standard mapi_message Interfaccia - Chiamare save() Per scrivere il risultato come 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";
}

Passo 3 — Convertire EML in MSG (Stream)

Utilizzare il flusso di sovraccarico del load_from_eml() Quando i dati provenienti da una rete socket, buffer di memoria o altro 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"));
}

Passo 4 — Convertire MSG in EML

Caricare un file MSG esistente con mapi_message::from_file(),e poi serializzare a EML Formato con 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";
}

Passo 5 – Trattamento completo (EML → MSG→ EML)

Il seguente esempio dimostra che il soggetto, il corpo, l’inviatore, i destinatari e gli allegati sono tutti conservati attraverso un viaggio completo:

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

Passo 6 — Convertire in EML byte nella memoria

entrambi save() e save_to_eml() hanno sovraccaricazioni di argomento zero che restituiscono std::vector<std::uint8_t>, utile per lo streaming di risultati a una connessione di rete o Il database senza toccare il file system:

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

Problemi comuni e risoluzioni

load_from_eml() Inserisci un file con una vista valida. Verifica il file utilizza RFC 5322 I file esportati da alcuni strumenti possono utilizzare il nudo LF. La libreria Si aspettano linee di fine conforme alle norme.

Mancanza di allegati dopo la conversione. Confirmi che EML contiene standard MIME multipart/mixed o multipart/related Immagini in linea. immagini in riferimento via cid: sono trasportati come allegati nell’ MSG e dovrebbero essere presenti.

Il corpo HTML perduto dopo MSG → EML. Il contenuto HTML viene conservato durante il tour. Quando message.html_body() Non è vuoto, se non si message.body() È popolata nella La fonte MSG, il EML contiene solo una parte di testo semplice.

save_to_eml() Il flusso di uscita è vuoto. Il flusso di output con std::ios::binary.I flussi di modalità testo corrompono la struttura MIME in Windows.

Il tema contiene ?= Codifica degli artefatti. Sono 2047 le sequenze di parole codificate. La biblioteca li conserva come-è. decodifica con una libreria RFC 2047 Se hai bisogno di un tema Unicode.

Domande frequenti

I file allegati sono conservati in entrambe le direzioni di conversione?

Sia i passeggeri che gli addetti a un servizio di trasporto sono stati sottoposti a tutte le conversioni tramite il mapi_message I file allegati binari sono rappresentati come byte crudi in mapi_attachment::data.

Ma è possibile conservare il corpo HTML?

Se il contenitore contiene un text/html MIME parte, è memorizzato nel corpo HTML MAPI Proprietà e restituzione da message.html_body() Dopo il carico.

Posso convertire in lotto un directory di file?

Sì. Iterare il directory con std::filesystem::directory_iterator e chiamate mapi_message::load_from_eml() su ciascuno .eml Il cammino, poi salvo con 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);
        }
    }
}

Cosa si conserva durante la conversione di EML ↔ MSG?

Oggetto, corpo di testo semplice, corpus HTML, nome del mittente e indirizzo email, elenco dei destinatari e tutti gli allegati MIME. IMAP bandiere, intestazioni di routing al di là degli intestini di trasporto di base e dati codificati con TNEF non vengono conservati.

è `load_from_eml()` Trama sicura ?

Ogni chiamata a load_from_eml() Crea un’indipendenza mapi_message Il caso. tu Può essere chiamato da più fili contemporaneamente, purché ciascun filo utilizzi il suo stesso. Messaggio di oggetto.