Comment convertir le code en C++

Aspose.Email FOSS for C++ supports bidirectional conversion between EML (RFC 5322 / Les modèles de l’équipement et les formats d’examen sont utilisés. mapi_message::load_from_eml() Pour importer un fichier, puis mapi_message::save() pour l’écrire comme MSG – et vice versa avec mapi_message::from_file() Suivi par mapi_message::save_to_eml().

Étape 1 - Définir le projet

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)

Étape 2 — Convertir EML à MSG (Path de fichier)

mapi_message::load_from_eml() parsent le fichier EML et exposent ses propriétés à travers La norme mapi_message Interface : Appel à l’interface save() Pour écrire le résultat comme MSG:

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

int main()
{
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("message.eml"));

    std::cout << "Subject: " << message.subject() << '\n';
    std::cout << "From:    " << message.sender_email_address() << '\n';

    message.save(std::filesystem::path("converted.msg"));
    std::cout << "Saved converted.msg\n";
}

Étape 3 — Convertir EML à MSG (Stream)

Utilisez le flux de surcharge de load_from_eml() Lorsque les données EML proviennent d’un réseau cache, buffer de mémoire ou autre std::istream:

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

int main()
{
    std::ifstream eml_stream("message.eml", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(eml_stream);

    message.save(std::filesystem::path("converted.msg"));
}

Étape 4 — Convertir MSG à EML

Télécharger un fichier existant avec mapi_message::from_file(),et ensuite sérialiser à EML Format avec save_to_eml():

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

    message.save_to_eml(std::filesystem::path("exported.eml"));
    std::cout << "Saved exported.eml\n";
}

Étape 5 – Tour complet (EML → MSG→ EML)

L’exemple suivant montre que le sujet, le corps, l’expéditeur, les destinataires et les pièces jointes sont tous conservés au cours d’un tour complet:

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

int main()
{
    const auto msg_path = std::filesystem::path("roundtrip.msg");
    const auto eml_out  = std::filesystem::path("roundtrip.eml");

    // EML → MSG
    auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("original.eml"));
    message.save(msg_path);

    // MSG → EML
    auto reloaded = aspose::email::foss::msg::mapi_message::from_file(msg_path);
    reloaded.save_to_eml(eml_out);

    std::cout << "Subject preserved: " << reloaded.subject() << '\n';
    std::cout << "Attachments: " << reloaded.attachments().size() << '\n';
}

Étape 6 — Convertir en EML Bytes dans la mémoire

Les deux save() et save_to_eml() avoir des surcharges d’argument zéro qui retournent std::vector<std::uint8_t>,Utile pour le streaming de résultats vers une connexion réseau ou La base de données sans toucher le système de fichiers :

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

int main()
{
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
        std::filesystem::path("message.eml"));

    // In-memory MSG bytes
    const auto msg_bytes = message.save();

    // In-memory EML bytes
    const auto eml_bytes = message.save_to_eml();
}

Problèmes courants et solutions

load_from_eml() Il s’agit d’un fichier valide. Vérifier l’utilisation du fichier RFC 5322 Les fichiers exportés par certains outils peuvent utiliser le LF nu. La bibliothèque Il s’agit d’une ligne de finition conforme aux normes.

Les pièces jointes manquantes après la conversion. Confirmez que le EML contient la norme MIME multipart/mixed ou multipart/related Les images en ligne. référencés via cid: Ils sont portés comme annexes dans le MSG et doivent être présents.

Le corps HTML perdu après MSG → EML. Le contenu HTML est préservé au cours du tour-trip Quand message.html_body() Il n’est pas vide, si seulement message.body() Il est peuplé dans la source MSG, le EML ne contiendra qu’une partie de texte simple.

save_to_eml() Le flux est vide. Les flux de sortie ouverts avec std::ios::binary.Les flux de mode texte corrompent la structure MIME dans Windows.

Le sujet contient ?= Codage des artefacts. Ce sont les 2047 séquences de mots codés. La bibliothèque les conserve comme il est. décode avec une bibliographie RFC 2047 Si vous avez besoin de l’unicode.

Questions fréquentes

Les pièces jointes sont-elles conservées dans les deux directions de conversion?

Les deux modes de conversion, les modèles et les paramètres sont intégrés dans le système. mapi_message Les pièces jointes binaires sont représentées comme des octets bruts dans les mapi_attachment::data.

Est-ce que le code HTML est conservé ?

Si le contenu contient un text/html MIME partie, elle est stockée dans le corps HTML MAPI Propriété et retour par message.html_body() Après le chargement.

Puis-je convertir en lot un répertoire de fichiers EML ?

Oui. itérer le répertoire avec std::filesystem::directory_iterator et appel mapi_message::load_from_eml() sur chaque .eml Le chemin, puis le sauvetage save():

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

int main()
{
    for (const auto& entry : std::filesystem::directory_iterator("emails/"))
    {
        if (entry.path().extension() == ".eml")
        {
            auto msg = aspose::email::foss::msg::mapi_message::load_from_eml(entry.path());
            auto out = entry.path();
            out.replace_extension(".msg");
            msg.save(out);
        }
    }
}

Qu’est-ce qui est conservé lors de la conversion ?

Sujet, corps de texte simple, HTML, nom d’expéditeur et adresse e-mail, liste des destinataires et toutes les pièces jointes MIME. flags, en-têtes de routage au-delà des entitres de transport de base et données codées par TNEF ne sont pas conservés.

est `load_from_eml()` Théâtre en sécurité ?

Chaque appel à load_from_eml() Créer un indépendant mapi_message L’instance, vous peut être appelé à partir de plusieurs fils simultanément, tant que chaque fil utilise son propre message objet de l’objet.