Introducere
Aspose.Email FOSS pentru C++ este o bibliotecă nouă open-source pentru citirea, crearea și conversia fișierelor Outlook MSG, mesajelor RFC 5322 EML și a containerelor Compound File Binary (CFB) pe care se bazează formatul MSG. Este scrisă în C++17, nu are dependențe externe la runtime și se compilează pe Linux, macOS și Windows prin CMake — nu există dependență de COM și nici un traseu de cod specific platformei.
Fișierele Outlook MSG apar în mod constant în lucrările de integrare la nivel enterprise — conductele de arhivare, instrumentele de migrare, exporturile de conformitate — dar citirea lor fără Outlook însuși a însemnat de obicei automatizare COM pe Windows sau o bibliotecă comercială. Aspose.Email FOSS pentru C++ îți oferă o alternativă portabilă: o clasă mapi_message de nivel înalt pentru citirea și crearea zilnică a mesajelor, plus clase de nivel inferior msg_reader, msg_document și cfb_reader pentru acces direct la formatul containerului de bază atunci când ai nevoie.
Biblioteca este distribuită ca sursă C++17 sub licența MIT și adăugată unui proiect ca subdirector CMake, expunând ținta AsposeEmailFoss — nu este necesară înregistrarea în managerul de pachete și nu sunt necesare binare preconstruite.
Funcționalități cheie
Citește fișiere Outlook MSG
Deschide un fișier .msg cu msg_reader::from_file() sau msg_reader::from_stream(). Pentru a accesa direct stocările și fluxurile unui mesaj, învelește cititorul într-un msg_document cu 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);
Creează mesaje programatic
mapi_message::create() creează un mesaj nou în memorie dintr-un subiect și corp. Setează expeditorul, adaugă destinatari și atașează sarcini binare sau text înainte de a salva cu 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"));
Convertește între MSG și EML
mapi_message::save_to_eml() scrie mesajul curent ca un fișier EML conform RFC 5322, iar mapi_message::load_from_eml() citește unul înapoi. Ambele direcții păstrează subiectul, expeditorul, destinatarii și atașamentele, astfel încât un mesaj poate fi mutat între MSG și EML fără 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"));
Inspectează proprietățile mesajului și atașamentele
Un mapi_message încărcat expune câmpurile sale standard de antet direct — subject(), sender_name(), sender_email_address(), message_class() și internet_message_id() — împreună cu recipients() și attachments() ca vectori de mapi_recipient și mapi_attachment. Pentru câmpurile MAPI fără un accesoriu dedicat, get_property_value() citește orice proprietate prin common_message_property_id și 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));
Acces la container CFB la nivel scăzut
Fișierele MSG sunt stocate în interiorul unui container Compound File Binary (CFB) — formatul de stocare structurată utilizat și de formatele binare Office vechi. cfb_reader deschide containerul brut și expune arborele său de directoare direct: storage_ids() și stream_ids() listează fiecare intrare, directory_entry_count() raportează totalul și header() returnează layout-ul sectoarelor containerului. Acest lucru este util când ai nevoie de date MAPI pe care mapi_message API nu le expune.
#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';
Start rapid
Adăugați biblioteca în proiectul dvs.:
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)Apoi creați un mesaj, salvați-l ca MSG și îl transformați în 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;
}
Formate acceptate
| Format | Extensie | Citește | Scrie |
|---|---|---|---|
| Mesaj Outlook (MSG) | .msg | ✓ | ✓ |
| EML (RFC 5322 / MIME) | .eml | ✓ | ✓ |
| Compound File Binary (CFB) | .cfb | ✓ | ✓ |
Open Source și Licențiere
Aspose.Email FOSS pentru C++ este lansat sub licența MIT. Codul sursă complet este disponibil la aspose-email-foss/Aspose.Email-FOSS-for-Cpp, iar utilizarea comercială este permisă fără redevențe. Biblioteca nu are dependențe la rulare în afară de un compilator C++17 și CMake 3.26 sau o versiune ulterioară.
