Introduzione
Aspose.Email FOSS per C++ è una nuova libreria open-source per leggere, creare e convertire file Outlook MSG, messaggi RFC 5322 EML e i contenitori Compound File Binary (CFB) su cui si basa il formato MSG. È scritta in C++17, non ha dipendenze runtime esterne e si compila su Linux, macOS e Windows tramite CMake — non vi è alcuna dipendenza COM né percorsi di codice specifici per piattaforma.
I file Outlook MSG compaiono costantemente nei lavori di integrazione aziendale — pipeline di archiviazione, strumenti di migrazione, esportazioni per conformità — ma leggerli senza Outlook stesso ha di solito richiesto l’automazione COM su Windows o una libreria commerciale. Aspose.Email FOSS per C++ ti offre un’alternativa portabile: una classe mapi_message di alto livello per la lettura e la creazione quotidiana dei messaggi, più classi di livello inferiore msg_reader, msg_document e cfb_reader per l’accesso diretto al formato contenitore sottostante quando ne hai bisogno.
La libreria è distribuita come sorgente C++17 sotto licenza MIT e aggiunta a un progetto come sottodirectory CMake, esponendo il target AsposeEmailFoss — non è necessaria alcuna registrazione al gestore di pacchetti né binari precompilati.
Caratteristiche principali
Leggi file Outlook MSG
Apri un file .msg con msg_reader::from_file() o msg_reader::from_stream(). Per accedere direttamente a archivi e stream di un messaggio, avvolgi il lettore in un msg_document con 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);
Crea messaggi programmaticamente
mapi_message::create() crea un nuovo messaggio in memoria a partire da un oggetto e un corpo. Imposta il mittente, aggiungi i destinatari e allega payload binari o di testo prima di salvare con 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"));
Converti tra MSG ed EML
mapi_message::save_to_eml() scrive il messaggio corrente come file EML RFC 5322, e mapi_message::load_from_eml() lo legge nuovamente. Entrambe le direzioni conservano l’oggetto, il mittente, i destinatari e gli allegati, così un messaggio può passare tra MSG ed EML senza 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"));
Ispeziona le proprietà del messaggio e gli allegati
Un mapi_message caricato espone direttamente i suoi campi di intestazione standard — subject(), sender_name(), sender_email_address(), message_class() e internet_message_id() — insieme a recipients() e attachments() come vettori di mapi_recipient e mapi_attachment. Per i campi MAPI senza accessor dedicato, get_property_value() legge qualsiasi proprietà tramite il suo common_message_property_id e 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));
Accesso a contenitori CFB a basso livello
I file MSG sono archiviati all’interno di un contenitore Compound File Binary (CFB) — il formato di storage strutturato utilizzato anche dai formati binari legacy di Office. cfb_reader apre il contenitore grezzo e ne espone direttamente l’albero delle directory: storage_ids() e stream_ids() elencano ogni voce, directory_entry_count() riporta il totale e header() restituisce la disposizione dei settori del contenitore. Questo è utile quando hai bisogno di dati MAPI che il mapi_message API non espone.
#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';
Avvio rapido
Aggiungi la libreria al tuo progetto:
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)Quindi crea un messaggio, salvalo come MSG e convertilo in 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;
}
Formati supportati
| Formato | Estensione | Leggi | Scrivi |
|---|---|---|---|
| Messaggio Outlook (MSG) | .msg | ✓ | ✓ |
| EML (RFC 5322 / MIME) | .eml | ✓ | ✓ |
| Compound File Binary (CFB) | .cfb | ✓ | ✓ |
Open source e licenze
Aspose.Email FOSS per C++ è rilasciato sotto licenza MIT. Il codice sorgente completo è disponibile su aspose-email-foss/Aspose.Email-FOSS-for-Cpp, e l’uso commerciale è consentito senza royalty. La libreria non ha dipendenze runtime oltre a un compilatore C++17 e CMake 3.26 o versioni successive.
