Com treballar amb els enllaços en C++

Aspose.Email FOSS for C++ provides the mapi_attachment Classe per crear adhesions de les fonts o els fluxos, i el mapi_message Llista d’Afeixos per a la Lectura dels arxius existents.Pots afegir adjunts quan composes missatges i inspeccionar-los quan carregueu arxius, incloent-hi la detecció de si un annex és en si mateix un embolicat El missatge de la CUP.

Pas 1 - Establir el projecte

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)

Pas 2 - Afegir un fitxer adjunt des de bytes

utilitzar mapi_message::add_attachment() - Adjuntar dades binàries quan es compon un missatge. Proporcionar el nom de fitxer, els bytes crus com a std::vector<std::uint8_t>,i el seu lloc. Tipus de contingut:

#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"));
}

Pas 3 - Afegir un annex d’un arxiu al disc

Llegir el fitxer en un vector de byte, després passar-lo a 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"));
}

Pas 4 - Llegir adjunts d’un fitxer MSG existent

message.attachments() Torna a const Referència a un vector d’objectes d’adhesió. Cada exposició filename, mime_type, data (els bots crues), i 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';
    }
}

Pas 5 - Detectar i accedir als missatges emmarcats

Alguns arxius MSG contenen altres arxis MSG com a annexos (convocatòries de trobada o enviades). utilitzar is_embedded_message() per detectar-los i accedir al missatge nixat a través de 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";
        }
    }
}

Pas 6 - Guardar dades d’afaçaments al disc

Extreure bytes d’adjunt i escriure-los a un arxiu utilitzant fluxos de fitxers C++ estàndard:

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

Problemes comuns i solucions

attachment.data És un buit per a una gran adherència. Verificació de l’origen del fitxer MSG En realitat conté les dades d’adjunt (no un enllaç OLE). MSG fitxers exportats des d’alguns Els clients de correu electrònic poden emmagatzemar els fitxers adjunts com a referències externes que la biblioteca no pot seguir.

is_embedded_message() Retorns true però embedded_message És nullptr. El l’enquadrament de l’apartat indica un MSG embolicat, però les dades no eren visibles. La font MSG és vàlida i no truncada.

L’emmagatzematge d’adhesius extraïts fracassa amb un error de camí. Alguns fitxers adjunts Conté caràcters que són inútils en el sistema de fitxers d’objectiu (per exemple,., :, ? És Sanitat - Sanitària attachment.filename abans de fer el camí d’execució.

Els arxius grans causen un gran ús de memòria. Elmapi_message::from_file() Carregar tots En cas de fitxers grans, obri el contenidor CFB subjacent amb un cfb_reader Per accedir a fluxos individuals sense materialitzar completament tots els enllaços.

add_attachment() No es troba en el moment de la compilació. Assegureu-vos que utilitzeu el correcte Inclouen : "aspose/email/foss/msg/mapi_message.hpp".El mètode és un membre de aspose::email::foss::msg::mapi_message.

Preguntes freqüents

Quins tipus de MIME he d’utilitzar per als annexos?

Utilitza el tipus IANA MIME estàndard per al format de fitxer: "text/plain" per .txt, "application/pdf" per .pdf, "application/octet-stream" Com a fallback per El tipus MIME s’emmagatzema com el attach_mime_tag Propietat de l’habitatge.

Puc afegir el mateix arxiu diverses vegades?

Cada trucada a add_attachment() Es pot fer una entrada d’addició independent.Duplicar Els noms de fitxers són permesos; es distingeixen per la posició en la llista d’apartats.

Com puc configurar l’ID de contingut per a imatges inline?

Passar la cadena d’ID de contingut com a quart argument a 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 Està exposat com attachment.content_id Quan llegeixes enrere.

és `attachment.data` Una còpia o una referència?

attachment.data És a std::vector<std::uint8_t> Emmagatzemats per valor dins de la mapi_message L’accés a la imatge no desencadena cap I/O addicional.

Puc eliminar un adjunt abans d’estalviar?

El mapi_message API no exposa un mètode de desallotjament directe en la versió 0.1.0. Build a new message, copy the desired properties and attachments manually, i salvar el nou objecte.