Hur man arbetar med atttag i C++

Aspose.Email FOSS for C++ provides the mapi_attachment Klasser för att skapa anslutningar från rå byter eller strömmar, och mapi_message Anslutningslista för läsande anslutningar från befintliga MSG-filer. Du kan lägga till bifogade filer när du skapar meddelanden och inspektera dem när du laddar filer, inklusive att upptäcka om en bifogning själv är ett inbyggd MSG meddelande.

Steg 1 – Ställ in projektet

git clone https://github.com/aspose-email-foss/Aspose.Email-FOSS-for-Cpp.git

add_subdirectory(Aspose.Email-FOSS-for-Cpp)
target_link_libraries(your_target PRIVATE AsposeEmailFoss::AsposeEmailFoss)

Steg 2 – Lägg till en filåtfölj från byter

Användning mapi_message::add_attachment() att bifoga binära data när du skapar ett meddelande. Ge filnamnet, de rå byterna som en std::vector<std::uint8_t>,Och MIME innehållstyp :

#include <filesystem>
#include <vector>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    auto message = aspose::email::foss::msg::mapi_message::create(
        "Report", "Please review the attached report.");
    message.set_sender_name("Alice");
    message.set_sender_email_address("alice@example.com");
    message.add_recipient("bob@example.com", "Bob");

    // Attach a text file
    std::vector<std::uint8_t> text_data{'H', 'e', 'l', 'l', 'o'};
    message.add_attachment("notes.txt", text_data, "text/plain");

    // Attach a binary blob
    std::vector<std::uint8_t> bin_data{0x00, 0x01, 0x02, 0x03};
    message.add_attachment("data.bin", bin_data, "application/octet-stream");

    message.save(std::filesystem::path("report.msg"));
}

Steg 3 – Lägg till en anslutning från en fil på en disk

Läs filen i en bytevektor och sedan överför den till add_attachment():

#include <filesystem>
#include <fstream>
#include <iterator>
#include <vector>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    // Read a file into bytes
    std::ifstream file("document.pdf", std::ios::binary);
    std::vector<std::uint8_t> pdf_bytes(
        std::istreambuf_iterator<char>(file),
        std::istreambuf_iterator<char>{});

    auto message = aspose::email::foss::msg::mapi_message::create(
        "Document", "See attached PDF.");
    message.set_sender_name("Alice");
    message.set_sender_email_address("alice@example.com");
    message.add_recipient("bob@example.com", "Bob");
    message.add_attachment("document.pdf", pdf_bytes, "application/pdf");

    message.save(std::filesystem::path("with_pdf.msg"));
}

Steg 4 – Läs anslutningar från en befintlig MSG-fil

message.attachments() Återkommer A const hänvisning till en vektor av anslutningsobjekt. Varje utställning filename, mime_type, data (och de är av med) och content_id:

#include <fstream>
#include <iostream>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    std::ifstream input("sample.msg", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::from_stream(input);

    std::cout << "Attachments: " << message.attachments().size() << '\n';
    for (std::size_t i = 0; i < message.attachments().size(); ++i)
    {
        const auto& a = message.attachments()[i];
        std::cout << "[" << (i + 1) << "]"
                  << "  name="         << a.filename
                  << "  mime="         << a.mime_type
                  << "  bytes="        << a.data.size()
                  << "  content_id="   << a.content_id
                  << '\n';
    }
}

Steg 5 – Upptäck och få tillgång till inbäddade meddelanden

Vissa MSG-filer innehåller andra MSM-filer som bifogade filer (förhandsgraderade eller mötesinbjudanden). Användning is_embedded_message() att upptäcka dessa och få tillgång till den nötade meddelandet genom embedded_message:

