Introduzione

Lavorare con i file Outlook MSG in C++ ha storicamente richiesto l’automazione COM solo per Windows
o librerie di terze parti ingombranti con licenze restrittive. Aspose.Email FOSS per C++
cambia questo: è una libreria pura C++17 senza dipendenze esterne, senza COM, e senza
codice specifico per piattaforme. Si compila identicamente su Linux, macOS e Windows.

La libreria è rilasciata sotto licenza MIT e distribuita come sorgente tramite GitHub. La integri clonando il repository e aggiungendola come sottodirectory CMake — non è necessaria la registrazione a un gestore di pacchetti, e non è necessario pre‑compilare binari.

Questo post illustra il flusso di lavoro principale: leggere un file MSG esistente, ispezionare le sue proprietà, creare un nuovo messaggio programmaticamente e fare il round‑trip tra i formati MSG ed EML.

Caratteristiche principali

Leggi i file MSG esistenti

Usa msg_reader per aprire un file .msg e msg_document per accedere al suo contenuto strutturato.
Entrambe le classi si trovano nello spazio dei nomi aspose::email::foss::msg.

#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"));
auto document = aef::msg::msg_document::from_reader(reader);

msg_reader ha anche un overload from_stream per la lettura da un std::istream, utile nei contesti server‑side o di pipeline in cui i file non sono presenti su disco.

Crea Messaggi Programmaticamente

mapi_message::create produce un nuovo messaggio in memoria con oggetto e corpo. È quindi possibile impostare i dettagli del mittente, aggiungere i destinatari e allegare payload binari o di testo prima di salvare.

#include "aspose/email/foss/msg/mapi_message.hpp"

namespace aef = aspose::email::foss;

auto msg = aef::msg::mapi_message::create(
    "Quarterly status update",
    "Hello team,\n\nPlease find the rollout summary attached.\n\nRegards");

msg.set_sender_name("Build Agent");
msg.set_sender_email_address("build.agent@example.com");
msg.add_recipient("alice@example.com", "Alice Example");
msg.save(std::filesystem::path("output.msg"));

Converti MSG in EML

mapi_message supporta la conversione diretta da MSG a EML tramite il metodo save_to_eml.
L’output EML è conforme a RFC 5322 (MIME), rendendolo compatibile con qualsiasi client di posta standard
o pipeline di elaborazione.

auto loaded = aef::msg::mapi_message::from_file(
    std::filesystem::path("message.msg"), /*strict=*/false);

// Save as EML to a file
loaded.save_to_eml(std::filesystem::path("message.eml"));

// Or capture as bytes
std::vector<std::uint8_t> eml_bytes = loaded.save_to_eml();

Carica da EML

La direzione inversa è altrettanto semplice: load_from_eml legge un file EML
e produce un mapi_message in memoria, che può quindi essere salvato nuovamente in MSG.

auto from_eml = aef::msg::mapi_message::load_from_eml(
    std::filesystem::path("message.eml"));

from_eml.save(std::filesystem::path("restored.msg"));

Accesso CFB a basso livello

Per casi d’uso avanzati — come la lettura di proprietà MAPI grezze non esposte dall’API di alto livello — cfb_reader fornisce accesso diretto al contenitore Compound File Binary che è alla base del formato MSG.

#include "aspose/email/foss/cfb/cfb_reader.hpp"

namespace aef = aspose::email::foss;

auto cfb = aef::cfb::cfb_reader::from_file(std::filesystem::path("message.msg"));
auto storage_ids = cfb.storage_ids();
auto stream_ids  = cfb.stream_ids();

Avvio rapido

Passo 1 — Clona e aggiungi come sottodirectory

git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.git

Nel tuo progetto CMakeLists.txt:

cmake_minimum_required(VERSION 3.26)
project(my_project)

add_subdirectory(Aspose.Email-FOSS-for-Cpp)

add_executable(my_app main.cpp)
target_link_libraries(my_app PRIVATE AsposeEmailFoss::AsposeEmailFoss)

Passo 2 — Includi e usa

#include <iostream>
#include "aspose/email/foss/msg/mapi_message.hpp"

namespace aef = aspose::email::foss;

int main()
{
    // Create a message
    auto msg = aef::msg::mapi_message::create("Hello from C++", "Body text here");
    msg.save(std::filesystem::path("hello.msg"));

    // Round-trip to EML
    auto loaded = aef::msg::mapi_message::from_file(
        std::filesystem::path("hello.msg"), false);
    loaded.save_to_eml(std::filesystem::path("hello.eml"));

    std::cout << "Done\n";
}

Passo 3 — Compilazione

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build

Formati supportati

FormatoEstensioneLetturaScrittura
MSG (Messaggio Outlook).msg✓✓
EML (RFC 5322 / MIME).eml✓✓
CFB (File binario composto).msg, .cfb✓✓

Open Source e Licenze

Aspose.Email FOSS per C++ è rilasciato sotto licenza MIT. Il codice sorgente completo è disponibile su GitHub a aspose-email-foss/Aspose.Email-FOSS-for-Cpp. L’uso commerciale è consentito senza royalty. La libreria non ha dipendenze di runtime oltre a un compilatore C++17 e CMake 3.26 o successivo.

Iniziare