Konverzia EML a MSG

Konverzia EML a MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) a) MSG (Outlook MAPI) formáty pomocou mapi_message.Konverzná cesta je: load_from_eml() → v pamäti mapi_message → save() pre EML→MSG a from_file() / from_stream() → save_to_eml() pre MSG→EML.

Konverzia EML na MSG

Nahradenie súboru EML s mapi_message::load_from_eml(), potom sa sérizuje na MSG s 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() analyzuje štruktúru MIME a vyplňuje predmet MAPI, obyčajný text body, HTML body , identity odosielateľa, zoznam príjemcov a všetky časti priloženia.

Konverzia MSG na EML

Nahradenie súboru MSG s mapi_message::from_file(), potom zavolaj . 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";
}

Prepočet založený na toku

Všetky štyri príslušné metódy prijímajú: std::istream / std::ostream preťaženie na: spracovanie v typovej pipeline bez dotýkania sa súborového systému:

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

Vždy otvorený prúd s std::ios::binary.Textové toky prekladajú konce riadkov . na Windows, poškodenie binárnych CFB údajov.

Konverzia v pamäti (bajty)

save() a) save_to_eml() oba majú preťaženie s nulovým argumentom vrátiace sa std::vector<std::uint8_t>.Použite tieto, aby ste sa vyhli všetkým vstupom a výstupom súborového systému:

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

Konverzia súborov v množstve

Iterovať adresár s: std::filesystem::directory_iterator previesť všetky .eml súbory v jednom prechode:

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

Tipy a najlepšie postupy

• Otvorte všetky prúdy súborov pomocou: std::ios::binary vstup a výstup.
• Preferovať load_from_eml(path) nad prúdom, keď máte cestu; cesta Preťaženie spracováva otvorovanie súborov interným spôsobom a je to o niečo jednoduchšie.
• Použite preťaženie bajtov (save() a) save_to_eml() bez arg) pri odovzdávaní údajov cez potrubie, medzi službami, aby sa zabránilo dočasným súborom.
• Predmet, telo, HTML telo a prílohy MIME sú zachované počas celého výletu.
• Vymedzenie sa nevykonáva prostredníctvom označení IMAP, hlavičiek smerovania a obsahu kódovaného TNEF.

Spoločné problémy

FAQ

Zachováva text EML → MSG?

Áno. text/html Časť MIME je uložená v vlastnosti tela HTML MAPI a je prístupná. cez: message.html_body() po nakladaní.

Sú pripútanosti zachované v oboch smeroch?

Áno, všetky časti pripojenia MIME prechádzajú cez mapi_message zoznam pripojených osôb. Údaje o binárnych pripojeniach sú k dispozícii ako: attachment.data (a) std::vector<std::uint8_t>).

Môžem konverzovať jeden EML na viac výstupných formátov súčasne?

Áno, nabitie EML raz s load_from_eml(), potom zavolajte obom . save() a) save_to_eml() na rovnakom pamäti mapi_message predmet.

Je to … load_from_eml() Bezpečná?

Každý hovor vytvára nezávislého mapi_message Prípad. Viac článkov môže volať load_from_eml() súčasne, pokiaľ každý proces používa svoj vlastný výstupný objekt.

Čo sa stane s odkazmi bez textového textu?

Ak EML obsahuje len text/html časť, message.body() vráti prázdny reťazec a) message.html_body() Oba sú uchovávané prostredníctvom MSG. serializácia.

Zhrnutie referenčného API