EML- en MSG-conversie

Aspose.Email FOSS voor C++ converteert bidirectioneel tussen EML (RFC 5322 / MIME) en MSG (Outlook MAPI) formaten met behulp van mapi_message. Het conversiepad is: load_from_eml() → in-memory mapi_message → save() voor EML→MSG, en from_file() / from_stream() → save_to_eml() voor MSG→EML.

Converteer EML naar MSG

Laad een EML-bestand met mapi_message::load_from_eml(), serialiseer vervolgens naar MSG met 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() analyseert de MIME-structuur en vult het MAPI-onderwerp, de platte-tekst-body, HTML body, afzenderidentiteit, ontvangerslijst en alle bijlage-onderdelen in.

Converteer MSG naar EML

Laad een MSG-bestand met mapi_message::from_file(), roep vervolgens save_to_eml() aan:

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

Streamgebaseerde conversie

Alle vier relevante methoden accepteren std::istream / std::ostream overloads voor pipeline-achtige verwerking zonder het bestandssysteem aan te raken:

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

Open streams altijd met std::ios::binary. Tekstmodus-streams vertalen regeleinden op Windows, waardoor binaire CFB-gegevens corrupt raken.

Conversie in het geheugen (Bytes)

save() en save_to_eml() hebben beide overloads zonder argumenten die std::vector<std::uint8_t> retourneren. Gebruik deze om alle bestands-I/O te vermijden:

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

Batchmapconversie

Itereer een map met std::filesystem::directory_iterator om alle .eml-bestanden in één keer te converteren:

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

Tips en best practices

Open alle bestandsstromen met std::ios::binary — zowel invoer als uitvoer.
Geef de voorkeur aan load_from_eml(path) boven de stream-overload wanneer je een pad hebt; de pad-overload handelt het openen van bestanden intern af en is iets eenvoudiger.
Gebruik de bytes-overloads (save() en save_to_eml() zonder argumenten) bij het doorsturen van gegevens tussen services om tijdelijke bestanden te vermijden.
Onderwerp, berichttekst, HTML berichttekst, afzender, ontvangers en MIME-bijlagen blijven allemaal behouden gedurende de volledige round-trip.
IMAP-vlaggen, routing-headers en TNEF-gecodeerde inhoud worden niet meegenomen bij de conversie.

Veelvoorkomende problemen

Probleem	Oorzaak	Oplossing
`load_from_eml` gooit een fout bij een geldig bestand	Niet-CRLF regeleinden in EML	Zorg ervoor dat EML RFC 5322 CRLF gebruikt; sommige exporttools schrijven alleen LF
Ontbrekende bijlagen na EML → MSG	Niet-standaard MIME-bijlagecodering	Verifieer dat EML `multipart/mixed` gebruikt met standaard `Content-Disposition: attachment`
Leeg HTML body na MSG → EML	Bron-MSG heeft alleen een platte-tekst body	Controleer `message.html_body()`; als deze leeg is, is alleen platte tekst opgeslagen
Stream-uitvoer is corrupt	Stream geopend in tekstmodus	Gebruik altijd `std::ios::binary`
Onderwerp toont `?=` reeksen	RFC 2047 gecodeerd woord in originele EML	Decodeer met een RFC 2047-bibliotheek; de bibliotheek behoudt de gecodeerde vorm

FAQ

Behoudt EML → MSG de HTML body?

Ja. Een text/html MIME-gedeelte wordt opgeslagen in de MAPI HTML body-eigenschap en is toegankelijk via message.html_body() na het laden.

Worden bijlagen in beide richtingen bewaard?

Ja. Alle MIME-bijlage-onderdelen worden doorgegeven via de mapi_message bijlagenlijst. Binaire bijlage-data is beschikbaar als attachment.data (een std::vector<std::uint8_t>).

Kan ik één EML gelijktijdig naar meerdere uitvoerformaten converteren?

Ja. Laad de EML één keer met load_from_eml(), roep vervolgens zowel save() als save_to_eml() aan op hetzelfde in-memory mapi_message object.

Is `load_from_eml()` thread-safe?

Elke oproep maakt een onafhankelijke mapi_message instantie aan. Meerdere threads mogen load_from_eml() gelijktijdig aanroepen zolang elke thread zijn eigen output-object gebruikt.

Wat gebeurt er met berichten zonder plain-text body?

Als de EML alleen een text/html-deel bevat, geeft message.body() een lege string terug en draagt message.html_body() de HTML-inhoud. Beide worden behouden tijdens MSG-serialisatie.

API Reference Samenvatting

Klasse / Methode	Beschrijving
`mapi_message::load_from_eml(path)`	Parse een EML-bestand naar een `mapi_message`
`mapi_message::load_from_eml(stream)`	Parse EML vanuit een `std::istream`
`mapi_message::save(path)`	Serialiseer `mapi_message` naar een MSG-bestand
`mapi_message::save(stream)`	Schrijf MSG-bytes naar een `std::ostream`
`mapi_message::save()`	Retourneer MSG als `std::vector<std::uint8_t>`
`mapi_message::from_file(path)`	Laad een MSG-bestand in een `mapi_message`
`mapi_message::from_stream(stream)`	Laad MSG van een `std::istream`
`mapi_message::save_to_eml(path)`	Schrijf EML naar een bestandspad
`mapi_message::save_to_eml(stream)`	Schrijf EML-bytes naar een `std::ostream`
`mapi_message::save_to_eml()`	Retourneer EML als `std::vector<std::uint8_t>`

Zie ook

Aspose.Email for C++ — Enterprise Documentation

EML- en MSG-conversie