Introductie
Aspose.Email FOSS for C++ is een nieuwe open-source bibliotheek voor het lezen, maken en converteren van Outlook MSG-bestanden, RFC 5322 EML-berichten, en de Compound File Binary (CFB) containers waar het MSG-formaat op is gebaseerd. Het is geschreven in C++17, heeft geen externe runtime-afhankelijkheden, en bouwt op Linux, macOS, en Windows via CMake — er is geen COM-afhankelijkheid en geen platformspecifieke code-pad.
Outlook MSG-bestanden komen continu voor in enterprise-integratiewerk — archiverings-pipelines, migratietools, compliance-exports — maar ze lezen zonder Outlook zelf betekende meestal COM-automatisering op Windows of een commerciële bibliotheek. Aspose.Email FOSS voor C++ biedt u een draagbaar alternatief: een high-level mapi_message-klasse voor alledaags berichtenlezen en -creëren, plus low-level msg_reader, msg_document en cfb_reader klassen voor directe toegang tot het onderliggende containerformaat wanneer u dat nodig heeft.
De bibliotheek wordt gedistribueerd als C++17-broncode onder de MIT-licentie en aan een project toegevoegd als een CMake-subdirectory, waarmee het AsposeEmailFoss-doel wordt blootgesteld — er is geen registratie bij een package-manager en geen vooraf gebouwde binaries vereist.
Belangrijkste kenmerken
Outlook MSG-bestanden lezen
Open een .msg-bestand met msg_reader::from_file() of msg_reader::from_stream(). Om direct toegang te krijgen tot de opslaglocaties en streams van een bericht, wikkel de lezer in een msg_document met 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);
Berichten programmatisch maken
mapi_message::create() maakt een nieuw bericht in het geheugen aan op basis van een onderwerp en tekst. Stel de afzender in, voeg geadresseerden toe en koppel binaire of tekstuele payloads voordat u opslaat met 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"));
Converteren tussen MSG en EML
mapi_message::save_to_eml() schrijft het huidige bericht als een RFC 5322 EML-bestand, en mapi_message::load_from_eml() leest er een terug. Beide richtingen behouden het onderwerp, de afzender, geadresseerden en bijlagen, zodat een bericht kan wisselen tussen MSG en EML zonder 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"));
Inspecteer bericht-eigenschappen en bijlagen
Een geladen mapi_message maakt zijn standaard header-velden direct beschikbaar — subject(), sender_name(), sender_email_address(), message_class() en internet_message_id() — samen met recipients() en attachments() als vectoren van mapi_recipient en mapi_attachment. Voor MAPI-velden zonder een specifieke accessor leest get_property_value() elke eigenschap via zijn common_message_property_id en 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));
Toegang tot CFB-container op laag niveau
MSG-bestanden worden opgeslagen in een Compound File Binary (CFB)-container — het structured-storage-formaat dat ook door legacy Office-binaire formaten wordt gebruikt. cfb_reader opent de ruwe container en maakt de directory-boom direct zichtbaar: storage_ids() en stream_ids() geven elke entry weer, directory_entry_count() rapporteert het totaal, en header() retourneert de sector-indeling van de container. Dit is handig wanneer u MAPI-gegevens nodig heeft die de mapi_message API niet blootlegt.
#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';
Snelstart
Voeg de bibliotheek toe aan uw project:
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)Maak vervolgens een bericht, sla het op als MSG en voer een round-trip uit naar 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;
}
Ondersteunde formaten
| Formaat | Extensie | Lezen | Schrijven |
|---|---|---|---|
| Outlook-bericht (MSG) | .msg | ✓ | ✓ |
| EML (RFC 5322 / MIME) | .eml | ✓ | ✓ |
| Compound File Binary (CFB) | .cfb | ✓ | ✓ |
Open source & licenties
Aspose.Email FOSS voor C++ wordt uitgebracht onder de MIT-licentie. De volledige broncode is beschikbaar op aspose-email-foss/Aspose.Email-FOSS-for-Cpp, en commercieel gebruik is toegestaan zonder royalty’s. De bibliotheek heeft geen runtime-afhankelijkheden behalve een C++17-compiler en CMake3.26 of hoger.
