EML और MSG रूपांतरण

EML और MSG रूपांतरण

Aspose.Email FOSS for C++ द्विदिश रूप से के बीच परिवर्तित करता है EML (RFC 5322 / MIME) और MSG (Outlook MAPI) फ़ॉर्मेट्स का उपयोग करके mapi_message. परिवर्तन पथ है: load_from_eml() → इन-मेमोरी mapi_message → save() EML→MSG के लिये, और from_file() / from_stream() → save_to_eml() MSG→EML के लिये।

EML को MSG में परिवर्तित करें

mapi_message::load_from_eml() के साथ एक EML फ़ाइल लोड करें, फिर save() के साथ 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';
    message.save(std::filesystem::path("converted.msg"));
    std::cout << "Saved converted.msg\n";
}

load_from_eml() MIME संरचना को पार्स करता है और MAPI विषय, प्लेन-टेक्स्ट बॉडी, HTML बॉडी, प्रेषक पहचान, प्राप्तकर्ता सूची, और सभी अटैचमेंट भागों को भरता है।

MSG को EML में परिवर्तित करें

mapi_message::from_file() के साथ एक MSG फ़ाइल लोड करें, फिर 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";
}

स्ट्रीम-आधारित रूपांतरण

सभी चार संबंधित विधियाँ std::istream / std::ostream ओवरलोड्स को स्वीकार करती हैं, जिससे पाइपलाइन-शैली प्रोसेसिंग फ़ाइल-सिस्टम को छुए बिना की जा सके:

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

हमेशा स्ट्रीम्स को std::ios::binary के साथ खोलें। टेक्स्ट-मोड स्ट्रीम्स विंडोज़ पर लाइन एंडिंग्स को अनुवादित करते हैं, जिससे बाइनरी CFB डेटा भ्रष्ट हो जाता है।

इन-मेमोरी रूपांतरण (बाइट्स)

save() और save_to_eml() दोनों में शून्य-आर्ग्यूमेंट ओवरलोड्स होते हैं जो std::vector<std::uint8_t> लौटाते हैं। सभी फ़ाइल-सिस्टम 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...
}

बैच डायरेक्टरी रूपांतरण

एक पास में सभी .eml फ़ाइलों को रूपांतरित करने के लिए std::filesystem::directory_iterator के साथ एक डायरेक्टरी को इटरेट करें:

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

टिप्स और सर्वोत्तम प्रथाएँ

• सभी फ़ाइल स्ट्रिम्स को std::ios::binary के साथ खोलें — इनपुट और आउटपुट दोनों।
• जब आपके पास पाथ हो तो स्ट्रीम ओवरलोड के बजाय load_from_eml(path) को प्राथमिकता दें; पाथ ओवरलोड फ़ाइल खोलने को आंतरिक रूप से संभालता है और थोड़ा सरल है।
• सेवाओं के बीच डेटा पाइप करने पर अस्थायी फ़ाइलों से बचने के लिए बाइट ओवरलोड्स (save() और save_to_eml() बिना आर्गुमेंट्स के) का उपयोग करें।
• विषय, बॉडी, HTML बॉडी, प्रेषक, प्राप्तकर्ता, और MIME अटैचमेंट्स सभी पूर्ण राउंड-ट्रिप के दौरान संरक्षित रहते हैं।
• IMAP फ़्लैग्स, रूटिंग हेडर्स, और TNEF-एन्कोडेड कंटेंट रूपांतरण के दौरान नहीं ले जाए जाते।

सामान्य समस्याएँ

FAQ

क्या EML → MSG HTML बॉडी को संरक्षित करता है?

हाँ। एक text/html MIME भाग MAPI HTML बॉडी प्रॉपर्टी में संग्रहीत होता है और लोड करने के बाद message.html_body() के माध्यम से पहुँचा जा सकता है।

क्या अटैचमेंट दोनों दिशाओं में संरक्षित रहते हैं?

हाँ। सभी MIME अटैचमेंट भाग mapi_message अटैचमेंट सूची के माध्यम से ले जाए जाते हैं। बाइनरी अटैचमेंट डेटा attachment.data के रूप में उपलब्ध है (एक std::vector<std::uint8_t>)।

क्या मैं एकल EML को एक साथ कई आउटपुट फ़ॉर्मेट में परिवर्तित कर सकता हूँ?

हाँ। load_from_eml() के साथ EML को एक बार लोड करें, फिर समान इन-मेमारी mapi_message ऑब्जेक्ट पर दोनों save() और save_to_eml() को कॉल करें।

क्या load_from_eml() थ्रेड-सेफ है?

प्रत्येक कॉल एक स्वतंत्र mapi_message इंस्टेंस बनाता है। कई थ्रेड्स load_from_eml() को एक साथ कॉल कर सकते हैं, बशर्ते प्रत्येक थ्रेड अपना आउटपुट ऑब्जेक्ट उपयोग करे।

जब संदेश में कोई साधारण-पाठ बॉडी नहीं होती तो क्या होता है?

यदि EML में केवल एक text/html भाग हो, तो message.body() एक खाली स्ट्रिंग लौटाता है और message.html_body() HTML सामग्री ले जाता है। दोनों को MSG सीरियलाइज़ेशन के माध्यम से संरक्षित किया जाता है।

API Reference सारांश

यह भी देखें

• Aspose.Email for C++ — Enterprise Documentation