#include <fstream>
#include <iostream>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    std::ifstream input("sample.msg", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::from_stream(input);

    for (const auto& attachment : message.attachments())
    {
        if (attachment.is_embedded_message() && attachment.embedded_message != nullptr)
        {
            const auto& inner = *attachment.embedded_message;
            std::cout << "Embedded subject: " << inner.subject() << '\n';
            std::cout << "Embedded from:    " << inner.sender_email_address() << '\n';

            // Save the embedded message as a standalone MSG
            inner.save(std::filesystem::path("embedded.msg"));
        }
        else
        {
            std::cout << "Regular attachment: " << attachment.filename
                      << " (" << attachment.data.size() << " bytes)\n";
        }
    }
}

Steg 6 – Spara anslutningsdata till skivan

Extract bifogade byter och skriv dem till en fil med standard C++-filströmmar:

#include <filesystem>
#include <fstream>
#include <iostream>
#include "aspose/email/foss/msg/mapi_message.hpp"

int main()
{
    const auto message = aspose::email::foss::msg::mapi_message::from_file(
        std::filesystem::path("sample.msg"));

    const std::filesystem::path out_dir("attachments");
    std::filesystem::create_directories(out_dir);

    for (const auto& a : message.attachments())
    {
        if (!a.is_embedded_message())
        {
            const auto out_path = out_dir / a.filename;
            std::ofstream out(out_path, std::ios::binary);
            out.write(reinterpret_cast<const char*>(a.data.data()),
                      static_cast<std::streamsize>(a.data.size()));
            std::cout << "Saved: " << out_path << '\n';
        }
    }
}

Vanliga problem och fixar

attachment.data är tom för en välkända anslutning. Kontrollera källkod MSG-filen faktiskt innehåller bifogandata (inte en OLE-länk). MSG-filer exporteras från vissa Mailklienter kan lagra bifogade filer som externa referenser som biblioteket inte kan följa.

is_embedded_message() återvänder true Men embedded_message är nullptr. Den fästhuvud indikerar en inbyggd MSG, men data var inte parseable. kontrollera att källan MSG är giltig och inte trunkad.

Spara extraherad bifogning misslyckas med en vägfel. Några filenamn tillägg innehåller tecken som är olagliga på målfilersystemet (t.ex., :, ? på Windows - Sanitär attachment.filename innan man bygger utgångsvägen.

Stora MSG-filer orsakar hög minneanvändning. -här är detmapi_message::from_file() Ladda alla för stora filer, öppna den underliggande CFB-behållaren med cfb_reader att få tillgång till enskilda strömmar utan att helt materialisera alla anslutningar.

add_attachment() inte hittades vid tidpunkten för samlingen. Se till att du använder rätt Inkluderar: "aspose/email/foss/msg/mapi_message.hpp".Metoden är en medlem av aspose::email::foss::msg::mapi_message.

Ofta ställda frågor

Vilka MIME-typer ska jag använda för tillägg?

Använd standardtypen IANA MIME för filformat: "text/plain" för .txt, "application/pdf" för .pdf, "application/octet-stream" som en generisk fallback för binära filer. MIME-typen lagras som den attach_mime_tag Mappen av egendom.

Kan jag lägga till samma fil flera gånger?

Ja, varje kallelse till add_attachment() bifogar en oberoende anslutningsenhet. duplicera filnamn är tillåtet; de skiljer sig av position i bifogningslistan.

Hur ställer jag in innehålls-ID för inline bilder?

Passera innehålls-ID-fältet som det fjärde argumentet till mapi_attachment::from_stream():

auto att = aspose::email::foss::msg::mapi_attachment::from_bytes(
    "logo.png", png_bytes, "image/png", "<logo-cid@example.com>");

content_id Det är uttryckt som attachment.content_id När man läser tillbaka.

är `attachment.data` En kopia eller en referens?

attachment.data är A std::vector<std::uint8_t> värdet som lagras inom mapi_message Att komma åt den utlöser inte ytterligare I/O.

Kan jag ta bort en anslutning innan spara?

Den mapi_message API visar inte en direkt borttagnings-attackmetod i versionen 0.1.0. Build a new message, copy the desired properties and attachments manually, och rädda det nya objektet.