EML y MSG Conversión

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) y MSG (Outlook MAPI) formatos que utilizan mapi_message.El camino de conversión es: load_from_eml() En memoria mapi_message → save() para EML→MSG, y from_file() / from_stream() → save_to_eml() Para MSG → EML.

Convertir EML en MSG

Cargar un archivo EML con mapi_message::load_from_eml(),Entonces, se puede ver en MSG con 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() parsa la estructura MIME y populaba el tema MAPI, texto plano cuerpo, cuerpo HTML, identidad de envío, lista de destinatarios y todas las partes de anexos.

Convertir MSG en EML

Cargar un archivo MSG con mapi_message::from_file(),Y luego llamar 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";
}

Conversión basada en flujo

Todos los cuatro métodos relevantes aceptan std::istream / std::ostream sobrecarga para Procesamiento de estilo de tubo sin tocar el sistema de archivos:

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

Siempre abierto el flujo con std::ios::binary.Texto-mode flujos traducir fin de línea Windows, corrompendo los datos binarios CFB.

Conversión de memoria (Bytes)

save() y save_to_eml() Ambos tienen un argumento de cero sobrecarga de vuelta std::vector<std::uint8_t>.Utilice estos para evitar todos los sistemas de archivos 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...
}

Conversión de directorio Batch

Toma un directorio con std::filesystem::directory_iterator Convertir todo .eml Los archivos en un solo paso:

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

Consejos y mejores prácticas

Abre todos los archivos con std::ios::binary - Tanto la entrada como la salida.
Preferimos load_from_eml(path) sobre el flujo de sobrecarga cuando tienes un camino; el camino El sobrecargo maneja la apertura de archivos internamente y es un poco más simple.
El uso de las bajas (save() y save_to_eml() sin args) cuando se ponen datos entre los servicios para evitar archivos temporales.
El sujeto, el cuerpo, la estructura HTML, los enviadores, receptores y los anexos MIME se conservan a través del viaje completo.
Las banderas de IMAP, los header de itinerancia y el contenido codificado por TNEF no se llevan a cabo mediante la conversión.

Problemas comunes

Problemas	Causas	Fixado
`load_from_eml` Se lanza en un archivo válido	Finales de línea no-CRLF en EML	Asegúrese de que EML utiliza RFC 5322 CRLF; algunas herramientas de exportación escriben LF
Los anexos que se quedan después de EML → MSG	No estándar MIME codificación de adhesivos	Verificar el uso de EML `multipart/mixed` Con la norma `Content-Disposition: attachment`
El cuerpo HTML vacío después de MSG → EML	La fuente MSG sólo tiene un cuerpo de texto plano	Verificar `message.html_body()`;· si está vacío, solo se ha almacenado texto plano
La producción de flujo es corrupta	El flujo se abre en modo de texto	Siempre usar `std::ios::binary`
Subjetos de muestra `?=` secuencias	RFC 2047 en código de palabra en EML original	Decodificación con una biblioteca RFC 2047; la biblioteca conserva el formato codificado

FAQ

¿Es EML → MSG el cuerpo HTML?

Sí a. text/html La parte MIME se almacena en la propiedad del cuerpo HTML de MAPI y es accesible. por vía message.html_body() Después de la carga.

¿Se conservan los adhesivos en ambas direcciones?

Todos los elementos de la MIME se llevan a través del mapi_message Lista de adhesivos. Los datos de adhesivos binarios están disponibles como attachment.data (a) a std::vector<std::uint8_t>).

¿Puedo convertir un único EML en varios formatos de salida simultáneamente?

Y. Cargue el EML una vez con load_from_eml(),Y llamar a ambos save() y save_to_eml() En la misma memoria mapi_message El objeto.

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

Cada llamada crea una independencia. mapi_message Por ejemplo, las líneas múltiples pueden llamar load_from_eml() simultáneamente mientras cada hilo utilice su propio objeto de salida.

¿Qué pasa con los mensajes sin un cuerpo de texto plano?

Si el EML contiene sólo una text/html parte de la, message.body() devolver una línea vacía y message.html_body() Tiene el contenido HTML. ambos se conservan a través de MSG La serialización.

Sumación de referencia API

Clase / Método	Descripción
`mapi_message::load_from_eml(path)`	Compartir un archivo EML en una `mapi_message`
`mapi_message::load_from_eml(stream)`	El EML de una `std::istream`
`mapi_message::save(path)`	Serialización `mapi_message` En el archivo MSG
`mapi_message::save(stream)`	Escribe los bajos de MSG a un `std::ostream`
`mapi_message::save()`	Retorno a MSG como `std::vector<std::uint8_t>`
`mapi_message::from_file(path)`	Cargar un archivo MSG en una `mapi_message`
`mapi_message::from_stream(stream)`	Cargar MSG desde una `std::istream`
`mapi_message::save_to_eml(path)`	Escribe EML a un camino de archivo
`mapi_message::save_to_eml(stream)`	Escribe los bajos EML a un `std::ostream`
`mapi_message::save_to_eml()`	Retorno de EML como `std::vector<std::uint8_t>`

Ver también

Aspose.Email for C++ — Enterprise Documentation

EML y MSG Conversión