Como converter o seu nome para C++
Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / O que é o uso de um sistema de controle (sistema de monitoramento) e de uma máquina de mapi_message::load_from_eml() Para importar um arquivo, então mapi_message::save() para escrever como MSG — e vice-versa com mapi_message::from_file() Seguido por mapi_message::save_to_eml().
Passo 1 – Crie o projeto
git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.gitadd_subdirectory(Aspose.Email-FOSS-for-Cpp)
target_link_libraries(your_target PRIVATE AsposeEmailFoss::AsposeEmailFoss)Passo 2 — Converter EML para MSG (Caminho de arquivo)
mapi_message::load_from_eml() analisando o arquivo EML e expondo suas propriedades através de O padrão mapi_message Interface - Chamada save() Para escrever o 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";
}Passo 3 — Converter EML para MSG (Stream)
Use o fluxo de sobrecarga do load_from_eml() Quando os dados são obtidos a partir de uma rede cache, buffer de memória ou outro 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"));
}Passo 4 — Converter MSG para EML
Carregar um arquivo existente com mapi_message::from_file(),Então, você se torna um ser humano. Formato com 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";
}Passo 5 – Acompanhamento completo (EML → MSG→ EML)
O exemplo a seguir demonstra que o sujeito, corpo, remetente, receptor e anexos são preservados através de uma viagem completa:
#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';
}Passo 6 — Converter para EML bytes em memória
Ambos save() e save_to_eml() tem sobrecargas de argumento zero que retornam std::vector<std::uint8_t>, útil para o streaming de resultados para uma conexão de rede ou Base de dados sem tocar no sistema de arquivos:
#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 Comuns e Soluções
load_from_eml() Apenas um arquivo com aparência válida. Verificar o arquivo usa RFC 5322 EML arquivos exportados por algumas ferramentas podem usar LF. A biblioteca pode ser espera linhas de finalização conformes com as normas.
Faltam anexos após a conversão. Confirme que o EML contém padrão MIME multipart/mixed ou multipart/related Imagens de referência.Inline images referenced Via cid: Eles são carregados como anexos no MSG e devem estar presentes.
O corpo HTML perdido após MSG → EML. O conteúdo HTML é preservado durante a viagem de volta Quando message.html_body() Não é um vazio, se message.body() É povoado na fonte MSG, o EML contém apenas uma parte de texto simples.
save_to_eml() O fluxo de saída está vazio. O fluxo de saída aberto com std::ios::binary.Os fluxos de modo de texto corrompem a estrutura MIME no Windows.
O tema contém ?= de codificação dos artefatos. São 2047 palavras em código de seqüências. A biblioteca preserva-os como-é. Decodificação com uma biblioteca RFC 2047 Se você precisar do tema Unicode.
Perguntas Frequentes
Os anexos são preservados em ambas as direções de conversão?
Tanto os anexos de ônibus como os de veículos são transportados por todos os mapi_message Os anexos binários são representados como bytes brutos em mapi_attachment::data.
Será que o seu corpo HTML é preservado?
Se o seu conteúdo contém uma text/html MIME parte, é armazenado no corpo HTML MAPI Propriedade e devolvido por message.html_body() Após o carregamento.
Posso converter em lote um diretório de arquivos do EML?
Sim. Iterar o diretório com std::filesystem::directory_iterator e chamadas mapi_message::load_from_eml() em cada .eml O caminho, então, salva com 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);
}
}
}O que é preservado durante a conversão de EML ↔ MSG?
Assunto, corpo de texto simples, corpos HTML, nome do remetente e endereço de email, lista de destinatários e todos os anexos MIME. IMAP bandeiras, cabeçalhos de roteamento além dos cabeças básicas de transporte e dados codificados pelo TNEF não são preservados.
É load_from_eml() Trilho de segurança?
Cada chamada para load_from_eml() Criar uma independência mapi_message Ação. você Pode ser chamado de vários fios simultaneamente, desde que cada thread use o seu próprio. mensagem de objeto.
