Come leggere file in C++

Aspose.Email FOSS for C++ lets you open and parse Outlook MSG files with a single chiamata di funzione. mapi_message::from_file() e di cui al punto 2 mapi_message::from_stream() caricare il Messaggio completo soggetto, corpo, mittente, destinatari e allegati ?? in una memoria interna. oggetto senza dipendenza da Outlook o COM.

Passo 1 Impostare il progetto

Clona il repository e aggiungilo al tuo archivio di dati. CMakeLists.txt:

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)

Passo 2 Includere l’intestazione

#include "aspose/email/foss/msg/mapi_message.hpp"

Questo singolo header fornisce: mapi_message e tutti i tipi di supporto nel sistema. aspose::email::foss::msg spazio di nomi.

Passo 3 Caricare un messaggio da una traccia di file

Utilizzo: mapi_message::from_file() quando si ha 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';
}

Passo 4 Caricare un messaggio da uno streaming

Utilizzo: mapi_message::from_stream() per analizzare da qualsiasi std::istream utili per: elaborazione di MSG dati ricevuti tramite una rete o da un buffer in-memory:

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

int main()
{
    std::ifstream input("sample.msg", std::ios::binary);
    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 Per evitare l’ interruzione di Windows Traduzione da corruzione del contenitore CFB.

Fase 5 Destinatari iterati

message.recipients() restituisce un std::vector di oggetti destinatari, ciascuno con display_name, email_address, e recipient_type campi:

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

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

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

Fase 6 allegati iterati

message.attachments() restituisce un std::vector Ogni attaccamento è costituito da un’unica parte. esposizioni filename, mime_type, data (i byte grezzi), content_id, e il is_embedded_message() il predicato:

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

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

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

Problemi comuni e soluzioni

Valo body() dopo il caricamento. Alcuni messaggi memorizzano solo il testo nel corpo HTML Proprietà. message.html_body() quando ? message.body() restituisce una stringa vuota.

Strumento aperto senza std::ios::binary. Su Windows, trascrivere flussi in modalità testo Sequenze CRLF, corrompendo silenziosamente dati CFB binari. std::ios::binary.

msg_exception E’ stato lanciato per un dossier valido. Verifica che il file sia un vero MSG (OLE Compound File). I file salvati da alcuni strumenti di esportazione possono essere in testo semplice o MIME e non può essere analizzato da: mapi_message::from_file().

recipients() restituisce un vettore vuoto. I file più vecchi MSG a volte omettono il destinatario tabella ma memorizzare i destinatari di visualizzazione nel display_to Accedere tramite la pagina “Placeholder” di WEB message.get_property_value() con: common_message_property_id::display_to e di cui al punto 2 property_type_code::ptyp_string.

Grandi dati di allegato nella memoria. - Sì.mapi_message::from_file() e di cui al punto 2 from_stream() caricare l’intero messaggio inclusi tutti gli byte allegati. Per file di grandi dimensioni, aprire il contenitore sottostante con: msg_reader e ispezionare i flussi di attacco senza completamente materializzandoli.

Domande frequenti

Qual è la differenza tra: `from_file()` e di cui al punto 2 `from_stream()`?

Entrambi producono un risultato identico. mapi_message Oggetto. from_file() accetta un std::filesystem::path e apre il file internamente. from_stream() Legge da: qualsiasi std::istream si fornisce utile quando i dati MSG sono già in memoria o Arrivo su una presa.

- Sì. `from_file()` - Lasciare aperto il file dopo l’accesso?

No, il file viene aperto, analizzato completamente nella memoria e chiuso prima che la macchina non riesca a scaricare i dati. from_file() Puoi spostare o cancellare il file sorgente immediatamente dopo la chiamata.

Posso leggere file MSG creati da Outlook su macOS o Linux?

Sì. Il formato MSG (proprietà OLE Compound File + MAPI) è portabile su tutti i file di cui dispone il sistema operativo. Qualsiasi sistema operativo. .msg Il file generato da qualsiasi versione di Outlook può essere aperto. con: mapi_message::from_file().

Come faccio a leggere il corpo HTML?

Chiamami. message.html_body().Se il messaggio è stato creato con un corpo di testo semplice, questo restituisce una stringa vuota. message.body() restituisce il corpo del testo semplice.

La modalità rigorosa è la scelta predefinita?

mapi_message::from_file(path, strict) e di cui al punto 2 from_stream(stream, strict) accetta un opzionale strict Boolean. Il predefinito è false, che tollerano le piccole alterazioni strutturali. deviazioni nei file del mondo reale.