EML et MSG Conversion

EML et MSG Conversion

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) et MSG (Outlook MAPI) formats utilisant mapi_message.Le chemin de conversion est : load_from_eml() En mémoire mapi_message → save() pour EML, MSG et from_file() / from_stream() → save_to_eml() Pour MSG et EML.

Convertir EML en MSG

Téléchargez un fichier EML avec mapi_message::load_from_eml(),Il s’agit de sérialiser MSG avec save():

#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';
    message.save(std::filesystem::path("converted.msg"));
    std::cout << "Saved converted.msg\n";
}

load_from_eml() Parse la structure MIME et populate le sujet MAPI, texte plain corps, corps HTML, identité de l’envoi, liste des destinataires et toutes les pièces d’annexe.

Convertir MSG en EML

Téléchargez un fichier MSG avec mapi_message::from_file(),Et puis appeler 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";
}

Conversion basée sur le courant

Les quatre méthodes pertinentes sont acceptées std::istream / std::ostream surcharge pour Traitement en style de pipeline sans toucher le système de fichiers :

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

int main()
{
    // EML → MSG via streams
    std::ifstream eml_in("message.eml", std::ios::binary);
    const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(eml_in);

    std::ofstream msg_out("converted.msg", std::ios::binary);
    message.save(msg_out);

    // MSG → EML via streams
    std::ifstream msg_in("converted.msg", std::ios::binary);
    const auto reloaded = aspose::email::foss::msg::mapi_message::from_stream(msg_in);

    std::ofstream eml_out("roundtrip.eml", std::ios::binary);
    reloaded.save_to_eml(eml_out);
}

Toujours ouvert avec std::ios::binary.Texte-mode Streams traduire les finitions de la ligne sur Windows, corrompre les données binaire CFB.

La conversion en mémoire (Bytes)

save() et save_to_eml() Les deux ont un argument de surcharge zéro retournant std::vector<std::uint8_t>.Utilisez ces éléments pour éviter tous les systèmes de fichiers I/O :

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

    const std::vector<std::uint8_t> msg_bytes  = message.save();
    const std::vector<std::uint8_t> eml_bytes  = message.save_to_eml();

    // Write to a database, network socket, or other destination...
}

Conversion de la catégorie Batch Directory

Créer un catalogue avec std::filesystem::directory_iterator Pour convertir tout .eml Les fichiers en un seul passage :

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

int main()
{
    const std::filesystem::path input_dir("emails/eml");
    const std::filesystem::path output_dir("emails/msg");
    std::filesystem::create_directories(output_dir);

    for (const auto& entry : std::filesystem::directory_iterator(input_dir))
    {
        if (entry.path().extension() != ".eml")
            continue;

        const auto message = aspose::email::foss::msg::mapi_message::load_from_eml(
            entry.path());

        auto out_path = output_dir / entry.path().filename();
        out_path.replace_extension(".msg");
        message.save(out_path);

        std::cout << "Converted: " << entry.path().filename() << '\n';
    }
}

Conseils et meilleures pratiques

• Ouvrez tous les fichiers avec std::ios::binary - entrée et sortie.
• Préférez load_from_eml(path) sur le flux de surcharge quand vous avez un chemin ; le chemin Le surcharge gère l’ouverture de fichiers à l’intérieur et est légèrement plus simple.
• Utilisez les bits de surcharge (save() et save_to_eml() sans args) lorsqu’on met en scène les données entre les services pour éviter des fichiers temporaires.
• Subject, corps, HTML corps , messager, récepteurs et annexes MIME sont tous conservés à travers le parcours complet.
• Les drapeaux IMAP, les rubriques de routing et le contenu codé TNEF ne sont pas transférés par la conversion.

Les problèmes communs

FAQ

EML → MSG sauve-t-il le corps HTML ?

Oui A text/html La partie MIME est stockée dans la propriété du corps HTML de MAPI et est accessible. par via message.html_body() Après le chargement.

Les liens sont-ils conservés dans les deux directions ?

Oui, toutes les pièces d’adhésion MIME sont transférées à travers le mapi_message Liste de liens. Les données d’adhésion binaires sont disponibles comme attachment.data (A) à std::vector<std::uint8_t>).

Puis-je convertir un seul EML en plusieurs formats de sortie simultanément?

Oui, remplissez l’EML une fois avec load_from_eml(),Appelez les deux save() et save_to_eml() Dans la même mémoire mapi_message objets .

est load_from_eml() Le Thread ?

Chaque appel crée une indépendante mapi_message Par exemple, plusieurs filets peuvent appeler load_from_eml() en même temps que chaque fil utilise son propre objet de sortie.

Que se passe-t-il avec les messages sans corps de texte plain ?

Si le EML ne contient qu’un text/html partie de la, message.body() Retourner une ligne vide et message.html_body() Le contenu HTML est conservé par MSG. La sérialisation.

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

Voir aussi

• Aspose.Email for C++ — Enterprise Documentation