Introdução
Aspose.Email FOSS para C++ é uma nova biblioteca de código aberto para ler, criar e converter arquivos Outlook MSG, mensagens RFC 5322 EML e os contêineres Compound File Binary (CFB) nos quais o formato MSG é baseado. É escrita em C++17, não tem dependências externas de tempo de execução e compila em Linux, macOS e Windows via CMake — não há dependência de COM nem caminho de código específico de plataforma.
Arquivos Outlook MSG aparecem constantemente em trabalhos de integração corporativa — pipelines de arquivamento, ferramentas de migração, exportações de conformidade — mas lê-los sem o próprio Outlook geralmente exigia automação COM no Windows ou uma biblioteca comercial. Aspose.Email FOSS para C++ oferece uma alternativa portátil: uma classe mapi_message de alto nível para leitura e criação diária de mensagens, além das classes de nível mais baixo msg_reader, msg_document e cfb_reader para acesso direto ao formato de contêiner subjacente quando necessário.
A biblioteca é distribuída como código-fonte C++17 sob a licença MIT e adicionada a um projeto como um subdiretório CMake, expondo o alvo AsposeEmailFoss — não é necessário registro em gerenciador de pacotes nem binários pré-compilados.
Principais Recursos
Ler Arquivos Outlook MSG
Abrir um arquivo .msg com msg_reader::from_file() ou msg_reader::from_stream(). Para acessar diretamente os armazenamentos e fluxos de uma mensagem, envolva o leitor em um msg_document com msg_document::from_reader().
#include "aspose/email/foss/msg/msg_reader.hpp"
#include "aspose/email/foss/msg/msg_document.hpp"
#include <filesystem>
namespace aef = aspose::email::foss;
auto reader = aef::msg::msg_reader::from_file(
std::filesystem::path("message.msg"), /*strict=*/false);
auto document = aef::msg::msg_document::from_reader(reader);
Criar Mensagens Programaticamente
mapi_message::create() cria uma nova mensagem em memória a partir de um assunto e corpo. Defina o remetente, adicione destinatários e anexe cargas binárias ou de texto antes de salvar com save().
#include "aspose/email/foss/msg/mapi_message.hpp"
#include <filesystem>
namespace aef = aspose::email::foss;
auto message = aef::msg::mapi_message::create(
"Quarterly status update", "Hello team,\n\nRollout summary attached.");
message.set_sender_name("Build Agent");
message.set_sender_email_address("build.agent@example.com");
message.add_recipient("alice@example.com", "Alice Example");
message.add_recipient("carol@example.com", "Carol Example",
aef::msg::mapi_message::recipient_type_cc);
message.add_attachment("report.txt", std::vector<std::uint8_t>{'o', 'k'}, "text/plain");
message.save(std::filesystem::path("output.msg"));
Converter Entre MSG e EML
mapi_message::save_to_eml() grava a mensagem atual como um arquivo EML RFC 5322, e mapi_message::load_from_eml() lê um de volta. Ambas as direções preservam o assunto, remetente, destinatários e anexos, de modo que uma mensagem pode ser transferida entre MSG e EML sem o Outlook.
auto message = aef::msg::mapi_message::from_file(
std::filesystem::path("message.msg"), /*strict=*/false);
message.save_to_eml(std::filesystem::path("message.eml"));
auto restored = aef::msg::mapi_message::load_from_eml(std::filesystem::path("message.eml"));
restored.save(std::filesystem::path("restored.msg"));
Inspecionar Propriedades e Anexos da Mensagem
Um mapi_message carregado expõe seus campos de cabeçalho padrão diretamente — subject(), sender_name(), sender_email_address(), message_class() e internet_message_id() — juntamente com recipients() e attachments() como vetores de mapi_recipient e mapi_attachment. Para campos MAPI sem acessador dedicado, get_property_value() lê qualquer propriedade pelo seu common_message_property_id e property_type_code.
#include "aspose/email/foss/msg/mapi_message.hpp"
#include "aspose/email/foss/msg/common_message_property_id.hpp"
#include "aspose/email/foss/msg/property_type_code.hpp"
#include <iostream>
namespace aef = aspose::email::foss;
template <typename E>
constexpr auto to_underlying(E value) noexcept {
return static_cast<std::underlying_type_t<E>>(value);
}
auto message = aef::msg::mapi_message::from_file(
std::filesystem::path("message.msg"), /*strict=*/false);
std::cout << "Subject: " << message.subject() << '\n';
std::cout << "From: " << message.sender_name()
<< " <" << message.sender_email_address() << ">\n";
std::cout << "Recipients: " << message.recipients().size() << '\n';
for (const auto& attachment : message.attachments()) {
std::cout << "- " << attachment.filename
<< " (" << attachment.mime_type << ", "
<< attachment.data.size() << " bytes)\n";
}
const auto display_cc = message.get_property_value(
to_underlying(aef::msg::common_message_property_id::display_cc),
to_underlying(aef::msg::property_type_code::ptyp_string));
Acesso de Baixo Nível ao Contêiner CFB
Arquivos MSG são armazenados dentro de um contêiner Compound File Binary (CFB) — o formato de armazenamento estruturado também usado pelos formatos binários legados do Office. cfb_reader abre o contêiner bruto e expõe sua árvore de diretórios diretamente: storage_ids() e stream_ids() listam cada entrada, directory_entry_count() relata o total e header() devolve o layout de setores do contêiner. Isso é útil quando você precisa de dados MAPI que o mapi_message API não expõe.
#include "aspose/email/foss/cfb/cfb_reader.hpp"
#include <iostream>
namespace aef = aspose::email::foss;
auto cfb = aef::cfb::cfb_reader::from_file(std::filesystem::path("message.msg"));
std::cout << "Directory entries: " << cfb.directory_entry_count() << '\n';
std::cout << "Storages: " << cfb.storage_ids().size() << '\n';
std::cout << "Streams: " << cfb.stream_ids().size() << '\n';
Início Rápido
Adicione a biblioteca ao seu projeto:
git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.git# CMakeLists.txt
add_subdirectory(Aspose.Email-FOSS-for-Cpp)
target_link_libraries(your_target PRIVATE AsposeEmailFoss::AsposeEmailFoss)Em seguida, crie uma mensagem, salve-a como MSG e faça o round-trip para EML:
#include "aspose/email/foss/msg/mapi_message.hpp"
#include <filesystem>
#include <vector>
#include <cstdint>
namespace aef = aspose::email::foss;
int main() {
auto message = aef::msg::mapi_message::create("Hello from C++", "Body text here");
message.set_sender_name("Alice");
message.set_sender_email_address("alice@example.com");
message.add_recipient("bob@example.com", "Bob");
message.add_attachment("note.txt", std::vector<std::uint8_t>{'a', 'b', 'c'}, "text/plain");
message.save(std::filesystem::path("hello.msg"));
auto loaded = aef::msg::mapi_message::from_file(
std::filesystem::path("hello.msg"), /*strict=*/false);
loaded.save_to_eml(std::filesystem::path("hello.eml"));
return 0;
}
Formatos Compatíveis
| Formato | Extensão | Ler | Escrever |
|---|---|---|---|
| Mensagem do Outlook (MSG) | .msg | ✓ | ✓ |
| EML (RFC 5322 / MIME) | .eml | ✓ | ✓ |
| Arquivo Binário Composto (CFB) | .cfb | ✓ | ✓ |
Código Aberto e Licenciamento
Aspose.Email FOSS para C++ é distribuído sob a licença MIT. O código-fonte completo está disponível em aspose-email-foss/Aspose.Email-FOSS-for-Cpp, e o uso comercial é permitido sem royalties. A biblioteca não tem dependências em tempo de execução além de um compilador C++17 e CMake 3.26 ou superior.
