Aspose.Email FOSS
C++
Guida per sviluppatori
Leggere file MSG

Leggere file MSG

Leggere file MSG

mapi_message è il punto di ingresso per caricare e analizzare i file MSG Outlook. Un singolo chiamare a: from_file() o di più. from_stream() Legge l’intero contenitore CFB, estrae tutte le MAPI. proprietà, e li espone attraverso metodi di accesso digitato nessun installazione Outlook richiesto.

Carico da un percorso di file

Utilizzo: mapi_message::from_file() con un 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';
}

Carico da un flusso

Utilizzo: mapi_message::from_stream() quando i dati MSG arrivano da un socket di rete, e Archivio, o qualsiasi altro archivio di dati. 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';
}

Apri sempre il flusso con … std::ios::binary. Trascrizione di linee in modalità testo - E corromper il contenitore CFB.

Proprietà del messaggio di accesso

mapi_message espone le proprietà più comuni dei messaggi come getter nominati:

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

Destinatari iterati

message.recipients() restituisce un std::vector di oggetti destinatari con display_name, email_address, e 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';
    }
}

Attachments iterati

message.attachments() restituisce un std::vector Ogni esposizione è un’operazione di ricerca. filename, mime_type, data, content_id, e 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()));
        }
    }
}

Accedere ai messaggi incorporati

Quando ? is_embedded_message() è: true, l’allegato contiene un altro file MSG. Accedere tramite: 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"));
        }
    }
}

Suggerimenti e migliori pratiche

  • Passa sempre . std::ios::binary a) per il std::ifstream quando si caricano file di MSG.
  • Controllo html_body() prima di questo. body() I messaggi solo HTML memorizzano il loro contenuto nel sistema di codifica. Proprietà del corpo HTML e lasciare body() - Vaga. - Sì, è vuota.
  • from_file() Per i file MSG di grandi dimensioni, considerare il metodo “Messaggio” (MSG) come un’applicazione per la memoria. aprire il contenitore sottostante con: msg_reader per ispezionare i metadati senza completare la procedura di controllo. materializzare gli byte di allegato.
  • Il Consiglio ha adottato: strict parametro di from_file(path, strict) e di cui al punto 2 from_stream(stream, strict) - di default a false, tollerando le minori deviazioni strutturali nei file MSG del mondo reale.
  • Gli oggetti destinatari espongono recipient_type per distinguere le voci To, Cc e Bcc.

Problemi comuni

Numero di pubblicazioneCausa di morteRettifica
msg_exception su un file di aspetto validoIl file non è un contenitore OLE CFB originale .Verificare con: cfb_reader::from_file() se anche lancia, il file non è un MSG valido
body() restituisce una stringa vuotaMessaggio utilizza solo il corpo HTMLUtilizzo: html_body() invece di …
recipients() è vuoto.GMS più vecchio senza tabella dei destinatariAccesso display_to via: get_property_value() con: common_message_property_id::display_to
Corruzione del flusso su WindowsStrumento aperto senza std::ios::binaryAggiungere std::ios::binary bandiera a std::ifstream
Alta utilizzazione di memoria per file di grandi dimensioniTutti i dati dell’ allegato sono caricati in anticipo.Utilizzo: msg_reader per l’accesso a basso livello senza piena materializzazione

FAQ

- Sì. from_file() - Tieni aperta la maniglia del file?

No. Il file viene aperto, completamente analizzato e chiuso prima che il metodo ritorni. Puoi spostare o eliminare il file sorgente dopo la chiamata.

Come faccio a sapere se un allegato è un file o una MSG incorporata?

Chiamami. attachment.is_embedded_message().- Ritorni true per i file MSG incorporati; false Per i messaggi incorporati, accedere all’oggetto annidato. via: attachment.embedded_message.

Qual è la differenza tra: from_file() e utilizzando: msg_reader?

mapi_message::from_file() è l’API di alto livello analizza il messaggio completo e espone le proprietà come campi tipizzati. msg_reader è il lettore di basso livello che dà L’accesso alla struttura del contenitore CFB grezzo è utile quando si ha bisogno di ispezionare il materiale. layout del messaggio senza analizzare tutte le proprietà MAPI.

I file Unicode e ANSI MSG sono entrambi supportati?

  • Sì, è vero. mapi_message gestisce sia Unicode (tipo di proprietà ptyp_string) e ANSI (ptyp_string8) proprietà di stringhe. unicode_strings() rendimenti true per i messaggi memorizzato con proprietà Unicode.

Riassunto di riferimento API

Classe / metodoDescrizione
mapi_message::from_file(path)Caricare un file MSG da una scheda di controllo. std::filesystem::path
mapi_message::from_file(path, strict)Carico con opzione di modalità rigorosa
mapi_message::from_stream(stream)Carico di MSG da un std::istream
mapi_message::from_stream(stream, strict)Carico da flusso con opzione di modalità rigorosa
mapi_message::subject()Ritorna la stringa dell’ argomento del messaggio
mapi_message::body()Restituire il corpo del testo semplice
mapi_message::html_body()Restituire il corpo HTML (vuoto se non presente)
mapi_message::sender_name()Restituire il nome di visualizzazione del mittente
mapi_message::sender_email_address()Restituire l’indirizzo email del mittente
mapi_message::internet_message_id()Restituire l’intestazione RFC 2822 Message-ID
mapi_message::message_class()Restituire la stringa di classe MAPI del messaggio
mapi_message::recipients()Restituire l’elenco dei destinatari
mapi_message::attachments()Restituire l’ elenco di allegati
mapi_attachment::is_embedded_message()Vero se l’attaccamento è un MSG incorporato
mapi_message::unicode_strings()Vero se il messaggio utilizza le proprietà di stringhe Unicode
 Italiano