EML ו- MSG Conversion

Aspose.Email FOSS for C++ converts bidirectionally between 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

להעלות קובץ EML עם mapi_message::load_from_eml(),לאחר מכן, להוסיף את MSG עם 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() הפריסה של מבנה MIME ומפולאציה של נושא MAPI, טקסט שטוח גוף, גוף HTML, זהות המשלוח, רשימת הנמענים וכל החלקים של הקובץ.

הפוך MSG ל EML

להעלות קובץ MSG עם mapi_message::from_file(),ואז התקשר 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.טקסט-מוד זרמים תרגום קצה קו על Windows, שחיתות נתונים CFB בינארי.

תזכורת בזיכרון (In-Memory Conversion)

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

תגית: Batch Directory Conversion

תנו לי תיעוד עם std::filesystem::directory_iterator להפוך את כל .eml תגיות קשורות מסלול אחד:

#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) על זרם העומס כאשר יש לך מסלול; הדרך העומס העודף פותח את הקובץ פנימי וזה קצת יותר פשוט.
שימוש ב-Bit Overload (save() ו save_to_eml() ללא תועלת (למשל, כאשר נתונים מתפרסמים) בין השירותים להימנע קבצים זמניים.
נושא, גוף, גוף HTML, שרתים, קבלנים, ותוספי MIME נשמרים דרך מסלול סיבוב מלא.
דגלים של IMAP, כותרות הדרכה ותוכן מקודד TNEF אינם נלקחים באמצעות ההמרה.

בעיות נפוצות

נושא	סיבה	קבע
`load_from_eml` לשים על קובץ תקינה	קצה קו שאינו CRLF ב- EML	להבטיח EML משתמשת RFC 5322 CRLF; כמה כלי ייצוא לכתוב רק LF
תוספים חסרים לאחר EML → MSG	לא סטנדרטי MIME קובץ הקוד	בדוק את השימוש ב- EML `multipart/mixed` עם סטנדרט `Content-Disposition: attachment`
גוף HTML ריק לאחר MSG → EML	מקור MSG יש רק גוף טקסט שטוח	צפו `message.html_body()`;אם ריק, רק טקסט שטוח נשמר.
תנועת ה-TRAAM היא שחיתות	זרם פתוח במצב טקסט	תמיד להשתמש `std::ios::binary`
נושא הוכחה `?=` סקירה	RFC 2047 מילה מקודדת EML המקורי	דקוד עם ספרייה RFC 2047; הספרייה שומרת על הצורה הקודמת

FAQ

האם EML → MSG שומרת על הגוף HTML?

כן א text/html חלק MIME מאוחסן בתכונת הגוף של ה-MAPI HTML והוא זמין. דרך message.html_body() לאחר ההעלאה.

האם השילוב נשמר בשני הכיוונים?

כן, כל חלקי ההדבקה של MIME נלקחים דרך mapi_message רשימת תוספים. נתוני הדפסה בינארית זמינים כ attachment.data (א) א std::vector<std::uint8_t>).

האם אני יכול להמיר EML אחד לתבניות ייצוא מרובות בו זמנית?

כן, תוריד את EML פעם אחת עם load_from_eml(),ואז תתקשר לשניהם. save() ו save_to_eml() באותו זיכרון mapi_message אובייקט.

הוא `load_from_eml()` בטוח ברשת?

כל שיחה יוצרת עצמאות. mapi_message דוגמה: מספר שורות יכול להתקשר load_from_eml() כל עוד כל רצועה משתמשת באובייקט היציאה שלה.

מה קורה עם הודעות ללא גוף טקסט שטוח?

אם ה- EML מכיל רק אחד text/html חלק זה, message.body() החזיר רצועה ריקה ו message.html_body() תוכן HTML נשמר באמצעות MSG. סריאליזציה.

סיכום התייחסות API

שיעור / שיטה	תיאור
`mapi_message::load_from_eml(path)`	לחלק קובץ EML לתוך A `mapi_message`
`mapi_message::load_from_eml(stream)`	פרשת EML מ- A `std::istream`
`mapi_message::save(path)`	סריקה `mapi_message` קובץ MSG
`mapi_message::save(stream)`	כתוב את ה-MSG באט לאחד `std::ostream`
`mapi_message::save()`	חזרה ל MSG `std::vector<std::uint8_t>`
`mapi_message::from_file(path)`	להעלות קובץ MSG לתוך A `mapi_message`
`mapi_message::from_stream(stream)`	להעלות את MSG מ- A `std::istream`
`mapi_message::save_to_eml(path)`	כתוב EML למסלול קבצים
`mapi_message::save_to_eml(stream)`	כתוב את ה- EML באט לאחד `std::ostream`
`mapi_message::save_to_eml()`	חזרה אליך EML `std::vector<std::uint8_t>`

ראה גם

Aspose.Email for C++ — Enterprise Documentation

EML ו- MSG Conversion