Com convertir el C++ en C#

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / El seu nom és: «Plaça de la Muntanya» (en castellà). mapi_message::load_from_eml() Importació d’un El fitxer, després mapi_message::save() per escriure-ho com a MSG — i viceversa amb mapi_message::from_file() Segueix per mapi_message::save_to_eml().

Pas 1 - Establir el projecte

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)

Pas 2 — Convertir EML a {PATGE DE FILS)

mapi_message::load_from_eml() Descarrega el fitxer i exposa les seves propietats a través de El estàndard mapi_message Interfície: CALL save() Escriu el resultat com a MSG:

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

Pas 3 — Convertir EML a MSG (Stream)

Utilitzar el flux de sobrecàrrega del load_from_eml() Quan les dades provenen d’una xarxa socket, buffer de memòria o un altre 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"));
}

Pas 4 — Convertir MSG a EML

Carregar un arxiu MSG existent amb mapi_message::from_file(),i després serialitzar-se a EML Format amb 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";
}

Pas 5 - Full Round-Trip (EML → MSG→ EML)

L’exemple següent demostra que el subjecte, el cos, l’enviador, els receptors i els adjunts es conserven tots a través d’un viatge complet:

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

Pas 6 — Convertir a EML bytes en memòria

Tots dos save() i save_to_eml() Hi ha sobrecàrregues d’arguments zero que tornen std::vector<std::uint8_t>, útil per a la transmissió de resultats a una connexió de xarxa o Base de dades sense tocar el sistema d’arxius:

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

Problemes comuns i solucions

load_from_eml() Es tracta d’un fitxer de caràcter valent. Verifica el fitxer utilitza RFC 5322 Els arxius EML exportats per algunes eines poden utilitzar LF nu. La biblioteca Es preveu que s’acabin les línies de conformitat.

Manca d’adjunts després de EML → MSG conversió. Confirmar que el EML conté estàndard MIME multipart/mixed o multipart/related Imatges de referència.Inline images referenced Via cid: Són els que es troben en el lloc de la trobada i han d’estar presents.

El cos HTML perdut després de MSG → EML. El contingut HTML es conserva durant el viatge de ronda. Quan message.html_body() No és un buit, si no message.body() Està poblada en la La font MSG, la EML només contindrà una part de text simple.

save_to_eml() El flux de sortida és buit. El flux de sortida obert amb std::ios::binary.Els fluxos de text corrompen l’estructura MIME en Windows.

El tema conté ?= Codificació dels artefactes. Aquestes són les seqüències de paraules codificades 2047 RFC La biblioteca els conserva com a tals.Decodeu-los amb una biblioteca RFC 2047 Si necessites un codi Unicode.

Preguntes freqüents

Es conserven els enllaços en ambdues direccions de conversió?

Tant les conversions de EML → MSG com les deMSG transporten tots els enllaços a través del mapi_message Els enllaços binaris es representen com a bytes en brut. mapi_attachment::data.

¿Es conserva el cos HTML?

Si el contingut de la lletra conté un text/html MIME part, s’emmagatzema en el cos HTML de MAPI Propietat i retornat per message.html_body() Després de la càrrega.

Puc convertir un batxillerat en un directori de fitxers?

Iterar el directori amb std::filesystem::directory_iterator i trucada mapi_message::load_from_eml() Cada un .eml El camí, després de salvar-se 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);
        }
    }
}

Què es conserva durant la conversió?

Subjecte, cos de text simple, corpus HTML, nom i adreça d’enviament, llista de destinataris i tots els annexos MIME. IMAP banderes, encapçalaments de rutes més enllà dels encapsuladors bàsics de transport i dades codificades per TNEF no es conserven.

és `load_from_eml()` El segell?

Cada trucada a load_from_eml() Creació d’una independència mapi_message La sentència. tu Pot trucar des de múltiples fils simultàniament sempre que cada fil utilitzi el seu propi. El missatge objecte.