EML och MSG konvertering

EML och MSG konvertering

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) och MSG (Outlook MAPI) format som används för att mapi_message.Konversionsvägen är: load_from_eml() In-minnet i minnet mapi_message → save() för EML→MSG, och from_file() / from_stream() → save_to_eml() För MSG→EML.

Konvertera EML till MSG

Ladda upp en EML-fil med mapi_message::load_from_eml(),och sedan serialisera till 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() Parsera MIME-strukturen och populerar MAPI-tema, platt text kropp, HTML-kropp, sändaridentitet, mottagarlista och alla bifogade delar.

Konvertera MSG till EML

Ladda upp en MSG-fil med mapi_message::from_file(),Och sedan ringer 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";
}

Streambaserad konvertering

Alla fyra relevanta metoder accepteras std::istream / std::ostream Överbelastning för Pipeline-stil bearbetning utan att röra 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);
}

Alltid öppna strömmar med std::ios::binary.Text-mode strömmar översätta linjeändar på Windows, korrupta binära CFB-data.

In-Memory Conversion (Bytes) och in-minnet omvandlas till

save() och save_to_eml() Båda har nollargument överbelastning returnerar std::vector<std::uint8_t>.Använd dessa för att undvika alla filsystem I/O:

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

Skriv ett katalog med std::filesystem::directory_iterator för att konvertera alla .eml Filer i ett pass:

#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 och bästa praxis

• Öppna alla filströmmar med std::ios::binary Både in och ut.
• Prefer load_from_eml(path) över ström överbelastning när du har en väg; vägen överbelastning hanterar filen öppnas intern och är något enklare.
• Använd bytesöverlåtelser (save() och save_to_eml() med inga arg) när data är kopplade till mellan tjänster för att undvika tillfälliga filer.
• Subject, body, HTML-kropp, sändare, mottagare och MIME-filer bevaras alla genom den fullständiga rundturen.
• IMAP-flaggor, routinghuvud och TNEF-kodat innehåll transporteras inte genom konvertering.

Vanliga frågor

FAQ

Försvårar EML → MSG HTML-kroppen?

Ja, A är text/html MIME-del lagras i MAPI HTML kroppsegenskapen och är tillgänglig via message.html_body() efter laddning.

Är anslutningar bevarade i båda riktningarna?

Alla MIME-fästdelar transporteras genom mapi_message Anslutningslista . Binära bilagor är tillgängliga som attachment.data (a) och std::vector<std::uint8_t>).

Kan jag konvertera en enda EML till flera utgångsformat samtidigt?

Ladda EML en gång med load_from_eml(),Och ringer båda save() och save_to_eml() på samma in-minnes mapi_message och objekt.

är load_from_eml() Trådsäkerhet ?

Varje samtal skapar en oberoende mapi_message Exempel: flera trådar kan ringa load_from_eml() samtidigt så länge varje tråd använder sitt eget utgångsobjekt.

Vad händer med meddelanden utan en platt text kropp?

Om EML endast innehåller en text/html del av, message.body() återställer en tom sträng och message.html_body() bär HTML-innehållet. båda bevaras via MSG Seriering av .

API Referens sammanfattning

Se även

• Aspose.Email for C++ — Enterprise Documentation