Leitura de ficheiros MSG

mapi_message é o ponto de entrada para carregamento e análise dos arquivos Outlook MSG. Um único Chama-me. from_file() ou a) from_stream() Leia o contêiner CFB completo, extrai todos os MAPIs. propriedades, e expõe-os através de métodos de acesso tipados nenhuma instalação do Outlook necessária.

Carregar a partir de um caminho de arquivo

Utilização: mapi_message::from_file() com um 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';
}

Carga de um fluxo

Utilização: mapi_message::from_stream() quando os dados MSG chegam de um socket de rede, e Arquivo, ou qualquer outro arquiva de documentos. 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 abrir o fluxo com std::ios::binary.Fluxos de tradução em modo texto . O que é isso?.

Propriedades de mensagem do Access

mapi_message expõe as propriedades de mensagem mais comuns como getters nomeados:

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

Destinatários Iterados

message.recipients() retorna um std::vector de objetos destinatários com: 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';
    }
}

Anexos Iterados

message.attachments() retorna um std::vector Cada um expõe os seus próprios objetos de fixação. 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()));
        }
    }
}

Acesso a mensagens incorporadas

Quando ? is_embedded_message() é: true, o anexo contém outro ficheiro MSG. Acesse-a através do 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"));
        }
    }
}

Dicas e melhores práticas

Sempre passar . std::ios::binary a) para o std::ifstream ao carregar ficheiros de MSG.
Verificação html_body() antes de body() Mensagens apenas HTML armazenam o seu conteúdo no sistema de rede. Propriedade do corpo HTML e deixar body() - Está vazio.
from_file() Para grandes arquivos MSG, considere a função de transferência do ficheiro. abrindo o recipiente subjacente com: msg_reader para inspecionar metadados sem a utilização completa de dados, materializar bytes de anexo.
A Comissão strict Parâmetro de: from_file(path, strict) e a) from_stream(stream, strict) Descontos para false, tolerando desvios estruturais menores nos ficheiros de MSG do mundo real.
Objetos de destinatário expõem recipient_type para distinguir as entradas To, Cc e Bcc.

Problemas comuns

Emissão	Causa da morte	Correção
`msg_exception` num ficheiro com aparência válida.	O ficheiro não é um verdadeiro recipiente CFB do OLE .	Verificar com: `cfb_reader::from_file()` se também lança, o arquivo não é um MSG válido
`body()` retorna uma sequência vazia	Mensagem utiliza apenas corpo HTML	Utilização: `html_body()` em vez disso .
`recipients()` está vazio.	Glicerol mais antigo sem tabela de receptores	Acessos `display_to` via: `get_property_value()` com: `common_message_property_id::display_to`
Corrupção de fluxo no Windows	Fluxo aberto sem `std::ios::binary`	Adicionar `std::ios::binary` bandeira para `std::ifstream`
Alta utilização de memória para arquivos grandes	Todos os dados do anexo são carregados antecipadamente.	Utilização: `msg_reader` para acesso de baixo nível sem materialização completa.

FAQ

- Sim . `from_file()` - Mantém o arquivo aberto?

Não. O arquivo é aberto, analisado completamente e fechado antes que o método retorne. Você pode mover ou excluir o arquivos de origem após a chamada.

Como posso dizer se um anexo é um ficheiro ou uma MSG incorporada?

Chama-me . attachment.is_embedded_message().- Retornos de crédito . true para ficheiros de GMS incorporados; false Para mensagens incorporadas, acesse o objeto aninhado. via: attachment.embedded_message.

Qual é a diferença entre: `from_file()` e utilização de: `msg_reader`?

mapi_message::from_file() é o API de alto nível ele analisa a mensagem completa e expõe as propriedades como campos tipados. msg_reader é o leitor de baixo nível que dá acesso à estrutura do recipiente CFB e é útil quando você precisa inspecionar o material de cada um dos componentes. O layout da mensagem sem analisar todas as propriedades MAPI.

Os arquivos Unicode e ANSI MSG são suportados?

Sim, é verdade. mapi_message trata tanto Unicode (tipo de propriedade ptyp_string) e ANSI. (ptyp_string8) propriedades de cadeia. unicode_strings() Renda de rendimentos true para mensagens armazenado com propriedades Unicode.

Resumo de referência da API

Classe / Método	Descrição:
`mapi_message::from_file(path)`	Carregar um ficheiro MSG a partir de uma `std::filesystem::path`
`mapi_message::from_file(path, strict)`	Carga com opção de modo estrito
`mapi_message::from_stream(stream)`	Carga de GMS a partir de um `std::istream`
`mapi_message::from_stream(stream, strict)`	Carga do fluxo com opção de modo estrito
`mapi_message::subject()`	Devolver a sequência de assunto da mensagem
`mapi_message::body()`	Devolver o corpo de texto simples
`mapi_message::html_body()`	Devolver o corpo HTML (vazio se não estiver presente)
`mapi_message::sender_name()`	Devolver o nome de exibição do remetente
`mapi_message::sender_email_address()`	Devolver o endereço de e-mail do remetente
`mapi_message::internet_message_id()`	Retornar o cabeçalho RFC 2822 de mensagem-ID
`mapi_message::message_class()`	Retornar a cadeia de mensagens MAPI
`mapi_message::recipients()`	Devolver a lista de destinatários
`mapi_message::attachments()`	Devolver a lista de anexos
`mapi_attachment::is_embedded_message()`	Verdadeiro se o anexo for um GMS incorporado
`mapi_message::unicode_strings()`	Verdadeiro se a mensagem usar propriedades de string Unicode

Leitura de ficheiros MSG