Introduction

Travailler avec des fichiers Outlook MSG en C++ a historiquement nécessité une automatisation COM uniquement sous Windows
ou des bibliothèques tierces lourdes avec des licences restrictives. Aspose.Email FOSS for C++ change cela : c’est une bibliothèque pure C++17 sans dépendances externes, sans COM, et sans
code spécifique à une plateforme. Elle se compile de manière identique sous Linux, macOS et Windows.

La bibliothèque est publiée sous licence MIT et distribuée sous forme de source via GitHub. Vous l’intégrez en clonant le dépôt et en l’ajoutant comme sous‑répertoire CMake — aucune inscription à un gestionnaire de paquets n’est requise, et aucun binaire n’a besoin d’être pré‑compilé.

Cet article décrit le flux de travail principal : lecture d’un fichier MSG existant, inspection de ses propriétés, création d’un nouveau message par programmation, et conversion aller‑retour entre les formats MSG et EML.

Fonctionnalités clés

Lire les fichiers MSG existants

Utilisez msg_reader pour ouvrir un fichier .msg et msg_document pour accéder à son contenu structuré. Les deux classes se trouvent dans l’espace de noms 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 dispose également d’une surcharge from_stream pour la lecture depuis un std::istream, ce qui est utile dans les contextes côté serveur ou de pipeline où les fichiers ne sont pas présents sur le disque.

Créer des messages par programme

mapi_message::create crée un nouveau message en mémoire avec un sujet et un corps. Vous pouvez ensuite définir les détails de l’expéditeur, ajouter des destinataires et joindre des charges utiles binaires ou textuelles avant d’enregistrer.

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

Convertir MSG en EML

mapi_message prend en charge la conversion directe de MSG en EML via la méthode save_to_eml.
La sortie EML est conforme à la RFC 5322 (MIME), ce qui la rend compatible avec tout client de messagerie standard
ou toute chaîne de traitement.

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();

Charger depuis EML

La direction inverse est tout aussi simple : load_from_eml lit un fichier EML et produit un mapi_message en mémoire, qui peut ensuite être enregistré de nouveau au format MSG.

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

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

Accès CFB de bas niveau

Pour les cas d’utilisation avancés — tels que la lecture des propriétés MAPI brutes non exposées par l’API de haut niveau — cfb_reader donne un accès direct au conteneur Compound File Binary qui sous-tend le format 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();

Démarrage rapide

Étape 1 — Cloner et ajouter comme sous‑répertoire

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

Dans votre projet 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)

Étape 2 — Inclure et utiliser

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

Étape 3 — Construction

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

Formats pris en charge

FormatExtensionLireÉcrire
MSG (Outlook Message).msg✓✓
EML (RFC 5322 / MIME).eml✓✓
CFB (Compound File Binary).msg, .cfb✓✓

Open Source et licences

Aspose.Email FOSS for C++ est publié sous licence MIT. Le code source complet est disponible
sur GitHub à aspose-email-foss/Aspose.Email-FOSS-for-Cpp.
L’utilisation commerciale est autorisée sans redevances. La bibliothèque n’a aucune dépendance d’exécution
au-delà d’un compilateur C++17 et de CMake 3.26 ou ultérieur.

Premiers pas