Introduktion

Aspose.Email FOSS för C++ är ett nytt öppen källkods-bibliotek för att läsa, skapa och konvertera Outlook MSG-filer, RFC5322-EML-meddelanden och Compound File Binary (CFB)-behållare som MSG-formatet är byggt på. Det är skrivet i C++17, har inga externa körtidsberoenden och byggs på Linux, macOS och Windows via CMake — det finns inget COM-beroende och ingen plattforms-specifik kodväg.

Outlook MSG-filer dyker upp konstant i företagsintegration — arkiverings-pipelines, migrationsverktyg, efterlevnadsexporter — men att läsa dem utan Outlook har vanligtvis krävt COM-automation på Windows eller ett kommersiellt bibliotek. Aspose.Email FOSS för C++ ger dig ett portabelt alternativ: en hög-nivå mapi_message-klass för daglig meddelandeläsning och -skapande, samt lägre-nivå msg_reader, msg_document och cfb_reader-klasser för direkt åtkomst till det underliggande behållarformatet när du behöver det.

Biblioteket distribueras som C++17-källa under MIT-licensen och läggs till i ett projekt som en CMake-undermapp, vilket exponerar AsposeEmailFoss-målet — ingen registrering i pakethanterare och inga förbyggda binärer krävs.

Viktiga funktioner

Läs Outlook MSG-filer

Öppna en .msg-fil med msg_reader::from_file() eller msg_reader::from_stream(). För att komma åt ett meddelandes lagringar och strömmar direkt, slå in läsaren i en msg_document med 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);

Skapa meddelanden programatiskt

mapi_message::create() bygger ett nytt meddelande i minnet från ett ämne och en brödtext. Ställ in avsändaren, lägg till mottagare och bifoga binära eller textbaserade payloads innan du sparar med 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"));

Konvertera mellan MSG och EML

mapi_message::save_to_eml() skriver det aktuella meddelandet som en RFC 5322 EML-fil, och mapi_message::load_from_eml() läser tillbaka en sådan. Båda riktningarna bevarar ämnet, avsändaren, mottagarna och bilagorna, så att ett meddelande kan flyttas mellan MSG och EML utan 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"));

Inspektera meddelandeegenskaper och bilagor

En inläst mapi_message exponerar sina standardhuvudfält direkt — subject(), sender_name(), sender_email_address(), message_class() och internet_message_id() — samt recipients() och attachments() som vektorer av mapi_recipient och mapi_attachment. För MAPI-fält utan en dedikerad åtkomstfunktion läser get_property_value() vilken egenskap som helst via dess common_message_property_id och 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));

Lågnivå CFB-behållaråtkomst

MSG-filer lagras i en Compound File Binary (CFB)-behållare — det strukturerade lagringsformatet som också används av äldre Office-binära format. cfb_reader öppnar den råa behållaren och exponerar dess katalogträd direkt: storage_ids() och stream_ids() listar varje post, directory_entry_count() rapporterar totalen, och header() returnerar behållarens sektorlayout. Detta är användbart när du behöver MAPI-data som mapi_message API inte visar.

#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';

Snabbstart

Lägg till biblioteket i ditt projekt:

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)

Skapa sedan ett meddelande, spara det som MSG och konvertera det till 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;
}

Stödda format

FormatFiländelseLäsSkriv
Outlook-meddelande (MSG).msg✓✓
EML (RFC 5322 / MIME).eml✓✓
Compound File Binary (CFB).cfb✓✓

Öppen källkod & licensiering

Aspose.Email FOSS för C++ är släppt under MIT-licensen. Den fullständiga källkoden finns på aspose-email-foss/Aspose.Email-FOSS-for-Cpp, och kommersiell användning är tillåten utan royalties. Biblioteket har inga körtidssberoenden utöver en C++17-kompilator och CMake 3.26 eller senare.

Kom igång

Relaterade resurser