Konversi EML dan MSG

Konversi EML dan MSG

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) dan (b) MSG Format (Outlook MAPI) yang menggunakan mapi_message.Jalur konversi adalah: load_from_eml() → dalam memori mapi_message → save() untuk EML→MSG, dan from_file() / from_stream() → save_to_eml() untuk MSG→EML.

Mengkonversi EML menjadi MSG

Mengisi file EML dengan mapi_message::load_from_eml(), kemudian diserialisasi menjadi MSG dengan 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() menguraikan struktur MIME dan mengisi subjek MAPI, plain-text body, HTML body , sender identity, list recipient, dan semua bagian attachment.

Mengkonversi MSG menjadi EML

Mengunggah file MSG dengan mapi_message::from_file(), lalu hubungi 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";
}

Konversi berbasis aliran

Keempat metode yang relevan menerima std::istream / std::ostream overload untuk Pemrosesan gaya pipeline tanpa menyentuh sistem file:

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

Selalu terbuka dengan aliran yang lebih baik. std::ios::binary. Streams mode teks menerjemahkan akhir baris pada Windows, merusak data CFB biner.

Konversi dalam memori (Byte)

save() dan (b) save_to_eml() keduanya memiliki overload nol-argumen yang mengembalikan std::vector<std::uint8_t>.Gunakan ini untuk menghindari semua I/O file system:

#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...
}

Konversi Direktori Batch

Mengulang direktori dengan std::filesystem::directory_iterator untuk mengubah semua .eml file dalam satu kali:

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

Tips dan Praktik Terbaik

• Buka semua file dengan: std::ios::binary input dan output.
• Prefer (Mengutamakan) load_from_eml(path) di atas aliran kelebihan beban ketika Anda memiliki jalur; jalan overload menangani file pembukaan secara internal dan sedikit lebih sederhana.
• Gunakan byte overloads (save() dan (b) save_to_eml() tanpa arg) saat data pipa antara layanan untuk menghindari file sementara.
• Subjek, body, HTML body , sender, recipients, dan MIME attachments semuanya dilestarikan melalui perjalanan pulang-pergi penuh.
• Bendera IMAP, header routing, dan konten yang dikodekan TNEF tidak dibawa melalui konversi.

Masalah Umum

FAQ

Apakah EML → MSG mempertahankan tubuh HTML?

Ya, A. text/html Bagian MIME disimpan dalam properti body HTML MAPI dan dapat diakses. melalui: message.html_body() setelah pengisian.

Apakah lampiran tetap di kedua arah?

Ya. Semua bagian lampiran MIME dibawa melalui mapi_message daftar lampiran. Data lampiran biner tersedia sebagai: attachment.data (a) std::vector<std::uint8_t>).

Bisakah saya mengkonversi EML tunggal ke beberapa format output secara bersamaan?

Ya, muat EML sekali dengan… load_from_eml(), lalu panggil keduanya save() dan (b) save_to_eml() pada memori yang sama mapi_message obyek.

adalah: load_from_eml() aman untuk benang?

Setiap panggilan menciptakan independen mapi_message instance. Beberapa thread dapat memanggil load_from_eml() secara bersamaan selama setiap thread menggunakan objek outputnya sendiri.

Apa yang terjadi pada pesan tanpa teks sederhana?

Jika EML hanya berisi sebuah text/html bagian, message.body() mengembalikan string kosong dan (b) message.html_body() Kedua-duanya dilestarikan melalui MSG. serialisasi.

Ringkasan Referensi API