EML és MSG átalakítása

EML és MSG átalakítása

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) és a következők: MSG (Outlook MAPI) formátumok használata mapi_message.A konverziós útvonal a következő: load_from_eml() → memóriában mapi_message → save() EML→MSG esetében, és from_file() / from_stream() → save_to_eml() az MSG→EML esetében.

EML-t MSG-re alakítani

Töltse be az EML fájlt a mapi_message::load_from_eml(), majd sorozatos MSG-re, 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() MIME struktúráját elemzi és a MAPI tárgyát, egyszerű szöveget tölt be. body, HTML body , a küldő azonosítója, címzett listája és minden melléklet része.

MSG-t EML-re alakítani

Töltse be egy MSG fájlt a mapi_message::from_file(), akkor hívj! 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";
}

Átárgyalási alapú átváltás

A négy vonatkozó módszer is elfogadja a következőket: std::istream / std::ostream a túlterhelés csővezeték-stílusú feldolgozás a fájlrendszer érintése nélkül:

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

Mindig nyitott folyamok a std::ios::binary.A szöveges modusú áramlások fordítják a sorvégeket . Windows-on, hibás bináris CFB adatok.

Memóriában történő átváltás (Byte)

save() és a következők: save_to_eml() mindkettő 0-argumentes túlterheléssel jár. std::vector<std::uint8_t>.A következőket használd, hogy elkerülj az összes fájlrendszerbe és kivitelre vonatkozó információkat:

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

Batch Directory konverzió

Iteráljon egy címkéket a következőkkel: std::filesystem::directory_iterator hogy minden .eml Egy átjáróval:

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

Tippek és legjobb gyakorlatok

• Nyisd ki az összes fájláramlást a . std::ios::binary mind a bemeneti, mind az kimenetelbeli.
• Prefer load_from_eml(path) a folyó túlterhelése, amikor van egy út; az ösvény A túlterhelés a fájl megnyitását belsőleg kezeli, és kissé egyszerűbb.
• Használja a byte-tömegeket (save() és a következők: save_to_eml() a csővezetékben lévő adatok esetében. a szolgáltatások között, hogy elkerüljék az ideiglenes fájlok megjelenését.
• A témakör, a test, az HTML-test, küldő, fogadó és MIME mellékletek mind megőrződnek a teljes körű utazás során.
• Az IMAP jelzőjeleket, az útvonalcímeket és a TNEF-kódolt tartalmat nem lehet átvinni.

Általános kérdések

FAQ

Az EML → MSG megőrzi-e a HTML testét?

Igen, egy. text/html A MIME része a MAPI HTML test tulajdonságban tárolódik, és hozzáférhető. a következők: message.html_body() a betöltés után.

A kötődés mindkét irányban megmarad?

Igen. Minden MIME-csatlakozó alkatrészt a mapi_message a csatolt listát. A bináris csatolási adatok a következő formában állnak rendelkezésre: attachment.data (a) std::vector<std::uint8_t>).

Konvertálhatom egy EML-t több kimeneti formátumba egyszerre?

Igen, töltse fel az EML-t egyszer. load_from_eml(), akkor hívd mindkettőt. save() és a következők: save_to_eml() ugyanazon memóriában mapi_message Az objektum.

Az a. load_from_eml() - Fonalbiztos?

Minden egyes hívás független mapi_message Több szálas vezeték is hívhat. load_from_eml() egyidejűleg, ha minden egyes szál saját kimeneti objektumot használ.

Mi történik azokkal az üzenetekkel, amelyek nem tartalmaznak egyszerű szöveget?

Ha az EML csak egy text/html rész, message.body() üres szalagot ad vissza. és a következők: message.html_body() Mindkettő az MSG-n keresztül tárolódik. sorozatosítás.

API-referencia összefoglaló