Aspose.Email FOSS
C++
Hoe te converteren van EML naar MSG in C++

Hoe te converteren van EML naar MSG in C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / De verzameling van de (ver) en de verplaatsing van het materiaal. mapi_message::load_from_eml() Om te importeren een Het bestand, dan mapi_message::save() om het als MSG te schrijven - en vice versa met mapi_message::from_file() gevolgd door mapi_message::save_to_eml().

Stap 1 - Het project opzetten 

git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.git
add_subdirectory(Aspose.Email-FOSS-for-Cpp)
target_link_libraries(your_target PRIVATE AsposeEmailFoss::AsposeEmailFoss)

Stap 2 — Converteer EML naar MSG (File Path)

mapi_message::load_from_eml() het bestand EML analyseert en de eigenschappen ervan blootstelt via De standaard mapi_message Interface - bel save() Om het resultaat als MSG te schrijven:

#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';
    std::cout << "From:    " << message.sender_email_address() << '\n';

    message.save(std::filesystem::path("converted.msg"));
    std::cout << "Saved converted.msg\n";
}

Stap 3 — Converteer EML naar MSG (Stream)

Gebruik de overbelasting van de stroom load_from_eml() wanneer de EML gegevens afkomstig zijn van een netwerk - de socket, geheugenbuffer of een andere std::istream:

#include <fstream>
#include <filesystem>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    std::ifstream eml_stream("message.eml", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(eml_stream);

    message.save(std::filesystem::path("converted.msg"));
}

Stap 4 — Converteer MSG naar EML

Een bestaand MSG bestand laden met mapi_message::from_file(),en vervolgens serialiseren naar EML Format met 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";
}

Stap 5 – Volledige rondreis (EML → MSG→ EML)

Het volgende voorbeeld toont aan dat onderwerp, lichaam, zender, ontvanger en bijlagen allemaal worden bewaard door een volledige rondreis:

#include <filesystem>
#include <iostream>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    const auto msg_path = std::filesystem::path("roundtrip.msg");
    const auto eml_out  = std::filesystem::path("roundtrip.eml");

    // EML → MSG
    auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("original.eml"));
    message.save(msg_path);

    // MSG → EML
    auto reloaded = aspose::email::foss::msg::mapi_message::from_file(msg_path);
    reloaded.save_to_eml(eml_out);

    std::cout << "Subject preserved: " << reloaded.subject() << '\n';
    std::cout << "Attachments: " << reloaded.attachments().size() << '\n';
}

Stap 6 — Converteer naar EML bytes in geheugen

Beide save() en save_to_eml() hebben nul-argument overbelastingen die terugkeren std::vector<std::uint8_t>, nuttig voor het streamen van resultaten naar een netwerkverbinding of Database zonder het bestandssysteem aan te raken:

#include <filesystem>
#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"));

    // In-memory MSG bytes
    const auto msg_bytes = message.save();

    // In-memory EML bytes
    const auto eml_bytes = message.save_to_eml();
}

Veelvoorkomende problemen en oplossingen

load_from_eml() Een goed uitziende bestand. Controleer het bestand gebruikt RFC 5322 CRLF-lijnendeinden. EML bestanden die door sommige tools worden geëxporteerd, kunnen naakt LF gebruiken. Verwacht standaard-conforme lijn eindigingen.

Vermiste bijlagen na de conversie van EML → MSG. Bevestig dat EML standaard bevat MIME multipart/mixed of multipart/related Inline beelden referenced via cid: Deze worden als bijlagen in de MSG gedragen en moeten aanwezig zijn.

HTML lichaam verloren na MSG → EML. HTML-inhoud wordt bewaard tijdens de rondreis Wanneer message.html_body() Niet leeg, maar alleen als het message.body() Het is bevolkt in de de MSG-bron bevat alleen een eenvoudig tekstgedeelte.

save_to_eml() De uitgang van de stream is leeg. Open output streams met std::ios::binary.Tekst-modusstromen corrumperen de MIME structuur in Windows.

Onderwerp bevat ?= Het coderen van artefacten. Dit zijn de RFC 2047 gecodeerde-woord sequenties De bibliotheek bewaart ze als-is. decodeer met een RFC 2047 bibliothiëken Als je een Unicode-onderwerp nodig hebt.

Veelgestelde vragen

Zijn bijlagen bewaard in beide conversierichtingen?

Zowel de EML → MSG als de → de conversies dragen alle MIME bijlagen door de mapi_message Binaire bijlagen worden weergegeven als ruwe bytes in de mapi_attachment::data.

Is het mogelijk om de HTML-lichaam te behouden?

Ja. als de EML een text/html MIME deel, het wordt opgeslagen in de MAPI HTML lichaam eigendom en teruggestuurd door message.html_body() Na het laden.

Kan ik een map van EML bestanden batch-converteren?

Ja. itereren van de directory met std::filesystem::directory_iterator en oproep mapi_message::load_from_eml() Op elk .eml De weg, dan redden met save():

#include <filesystem>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    for (const auto& entry : std::filesystem::directory_iterator("emails/"))
    {
        if (entry.path().extension() == ".eml")
        {
            auto msg = aspose::email::foss::msg::mapi_message::load_from_eml(entry.path());
            auto out = entry.path();
            out.replace_extension(".msg");
            msg.save(out);
        }
    }
}

Wat wordt bewaard tijdens de EML ↔ MSG conversie?

Onderwerp, eenvoudige tekst lichaam, HTML lichaamsnaam en e-mailadres van de afzender, ontvangerslijst en alle MIME bijlagen. IMAP vlaggen, routing kopjes buiten basis transport koppen, en TNEF-gecodeerde gegevens worden niet bewaard.

is het load_from_eml() Een veilige trill?

Elke oproep naar load_from_eml() Een onafhankelijke creatie mapi_message De zaak. u kan het uit meerdere draden tegelijk bellen zolang elke draad zijn eigen draads gebruikt. Het bericht object.

Zie ook

 Nederlands