Omdannelse af EML og MSG

Omdannelse af EML og MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) og: MSG (Outlook MAPI) formater ved hjælp af mapi_message.Konverteringsbanen er: load_from_eml() → i-memori mapi_message → save() for EML→MSG og from_file() / from_stream() → save_to_eml() for MSG→EML.

Konvertere EML til MSG

Lade en EML-fil med mapi_message::load_from_eml(), der derefter serialiseres til MSG med 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() analyserer MIME-strukturen og fylder MAPI-objektet, almindelig tekst body, HTML-body, afsenderidentitet, modtagerliste og alle vedhæftede dele.

Konvertere MSG til EML

Lade en MSG-fil med mapi_message::from_file(),Så ring. 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";
}

Strømbaseret konvertering

Alle fire relevante metoder accepterer: std::istream / std::ostream overbelastning for Pipeline-formet behandling uden at berøre filsystemet:

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

• Altid åbne strømme med… std::ios::binary.Tekst-mode strømme oversætte linjeendelser på Windows, der ødelægger binære CFB-data.

Omregning i hukommelse (byte)

save() og: save_to_eml() begge har nul-argument overbelastninger returnering std::vector<std::uint8_t>.Brug disse for at undgå alle ind- og udgangssystemer:

#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-katalogkonvertering

Iterere en mappe med: std::filesystem::directory_iterator at konvertere alle .eml - Filer i ét kort:

#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 og bedste praksis

• Åbn alle filstrømme med: std::ios::binary både input og output.
• Foretrækker load_from_eml(path) over strømmen overbelastning, når du har en sti; vejen Overbelastning håndterer filåbningen internt og er lidt enklere.
• Brug byte overbelastninger (save() og: save_to_eml() uden arg) ved rørledning af data mellem tjenesterne for at undgå midlertidige filer.
• Emne, body, HTML-body, afsender, modtagere og MIME vedhæftede filer bevares alle gennem den fulde rundrejse.
• IMAP-flag, rutningshæders og TNEF-kodet indhold overføres ikke gennem konvertering.

Almindelige problemer

FAQ

Bevarer EML → MSG HTML-legemet?

Ja, det er en. text/html MIME-delen er gemt i HTML’s body-egenskab og kan tilgås. via: message.html_body() efter indlæsning.

Er vedhæftninger bevaret i begge retninger?

Ja. Alle MIME-tilbehør dele er gennemført i den mapi_message liste over tilsluttede dokumenter. Binære vedhæftede data er tilgængelige som: attachment.data (a) std::vector<std::uint8_t>).

Kan jeg konvertere en enkelt EML til flere udgangsformater samtidigt?

Lad EML’en op med en gang. load_from_eml(),Så ring til begge to. save() og: save_to_eml() på samme in-memory mapi_message - Det er en genstand.

er: load_from_eml() - Trådsikker?

Hver samtale skaber en uafhængig mapi_message Der kan være flere tråde, der ringer til en ny enhed. load_from_eml() samtidig, så længe hver tråd bruger sit eget udgangsobjekt.

Hvad sker der med beskeder uden tekst?

Hvis EML kun indeholder en text/html del, message.body() returnerer en tom streng og: message.html_body() Begge dele er bevaret gennem MSG. Serialisering.

API-referenceoversigt