Introduction
Aspose.Email FOSS pour C++ est une nouvelle bibliothèque open-source pour lire, créer et convertir les fichiers Outlook MSG, les messages RFC 5322 EML et les conteneurs Compound File Binary (CFB) sur lesquels le format MSG est basé. Elle est écrite en C++17, ne possède aucune dépendance d’exécution externe, et se compile sur Linux, macOS et Windows via CMake — il n’y a aucune dépendance COM et aucun chemin de code spécifique à une plateforme.
Les fichiers Outlook MSG apparaissent constamment dans les projets d’intégration d’entreprise — pipelines d’archivage, outils de migration, exportations de conformité — mais les lire sans Outlook implique généralement une automatisation COM sous Windows ou une bibliothèque commerciale. Aspose.Email FOSS pour C++ vous offre une alternative portable: une classe mapi_message de haut niveau pour la lecture et la création quotidiennes de messages, ainsi que des classes msg_reader, msg_document et cfb_reader de niveau inférieur pour un accès direct au format de conteneur sous-jacent lorsque cela est nécessaire.
La bibliothèque est distribuée sous forme de source C++17 sous licence MIT et ajoutée à un projet en tant que sous-répertoire CMake, exposant la cible AsposeEmailFoss — aucune inscription à un gestionnaire de paquets et aucun binaire précompilé ne sont requis.
Fonctionnalités clés
Lire les fichiers Outlook MSG
Ouvrez un fichier .msg avec msg_reader::from_file() ou msg_reader::from_stream(). Pour accéder directement aux stockages et flux d’un message, encapsulez le lecteur dans un msg_document avec 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);
Créer des messages de façon programmatique
mapi_message::create() crée un nouveau message en mémoire à partir d’un sujet et d’un corps. Définissez l’expéditeur, ajoutez des destinataires et joignez des charges utiles binaires ou texte avant d’enregistrer avec 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 et EML
mapi_message::save_to_eml() écrit le message actuel sous forme de fichier EML RFC5322, et mapi_message::load_from_eml() en lit un. Les deux sens conservent le sujet, l’expéditeur, les destinataires et les pièces jointes, de sorte qu’un message puisse passer de MSG à EML et inversement sans 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"));
Inspecter les propriétés du message et les pièces jointes
Un mapi_message chargé expose directement ses champs d’en-tête standard — subject(), sender_name(), sender_email_address(), message_class() et internet_message_id() — ainsi que recipients() et attachments() comme vecteurs de mapi_recipient et mapi_attachment. Pour les champs MAPI sans accesseur dédié, get_property_value() lit n’importe quelle propriété par son common_message_property_id et 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));
Accès bas niveau au conteneur CFB
Les fichiers MSG sont stockés à l’intérieur d’un conteneur Compound File Binary (CFB) — le format de stockage structuré également utilisé par les anciens formats binaires d’Office. cfb_reader ouvre le conteneur brut et expose directement son arbre de répertoires: storage_ids() et stream_ids() répertorient chaque entrée, directory_entry_count() indique le total, et header() renvoie la disposition des secteurs du conteneur. Ceci est utile lorsque vous avez besoin de données MAPI que le mapi_message API ne révèle pas.
#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';
Démarrage rapide
Ajoutez la bibliothèque à votre projet :
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)Ensuite, créez un message, enregistrez-le sous MSG, puis effectuez un aller-retour vers 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;
}
Formats pris en charge
| Format | Extension | Lire | Écrire |
|---|---|---|---|
| Message Outlook (MSG) | .msg | ✓ | ✓ |
| EML (RFC 5322 / MIME) | .eml | ✓ | ✓ |
| Fichier binaire composé (CFB) | .cfb | ✓ | ✓ |
Open source et licence
Aspose.Email FOSS pour C++ est publié sous licence MIT. Le code source complet est disponible à aspose-email-foss/Aspose.Email-FOSS-for-Cpp, et l’utilisation commerciale est autorisée sans redevances. La bibliothèque n’a aucune dépendance d’exécution autre qu’un compilateur C++17 et CMake 3.26 ou version ultérieure.
