Conversão de EML e MSG

Conversão de EML e MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) e a) MSG (Outlook MAPI) formatos usando mapi_message.O caminho de conversão é: load_from_eml() → em memória mapi_message → save() para EML→MSG, e from_file() / from_stream() → save_to_eml() para o MSG→EML.

Conversão de EML em MSG

Carregar um ficheiro EML com: mapi_message::load_from_eml(), em seguida, serializam para MSG com 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() analisa a estrutura MIME e preenche o assunto do MAPI, texto simples corpo, HTML corpo , identidade do remetente, lista de destinatários e todas as partes anexas.

Conversão de MSG em EML

Carregar um ficheiro MSG com o mapi_message::from_file(),Então , liga-me . 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";
}

Conversão baseada em fluxo

Todos os quatro métodos pertinentes aceitam: std::istream / std::ostream sobrecargas para: Processamento de tipo pipeline sem tocar no sistema de ficheiros:

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

Sempre abertos a fluxos com std::ios::binary.Fluxos de modo texto traduzem finais de linha . no Windows, corromper dados CFB binários.

Conversão na memória (Bytes)

save() e a) save_to_eml() ambos têm sobrecargas de argumento zero retornando std::vector<std::uint8_t>.Use estes para evitar todas as entradas/saídas do sistema de ficheiros:

#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...
}

Conversão de diretório por lotes

Iterar um diretório com: std::filesystem::directory_iterator para converter todos os .eml Arquivos em uma passagem:

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

Dicas e melhores práticas

• Abrir todos os fluxos de arquivos com: std::ios::binary tanto a entrada como a saída.
• Preferência load_from_eml(path) sobre a sobrecarga do fluxo quando você tem um caminho; o caminho A sobrecarga lida com a abertura de arquivos internamente e é um pouco mais simples.
• Use os bytes de sobrecarga (save() e a) save_to_eml() com não args) quando os dados de tubulação entre serviços para evitar arquivos temporários.
• O assunto, corpo, HTML corpo , remetente, destinatários e MIME anexos são preservados durante a viagem completa de ida e volta.
• As bandeiras IMAP, cabeçalhos de roteamento e conteúdo codificado por TNEF não são transferidos através da conversão.

Problemas comuns

FAQ

O EML → MSG preserva o corpo HTML?

Sim, um. text/html A parte MIME é armazenada na propriedade corpo do HTML MAPI e é acessível. via: message.html_body() após a carga.

Os apegos são preservados em ambas as direcções?

Sim. Todas as partes de anexo MIME são transportadas através do sistema de ligação Mime, que é o principal componente da unidade de fixação. mapi_message Lista de anexos. Os dados de anexo binário estão disponíveis como: attachment.data (a) std::vector<std::uint8_t>).

Posso converter um único EML para vários formatos de saída simultaneamente?

Carregar o EML uma vez com a máquina de filtração. load_from_eml(),Então , chama os dois . save() e a) save_to_eml() na mesma memória interna. mapi_message Objeto.

É o que é? load_from_eml() Segura para fio?

Cada chamada cria um sistema independente de informação. mapi_message instância. múltiplos tópicos podem chamar load_from_eml() simultaneamente, desde que cada thread utilize o seu próprio objeto de saída.

O que acontece com as mensagens sem texto simples?

Se o EML conter apenas uma text/html parte, message.body() retorna uma sequência vazia e a) message.html_body() ambos são preservados através de MSG. serialização.

Resumo de referência da API