Lecture des fichiers MSG

mapi_message est le point d’entrée pour télécharger et parser les fichiers MSG Outlook. Appel à from_file() ou from_stream() Lire le conteneur complet CFB, extraire tous les MAPI propriétés, et les exposer par le biais des méthodes d’accessoire typographiées — pas de Outlook installation nécessaire !.

Réserver un fichier de route

Utiliser mapi_message::from_file() Avec 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';
}

Résumé d’un courant

Utiliser mapi_message::from_stream() Lorsque les données MSG viennent d’un socket réseau, un archives ou tout autre 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';
}

Toujours ouvrir le courant avec std::ios::binary.Texte-mode Streams ligne de traduction Finir sur Windows et corrompre le conteneur CFB.

Propriétés de messagerie d’accès

mapi_message Il expose les propriétés de message les plus courantes appelées ghetters :

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

Récepteurs Iterate

message.recipients() Retour à A std::vector des objets récepteurs avec display_name, email_address,et 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';
    }
}

Les liens Iterate

message.attachments() Retour à A std::vector - Les objets de l’affichage. chaque exposé filename, mime_type, data, content_id,et 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()));
        }
    }
}

Accès aux messages intégrés

Quand is_embedded_message() est true,Le fichier contient un autre fichie MSG. Accès à travers 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"));
        }
    }
}

Conseils et meilleures pratiques

toujours passée std::ios::binary à std::ifstream Lorsque vous téléchargez les fichiers MSG.
Vérifier html_body() Avant body() - Les messages HTML uniquement stockent leur contenu dans le Propriété du corps HTML et laisse body() Vague !.
from_file() charge tous les données d’annexe dans la mémoire. Pour de grands fichiers MSG, considérer ouvrir le conteneur avec msg_reader - Inspecter les méta-data sans être complètement - La mise en œuvre des bits d’adhésion.
Le strict Paramètres de from_file(path, strict) et from_stream(stream, strict) Défauts à false,tolérer les déviations structurelles mineures dans les fichiers MSG du monde réel.
Les objets de réception exposent recipient_type Pour distinguer To, Cc et Bcc entrées.

Les problèmes communs

Problème	Cause	Fixé
`msg_exception` sur un fichier valide-looking	Le fichier n’est pas un réel conteneur OLE CFB	Vérifier avec `cfb_reader::from_file()` - si elle jette aussi, le fichier n’est pas valide MSG
`body()` Retourner la ligne vide	Le message n’utilise que le corps HTML	Utiliser `html_body()` Au lieu de
`recipients()` est vide	MSG sans tableau de récepteur	Accès `display_to` par via `get_property_value()` avec `common_message_property_id::display_to`
Corruption sur Windows	Le courant s’ouvre sans `std::ios::binary`	ajouter `std::ios::binary` Drapeau à `std::ifstream`
Utilisation de grande mémoire pour les fichiers	Tous les données de l’annexe sont chargées en avant	Utiliser `msg_reader` Pour un accès bas sans matérialisation complète

FAQ

Le fait `from_file()` Garder le fichier ouvert ?

Non. Le fichier est ouvert, entièrement parsé et fermé avant que la méthode ne revient. Vous pouvez déplacer ou supprimer le fichie source après l’appel.

Comment puis-je savoir si un attachement est un fichier ou un MSG intégré?

Appel à attachment.is_embedded_message().Retourner true pour les fichiers MSG intégrés ; false pour les annexes régulières de fichiers. Pour les messages intégrés, accéder à l’objet nés par via attachment.embedded_message.

Quelle est la différence entre `from_file()` et utilisant `msg_reader`?

mapi_message::from_file() est l’API de haut niveau – il parse le message complet et Exposer les propriétés comme des champs typiques. msg_reader C’est le lecteur de bas niveau qui donne Accès à la structure du conteneur de CFB crude et est utile lorsque vous avez besoin d’inspecter Layout de message sans parer toutes les propriétés MAPI.

Les fichiers Unicode et ANSI MSG sont-ils tous les deux soutenus ?

Oui oui. mapi_message Unicode (type propriété) ptyp_stringet ANSI (ptyp_string8Les propriétés de string. unicode_strings() Retourner true Pour les messages Il est stocké avec des propriétés Unicode.

Le résumé de référence API

Classes / Méthodes	Description
`mapi_message::from_file(path)`	Télécharger un fichier MSG à partir d’un `std::filesystem::path`
`mapi_message::from_file(path, strict)`	Réserver avec option de mode strict
`mapi_message::from_stream(stream)`	Mise en charge de MSG à partir d’un `std::istream`
`mapi_message::from_stream(stream, strict)`	Réserver le courant avec option de mode strict
`mapi_message::subject()`	Retourner le message sujet string
`mapi_message::body()`	Retourner le corps de texte plain
`mapi_message::html_body()`	Retourner le corps HTML (vraie si pas présent)
`mapi_message::sender_name()`	Retourner le nom de l’affichage du messager
`mapi_message::sender_email_address()`	Retourner l’adresse email de l’envoyant
`mapi_message::internet_message_id()`	Récupérer le titre de messagerie RFC 2822
`mapi_message::message_class()`	Retourner la ligne de classe MAPI message
`mapi_message::recipients()`	Retourner la liste des destinataires
`mapi_message::attachments()`	Retourner la liste d’adhésion
`mapi_attachment::is_embedded_message()`	Si le lien est un MSG intégré
`mapi_message::unicode_strings()`	Très vrai si le message utilise les propriétés de string Unicode

Voir aussi

Aspose.Email for C++ — Enterprise Documentation

Lecture des fichiers MSG