Lectura de archivos MSG

mapi_message es el punto de entrada para cargar y parsugar archivos MSG de Outlook. llamando a from_file() o from_stream() lea el contenedor completo de CFB, extrae todos los MAPI propiedades, y los expone a través de métodos de accesorios tipados — no Outlook instalación necesarios .

Cargar de un archivo Path

Uso mapi_message::from_file() con A 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 un flujo

Uso mapi_message::from_stream() Cuando los datos de MSG vienen de una rede socket, un archivos o cualquier otro 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';
}

Siempre abre el flujo con std::ios::binary. texto-moda flujos de línea de traducción Terminar en Windows y corromper el contenedor CFB.

Propiedades de mensajes de acceso

mapi_message Exponen las propiedades de mensaje más comunes como los llamados ghettos:

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

Recipientes Iterate

message.recipients() Volver a std::vector de los objetos recibientes con display_name, email_address,y, 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';
    }
}

Iterate de los accesorios

message.attachments() Volver a std::vector de los objetos de adhesión. cada exposición filename, mime_type, data, content_id,y, 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()));
        }
    }
}

Acceso a mensajes incorporados

Cuando is_embedded_message() Es el true,El anexo contiene otro archivo MSG. Acceso 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"));
        }
    }
}

Consejos y mejores prácticas

Siempre pasan std::ios::binary para std::ifstream Cuando se cargan archivos MSG.
Verificar html_body() Antes de body() - Los mensajes HTML únicamente almacenan su contenido en el Propiedad del cuerpo HTML y dejarlo body() y vacío.
from_file() cargar todos los datos de anexo en la memoria. para grandes archivos MSG, considere Abre el contenedor con msg_reader - Inspeccionar los metadatos sin tener totalidad. Materializar los bajos de adhesión.
El strict Parámetros de from_file(path, strict) y from_stream(stream, strict) Defaultos para false,Tolerancia de pequeñas desviaciones estructurales en los archivos MSG del mundo real.
Objetos de recepción expuestos recipient_type para distinguir entre las entradas To, Cc y Bcc.

Problemas comunes

Problemas	Causas	Fixado
`msg_exception` En un archivo de aspecto válido	El archivo no es un recipiente de OLE CFB.	Verificar con `cfb_reader::from_file()` - si también se lanza, el archivo no es un MSG válido.
`body()` Retorno de la línea vacía	El mensaje utiliza el cuerpo HTML solo	Uso `html_body()` En lugar de
`recipients()` Es vacío	MSG más viejo sin una mesa de receptor	Acceso `display_to` por vía `get_property_value()` con `common_message_property_id::display_to`
Corrupción en Windows	El flujo se abre sin `std::ios::binary`	añadir `std::ios::binary` La bandera de `std::ifstream`
Utilización de memoria alta para grandes archivos	Todos los datos de la etiqueta se cargan en adelante	Uso `msg_reader` para el acceso a nivel bajo sin materialización completa

FAQ

¿Qué hace `from_file()` ¿Tener el archivo abierto?

No. El archivo se abre, está completamente parsado y cierra antes de que el método vuelva.Puede mover o borrar el archivos fuente después de la llamada.

¿Cómo puedo decir si un anexo es un archivo o un MSG incorporado?

llamadas attachment.is_embedded_message().de vuelta true para los archivos MSG incorporados; false para los anexos de archivo regulares. Para mensajes envueltos, acceda al objeto nido por vía attachment.embedded_message.

¿Cuál es la diferencia entre `from_file()` y utilizando `msg_reader`?

mapi_message::from_file() es la API de alto nivel — parsa el mensaje completo y Exponen propiedades como campos tipados. msg_reader Es el lector de bajo nivel que da acceso a la estructura de contenedor crudo CFB y es útil cuando necesitas inspeccionar Descripción de mensajes sin paralizar todas las propiedades MAPI.

¿Se apoyan los archivos Unicode y ANSI MSG?

Sí sí. mapi_message Tiene un código de propiedad (Unicode) ptyp_stringy ANSI (ptyp_string8• Propiedades de la cordilla. unicode_strings() Retorno true Para mensajes almacenado con propiedades Unicode.

Sumación de referencia API

Clase / Método	Descripción
`mapi_message::from_file(path)`	Descargar un archivo MSG de una `std::filesystem::path`
`mapi_message::from_file(path, strict)`	Cargar con la opción de modo estricto
`mapi_message::from_stream(stream)`	Cargar MSG desde una `std::istream`
`mapi_message::from_stream(stream, strict)`	Cargar desde el flujo con la opción de modo estricto
`mapi_message::subject()`	Retorno de la mensaje subjetivo string
`mapi_message::body()`	Retorno al cuerpo de texto plain
`mapi_message::html_body()`	Retorno al cuerpo HTML (vaca si no está presente)
`mapi_message::sender_name()`	Retorno del nombre de la muestra del remitente
`mapi_message::sender_email_address()`	Retorno al correo electrónico del enviador
`mapi_message::internet_message_id()`	Retorno del RFC 2822 mensaje-ID
`mapi_message::message_class()`	Retorno a la línea de clase de mensajes MAPI
`mapi_message::recipients()`	Retorno a la lista de destinatarios
`mapi_message::attachments()`	Retornar la lista de adjetivos
`mapi_attachment::is_embedded_message()`	Si el adjunto es un MSG incorporado
`mapi_message::unicode_strings()`	Verdadero si el mensaje utiliza propiedades de la línea Unicode

Ver también

Aspose.Email for C++ — Enterprise Documentation

Lectura de archivos MSG