Aspose.Email FOSS
C++
Kā konvertēt EML uz MSG C++ valodā

Kā konvertēt EML uz MSG C++ valodā

Aspose.Email FOSS for C++ atbalsta divvirzienu konvertēšanu starp EML (RFC 5322 / MIME) un MSG (Outlook MAPI) formātiem. Izmantojiet mapi_message::load_from_eml() lai importētu EML failu, pēc tam mapi_message::save() lai saglabātu to kā MSG — un pretēji, izmantojot mapi_message::from_file() un pēc tam mapi_message::save_to_eml().

Solis 1 — Iestatiet projektu 

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)

Solis 2 — Konvertēt EML uz MSG (faila ceļš)

mapi_message::load_from_eml() parsē EML failu un atklāj tā īpašības caur standarta mapi_message interfeisu. Izsauciet save() lai ierakstītu rezultātu kā 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";
}

Solis 3 — Konvertēt EML uz MSG (plūsma)

Izmantojiet load_from_eml() plūsmas pārsniegumu, kad EML dati nāk no tīkla ligzdas, atmiņas bufera vai cita 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"));
}

Solis 4 — Konvertēt MSG uz EML

Ielādējiet esošu MSG failu, izmantojot mapi_message::from_file(), pēc tam serializējiet uz EML formātu, izmantojot 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";
}

5. solis — Pilna apgriešana (EML → MSG → EML)

Sekojošais piemērs demonstrē, ka temats, ķermenis, sūtītājs, saņēmēji un pielikumi visi tiek saglabāti pilnas apgriešanas laikā:

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

6. solis — Pārveidot uz EML baitiem atmiņā

Gan save(), gan save_to_eml() ir null-argumentu pārsniegumi, kas atgriež std::vector<std::uint8_t>, kas ir noderīgi, lai straumētu rezultātus uz tīkla savienojumu vai datubāzi, nepieskaroties failu sistēmai:

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

Biežāk sastopamās problēmas un to risinājumi

load_from_eml() izmet izņēmumu, ja EML fails izskatās derīgs. Pārbaudiet, vai fails izmanto RFC 5322 CRLF rindu beigas. Dažu rīku eksportētie EML faili var izmantot tikai LF. Bibliotēka sagaida standartus atbilstošas rindu beigas.

Pielikumi trūkst pēc EML → MSG konvertēšanas. Pārliecinieties, ka EML satur standarta MIME multipart/mixed vai multipart/related pielikumu daļas. Iekļautie attēli, uz kuriem atsaucas caur cid:, tiek pārvietoti kā pielikumi MSG un tiem jābūt klāt.

HTML ķermenis pazūd pēc MSG → EML. HTML saturs tiek saglabāts apgriešanas laikā, ja message.html_body() nav tukšs. Ja avota MSG ir aizpildīts tikai message.body(), EML saturēs tikai vienkārša teksta daļu.

save_to_eml() plūsmas izvade ir tukša. Atveriet izvades plūsmas ar std::ios::binary. Teksta režīma plūsmas bojā MIME struktūru Windows vidē.

Temats satur ?= kodēšanas artefaktus. Tie ir RFC 2047 kodētās vārdu sekvences oriģinālajā EML. Bibliotēka saglabā tos nemainītus. Atkodējiet ar RFC 2047 bibliotēku, ja jums vajag vienkāršu Unicode tematu.

Biežāk uzdotie jautājumi

Vai pielikumi tiek saglabāti abos konvertēšanas virzienos?

Jā. Gan EML → MSG, gan MSG → EML konvertācijas pārvieto visus MIME pielikumus caur mapi_message pielikumu sarakstu. Binārie pielikumi tiek attēloti kā neapstrādāti baiti mapi_attachment::data.

Vai EML → MSG saglabā HTML ķermeni?

Jā. Ja EML satur text/html MIME daļu, tā tiek saglabāta MAPI HTML ķermeņa īpašībā un tiek atgriezta ar message.html_body() pēc ielādes.

Vai varu grupveidā konvertēt direktoriju ar EML failiem?

Jā. Pārlūkojiet direktoriju ar std::filesystem::directory_iterator un izsauciet mapi_message::load_from_eml() katram .eml ceļam, pēc tam saglabājiet ar 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);
        }
    }
}

Kas tiek saglabāts EML ↔ MSG konvertēšanas laikā?

Temats, vienkāršā teksta ķermenis, HTML ķermenis, sūtītāja vārds un e-pasta adrese, saņēmēju saraksts, kā arī visi MIME pielikumi. IMAP karogi, maršrutēšanas galvenes, kas pārsniedz pamata transporta galvenes, un TNEF-iekodētie dati netiek saglabāti.

Vai load_from_eml() ir pavediena drošs?

Katrs izsaukums load_from_eml() izveido neatkarīgu mapi_message instance. To var izsaukt no vairākiem pavedieniem vienlaicīgi, ja vien katrs pavediens izmanto savu ziņojuma objektu.

Skatīt arī

  • BUJ — Aspose.Email FOSS for C++
  • Kā sākt darbu ar Aspose.Email FOSS for C++
  • Kā nolasīt MSG failus C++ valodā
  • Kā izveidot e-pasta ziņojumu C++
 Latviešu