Aspose.Email FOSS
C++
Cum se poate converti EML în MSG din C++

Cum se poate converti EML în MSG din C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / Întrebări şi răspunsuri: Cum să utilizaţi mapi_message::load_from_eml() Pentru a importa un fişierul de mai sus, atunci mapi_message::save() să o scrieţi ca MSG – şi invers cu mapi_message::from_file() Urmăriți de mapi_message::save_to_eml().

Pasul 1 – Crearea proiectului 

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)

Pasul 2 — Convertiți EML în MSG (Calea fișierului)

mapi_message::load_from_eml() analizează fişierul EML şi expune proprietăţile sale prin intermediul Standardul mapi_message Interfață - Apel save() Pentru a scrie rezultatul ca 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";
}

Pasul 3 — Convertire EML în MSG (Stream)

Foloseste fluxul de supraîncărcare a load_from_eml() Când datele de pe un site provin dintr-o reţea socket, buffer de memorie sau altul 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"));
}

Pasul 4 — Convertiți MSG în EML

Încărcaţi un fişier MSG existent cu mapi_message::from_file(),apoi serializează la EML Formatul cu 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";
}

Pasul 5 – Planificarea completă a călătoriei (EML → MSG→ EML)

Următorul exemplu demonstrează că subiectul, corpul, expeditorul și atașamentele sunt toate păstrate printr-o călătorie completă:

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

Pasul 6 — Convertire în EML Byte în memorie

Ambele save() şi save_to_eml() au supraîncărcări de argumente zero care revin std::vector<std::uint8_t>, util pentru a transmite rezultatele către o conexiune de rețea sau Datele de date fără a atinge sistemul de fișiere:

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

Probleme comune și soluții

load_from_eml() Se pune pe un fişier valid. Verificați utilizarea fișierului RFC 5322 Fișierele exportate de unele instrumente pot folosi LF gol. Se așteaptă terminarea liniilor conforme cu standardele.

Lipsește atașamentele după conversie. Confirmă că EML conține standardul MIME multipart/mixed sau multipart/related Imagini de referință.Inline images referenced prin cid: Acestea sunt purtate ca atașamente în MSG și ar trebui să fie prezente.

Corpul HTML a fost pierdut după MSG → EML. Conținutul HTML este păstrat prin călătoria în jurul valorii de Când message.html_body() Nu este gol, dacă message.body() Este populată în În cazul în care sursa MSG conţine doar o parte din textul simplu.

save_to_eml() Stream output este gol. fluxuri de ieşire deschise cu std::ios::binary.Fluxurile de text corupe structura MIME din Windows.

Subiectul conține ?= Codificarea artefactelor. Acestea sunt RFC 2047 codate-cuvinte secvențe În original, biblioteca le păstrează ca fiind. decodificarea cu o bibliotecă RFC 2047 Dacă aveți nevoie de un cod unicode.

Întrebări frecvente

Sunt atașamentele păstrate în ambele direcții de conversie?

Atât de multă lume, cât şi de tot ce se află în mijlocul ei. mapi_message Anexele binare sunt reprezentate ca byte brute în mapi_attachment::data.

Se păstrează corpul HTML?

Dacă un conţinut de a text/html MIME parte, este stocată în corpul MAPI HTML Proprietatea şi întoarcerea de către message.html_body() După încărcare.

Pot converti în lot un director de fișiere EML?

Da. Iterarea directorului cu std::filesystem::directory_iterator şi apelul mapi_message::load_from_eml() În fiecare .eml Calea, apoi salvare cu 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);
        }
    }
}

Ce se păstrează în timpul conversiei EML ↔ MSG?

Subiect, corpul textului simplu, Corpul HTML, numele expeditorului și adresa de e-mail, lista destinatarilor și toate atașamentele MIME. IMAP steaguri, anteturi de rutare dincolo de antetele de transport de bază și date codate prin TNEF nu sunt păstrate.

este load_from_eml() Tricolor în siguranță?

Fiecare apel la load_from_eml() Creează o autonomie mapi_message Întrebare. tu poate fi numit din mai multe fire simultan, atâta timp cât fiecare fir folosește propriul său Mesajul obiectului.

Aşa că

 Română