Cómo convertir EML en MSG en C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / MIME y MSG (Outlook MAPI) formatos. mapi_message::load_from_eml() Para importar una El archivo EML, y luego mapi_message::save() para escribirlo como MSG - y viceversa con el mapi_message::from_file() Seguido por mapi_message::save_to_eml().

Paso 1 - Configurar el proyecto

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)

Paso 2 - Convertir EML en MSG (Path de archivo)

mapi_message::load_from_eml() parse el archivo EML y exponer sus propiedades a través de la El estándar mapi_message Interfaz de llamadas save() Para escribir el resultado como 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";
}

Paso 3 - Convertir EML en MSG (Stream)

Utilice el flujo de sobrecarga de load_from_eml() Cuando los datos EML vienen de una red cajón, buffer de memoria o otro 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"));
}

Paso 4 - Convertir MSG en EML

Cargar un archivo MSG existente con mapi_message::from_file(),Entonces, se puede ser serializado a EML. Formato con 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";
}

Paso 5 – Full Round-Trip (EML → MSG → EML)

El siguiente ejemplo demuestra que el sujeto, cuerpo, enviador, destinatarios y anexos se conservan todos a través de un completo recorrido:

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

Paso 6 - Convertir en EML Bytes en memoria

Ambos save() y save_to_eml() Tiene un argumento de cero que vuelve a std::vector<std::uint8_t>, útil para los resultados de streaming a una conexión de red o Base de datos sin tocar el sistema de archivos:

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

Problemas y soluciones comunes

load_from_eml() Se lanza en un archivo EML válido. Verificar el archivo utilizando RFC 5322 Los archivos EML exportados por algunas herramientas pueden usar el LF. La biblioteca Se espera que se acabe con las líneas de conformidad.

Los anexos que se quedan después de la conversión EML a MSG. Confirmar que el EML contiene estándar MIME multipart/mixed o multipart/related Imágenes de la línea. enlaces referenciadas por vía cid: Se lleva como adhesivos en el MSG y debe estar presente.

El cuerpo HTML se perdió después de MSG → EML. El contenido HTML se conserva a través del circuito redondas. Cuando message.html_body() No es vacío, si solo message.body() Se ha hablado en el La fuente MSG, el EML sólo contendrá una parte de texto plano.

save_to_eml() La salida de la corriente es vacía. Las entradas de salida abiertas con std::ios::binary.Los flujos de modo de texto corrompen la estructura MIME en Windows.

El tema contiene ?= codificación de artefactos. Se trata de secuencias de palabras codificadas RFC 2047 La biblioteca los conserva como. decodificación con una biblioteca RFC 2047 Si necesitas el tema Unicode.

Preguntas frecuentes

¿Se conservan los adhesivos en ambas direcciones de conversión?

Tanto EML → MSG y MSM → las conversiones de EMM llevan todos los adjetivos MIME a través del mapi_message listas de adhesivos. los adjetos binarios se representan como bajetas crudas en el mapi_attachment::data.

¿Es EML → MSG el cuerpo HTML?

Si el EML contiene una text/html parte MIME, se almacena en el cuerpo HTML de la MAPI propiedad y devuelta por message.html_body() Después de la carga.

¿Puedo batch-convertir un directorio de archivos EML?

Y. El directorio se encuentra con std::filesystem::directory_iterator y llamar mapi_message::load_from_eml() En cada uno de los .eml El camino, y luego salvar con 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é se conserva durante la conversión EML ↔ MSG?

Subjeto, cuerpo de texto plano, corpo HTML, nombre del envío y dirección de correo electrónico, lista de destinatarios y todos los anexos MIME. banderas IMAP, encabezados de ruta más allá de las enclaves básicas de transporte, y datos codificados por TNEF no se conservan.

Es `load_from_eml()` ¿Seguridad de la TED?

Cada llamado a load_from_eml() Crea una independencia mapi_message El caso. tú puede llamarlo desde múltiples filas simultáneamente mientras cada fila utiliza su propia Objeto de mensaje.