Konverze EML a MSG

Konverze EML a MSG

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

Konverze EML na MSG

Nahrát soubor EML s mapi_message::load_from_eml(), pak se sériově zpracovává 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 strukturu MIME a vyplňuje předmět MAPI, prostý text body, HTML body a všechny části příloh.

Konverze MSG na EML

Naložit soubor MSG s mapi_message::from_file(), tak zavolej . 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";
}

Konverze na základě proudu

Všechny čtyři příslušné metody přijímá: std::istream / std::ostream přetížení pro: zpracování v typově plynovodním stylu bez dotýkání souborové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ždycky otevřete proudění s std::ios::binary.Textové toky překládá konce řádků . na Windows, narušující binární CFB data.

Konverze v paměti (bajty)

save() a) save_to_eml() Obě mají nultý argument přetížení vracíce se std::vector<std::uint8_t>.Použijte tyto, abyste se vyhnuly veškerým vstupům a výstupům souborové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...
}

Konverze souboru adresářů

Iterovat adresář s: std::filesystem::directory_iterator konverzovat všechny .eml soubory v jednom průjezdu:

#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 nejlepší postupy

• Otevřít všechny soubory pomocí: std::ios::binary jak vstup, tak výstup.
• Preferovat load_from_eml(path) přes proud přetížení, když máte cestu; cesta Přetížení se zabývá otevřením souborů vnitřně a je o něco jednodušší.
• Použijte přetížení bajtů (save() a) save_to_eml() bez arg) při odvodování dat. mezi službami, aby se zabránilo dočasným souborům.
• Předmět, tělo, HTML tělo a příjemci jsou uchovávány během celého přepínání.
• Vzorky IMAP, hlavičky směrování a obsah kódovaný TNEF nejsou převáděny.

Obvyklé problémy

FAQ

Zachovává EML → MSG tělo HTML?

Ano, A. text/html MIME část je uložená v vlastnosti těla HTML MAPI a je přístupná. přes: message.html_body() po nakládce.

Jsou připoutání zachovány v obou směrech?

Ano. Všechny části MIME připojení jsou přenášeny přes mapi_message seznam připojených osob. Data o binárním připojení jsou k dispozici jako: attachment.data (a) std::vector<std::uint8_t>).

Mohu konverzovat jednu EML do více výstupních formátů současně?

Ano, nabití EML jednou s load_from_eml(), tak zavolej oběma . save() a) save_to_eml() na stejné paměti mapi_message předmět.

Je to … load_from_eml() Bezpečná?

Každý hovor vytváří nezávislý mapi_message Příklad. více článků může volat load_from_eml() současně, pokud každý článek používá svůj vlastní výstupní objekt.

Co se stane s zprávami bez prostého textu?

Pokud EML obsahuje pouze: text/html část, message.body() vrací prázdný řetěz a) message.html_body() Obě jsou uchovávány prostřednictvím MSG. serializace.

Souhrnná referenční informace API