Introducción

Aspose.Email FOSS for C++ es una nueva biblioteca de código abierto para leer, crear y convertir archivos Outlook MSG, mensajes RFC 5322 EML y los contenedores Compound File Binary (CFB) sobre los que se basa el formato MSG. Está escrita en C++17, no tiene dependencias externas en tiempo de ejecución y se compila en Linux, macOS y Windows mediante CMake — no hay dependencia de COM ni rutas de código específicas de plataforma.

Los archivos Outlook MSG aparecen constantemente en el trabajo de integración empresarial — pipelines de archivado, herramientas de migración, exportaciones de cumplimiento — pero leerlos sin Outlook suele requerir automatización COM en Windows o una biblioteca comercial. Aspose.Email FOSS for C++ le ofrece una alternativa portátil: una clase de alto nivel mapi_message para la lectura y creación cotidiana de mensajes, además de clases de bajo nivel msg_reader, msg_document y cfb_reader para acceso directo al formato de contenedor subyacente cuando lo necesite.

La biblioteca se distribuye como código fuente C++17 bajo la licencia MIT y se agrega a un proyecto como un subdirectorio de CMake, exponiendo el objetivo AsposeEmailFoss — no se requiere registro en un gestor de paquetes ni binarios precompilados.

Características clave

Leer archivos Outlook MSG

Abra un archivo .msg con msg_reader::from_file() o msg_reader::from_stream(). Para acceder directamente a los almacenes y flujos de un mensaje, envuelva el lector en un msg_document con 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);

Crear mensajes programáticamente

mapi_message::create() crea un nuevo mensaje en memoria a partir de un asunto y un cuerpo. Establezca el remitente, añada destinatarios y adjunte cargas útiles binarias o de texto antes de guardarlo con 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"));

Convertir entre MSG y EML

mapi_message::save_to_eml() escribe el mensaje actual como un archivo EML RFC 5322, y mapi_message::load_from_eml() lo lee de nuevo. Ambas direcciones conservan el asunto, el remitente, los destinatarios y los adjuntos, de modo que un mensaje puede trasladarse entre MSG y EML sin 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"));

Inspeccionar propiedades y adjuntos del mensaje

Un mapi_message cargado expone sus campos de encabezado estándar directamente — subject(), sender_name(), sender_email_address(), message_class() y internet_message_id() — junto con recipients() y attachments() como vectores de mapi_recipient y mapi_attachment. Para los campos MAPI sin un accesador dedicado, get_property_value() lee cualquier propiedad por su common_message_property_id y 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));

Acceso de bajo nivel al contenedor CFB

Los archivos MSG se almacenan dentro de un contenedor Compound File Binary (CFB), el formato de almacenamiento estructurado también utilizado por los formatos binarios heredados de Office. cfb_reader abre el contenedor crudo y expone su árbol de directorios directamente: storage_ids() y stream_ids() enumeran cada entrada, directory_entry_count() informa el total, y header() devuelve la disposición de sectores del contenedor. Esto es útil cuando necesita datos MAPI que el mapi_message API no muestra.

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

Inicio rápido

Agrega la biblioteca a tu proyecto:

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)

Luego crea un mensaje, guárdalo como MSG y conviértelo de ida y vuelta a 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 compatibles

FormatoExtensiónLeerEscribir
Mensaje de Outlook (MSG).msg✓✓
EML (RFC 5322 / MIME).eml✓✓
Archivo binario compuesto (CFB).cfb✓✓

Código abierto y licencias

Aspose.Email FOSS para C++ se publica bajo la licencia MIT. El código fuente completo está disponible en aspose-email-foss/Aspose.Email-FOSS-for-Cpp, y el uso comercial está permitido sin regalías. La biblioteca no tiene dependencias en tiempo de ejecución más allá de un compilador C++17 y CMake 3.26 o posterior.

Comenzando

Recursos relacionados