Llegir arxius MSG

mapi_message és el punt d’entrada per a carregar i analitzar els arxius Outlook MSG. Un sol trucar a from_file() o de la seva from_stream() Llegeix el contenidor CFB complet, extraeixen tots els MAPI propietats, i els exposa a través de mètodes d’accesori tipus no instal·lació Outlook necessària.

Carrega des d’una ruta de fitxer

Utilització: mapi_message::from_file() amb una std::filesystem::path:

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

    std::cout << "Subject: " << message.subject() << '\n';
    std::cout << "From:    " << message.sender_name()
              << " <" << message.sender_email_address() << ">\n";
    std::cout << "Body:    " << message.body() << '\n';
}

Carrega d’un corrent

Utilització: mapi_message::from_stream() quan arriben dades de MSG des d’un socket de xarxa, un arxiu, o qualsevol altre document de la Comissió. std::istream:

#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 << "Subject: " << message.subject() << '\n';
}

Sempre obre el corrent amb std::ios::binary. Fluxos de text en mode traduir línia les terminacions en Windows i corrompre el contenidor CFB.

Propietats de missatges d’accés

mapi_message exposa les propietats més comunes de missatges com a getters nomenats:

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

    // Core properties
    std::cout << "Subject:          " << message.subject() << '\n';
    std::cout << "Sender name:      " << message.sender_name() << '\n';
    std::cout << "Sender email:     " << message.sender_email_address() << '\n';
    std::cout << "Internet msg-id:  " << message.internet_message_id() << '\n';
    std::cout << "Message class:    " << message.message_class() << '\n';

    // Body — check html_body() first; fall back to plain body()
    const auto& body = message.html_body().empty()
        ? message.body()
        : message.html_body();
    std::cout << "Body length: " << body.size() << " chars\n";
}

Receptors iteraus

message.recipients() retorna un std::vector de objectes destinataris amb: display_name, email_address, i recipient_type:

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

    for (std::size_t i = 0; i < message.recipients().size(); ++i)
    {
        const auto& r = message.recipients()[i];
        std::cout << "[" << (i + 1) << "] "
                  << r.display_name << " <" << r.email_address << ">"
                  << "  type=" << r.recipient_type << '\n';
    }
}

Anexos iteració

message.attachments() retorna un std::vector Cada un exposa filename, mime_type, data, content_id, i is_embedded_message():

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

    for (const auto& a : message.attachments())
    {
        std::cout << a.filename
                  << "  " << a.mime_type
                  << "  " << a.data.size() << " bytes"
                  << "  embedded=" << (a.is_embedded_message() ? "yes" : "no")
                  << '\n';

        if (!a.is_embedded_message())
        {
            std::ofstream out("extracted_" + a.filename, std::ios::binary);
            out.write(reinterpret_cast<const char*>(a.data.data()),
                      static_cast<std::streamsize>(a.data.size()));
        }
    }
}

Accedir a missatges incrustats

Quan? is_embedded_message() és true, l’encàrrec conté un altre fitxer MSG. Accedeix a través de: attachment.embedded_message:

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

    for (const auto& a : message.attachments())
    {
        if (a.is_embedded_message() && a.embedded_message != nullptr)
        {
            const auto& inner = *a.embedded_message;
            std::cout << "Embedded subject: " << inner.subject() << '\n';
            inner.save(std::filesystem::path("embedded.msg"));
        }
    }
}

Consells i millors pràctiques

Sempre passem. std::ios::binary a la std::ifstream en la càrrega de fitxers MSG.
Compte de pagament html_body() abans body() Els missatges només HTML emmagatzemen el seu contingut en l’ordinador de la xarxa. Propietat de cos HTML i deixar-ho body() buit.
from_file() Per a grans fitxers MSG, considereu obrir el recipient subjacent amb: msg_reader inspeccionar metadades sense que s’hagin completat les dades. materialitzant bytes d’apadhament.
El strict paràmetre de from_file(path, strict) i de la from_stream(stream, strict) incumpliments a false, tolerant desviacions estructurals menors en arxius de MSG del món real.
Objectes de destinatari exposar recipient_type per distingir les entrades To, Cc i Bcc.

Problemàtiques comuns

Edició	Causa	Correcció
`msg_exception` en un fitxer de bona imatge	El fitxer no és un contenidor OLE CFB genuí.	Verificar amb: `cfb_reader::from_file()` si també tira, el fitxer no és un MSG vàlid.
`body()` Retorna cadena buida	El missatge només utilitza el cos HTML.	Utilització: `html_body()` en lloc d’això.
`recipients()` està buida.	GMS antic sense taula de receptors.	Accés `display_to` per mitjà de: `get_property_value()` amb: `common_message_property_id::display_to`
Corrupció de flux en Windows	Flueix obert sense `std::ios::binary`	Ajuntar `std::ios::binary` bandera a `std::ifstream`
Alta utilització de memòria per a fitxers grans	Totes les dades d’acte adjunt es carguen per endavant.	Utilització: `msg_reader` per a l’accés de baix nivell sense materialització completa.

FAQ

És així. `from_file()` mantenir l’arxiu obert?

No. El fitxer s’obre, es parseja completament i es tanca abans que el mètode retorni. Pots moure o eliminar el fitxatge font després de la crida.

Com puc saber si un adjunt és un fitxer o una MSG incrustada?

L’anomenaràs. attachment.is_embedded_message().Retorns true per a arxius integrats de MSG; false Per a missatges incrustats, accedeix a l’objecte enrodat. per mitjà de: attachment.embedded_message.

Quina és la diferència entre `from_file()` i utilitzant `msg_reader`?

mapi_message::from_file() és l’API d’alt nivell analitza tot el missatge i exposa les propietats com a camps tipitzats. msg_reader és el lector de baix nivell que dóna l’accés a la estructura del contenidor CFB i és útil quan es necessita inspeccionar el disseny del missatge sense analitzar totes les propietats MAPI.

Els arxius Unicode i ANSI MSG són compatibles?

Sí, ho sé. mapi_message tracta tant Unicode (tipe de propietat ptyp_string) i ANSI. (ptyp_string8) propietats de cadena. unicode_strings() devolucions true per a missatges emmagatzemats amb propietats d’Unicode.

Resum de referència d’API

Classe / mètode	Descripció
`mapi_message::from_file(path)`	Carregar un fitxer MSG des d’un `std::filesystem::path`
`mapi_message::from_file(path, strict)`	Carrega amb opció de modalitat estricta
`mapi_message::from_stream(stream)`	Carrega de GMS des d’un `std::istream`
`mapi_message::from_stream(stream, strict)`	Carrega des del flux amb opció de modalitat estricta
`mapi_message::subject()`	Retorna la cadena d’assignatura del missatge
`mapi_message::body()`	Retornar el cos de text en comú
`mapi_message::html_body()`	Retorna el cos HTML (buit si no està present)
`mapi_message::sender_name()`	Retorna el nom de l’expedient
`mapi_message::sender_email_address()`	Retorna l’adreça de correu electrònic del remitent
`mapi_message::internet_message_id()`	Retorna l’encapçal·lada de la RFC 2822 del missatge-ID
`mapi_message::message_class()`	Retorna la cadena de classes del missatge MAPI
`mapi_message::recipients()`	Retornar la llista de destinataris
`mapi_message::attachments()`	Retornar la llista d’apadhs
`mapi_attachment::is_embedded_message()`	És cert si l’acoplament és un MSG incrustat.
`mapi_message::unicode_strings()`	Verdad si el missatge utilitza propietats de cadena d’Unicode

Llegir arxius MSG