Aspose.Email FOSS
C++
Utvecklarguide
EML och MSG konvertering

EML och MSG konvertering

EML och MSG konvertering

Aspose.Email FOSS for C++ converts bidirectionally between EML (RFC 5322 / MIME) och MSG (Outlook MAPI) format som används för att mapi_message.Konversionsvägen är: load_from_eml() In-minnet i minnet mapi_message → save() för EML→MSG, och from_file() / from_stream() → save_to_eml() För MSG→EML.

Konvertera EML till MSG

Ladda upp en EML-fil med mapi_message::load_from_eml(),och sedan serialisera till MSG med 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() Parsera MIME-strukturen och populerar MAPI-tema, platt text kropp, HTML-kropp, sändaridentitet, mottagarlista och alla bifogade delar.

Konvertera MSG till EML

Ladda upp en MSG-fil med mapi_message::from_file(),Och sedan ringer save_to_eml():

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

}


---

### Streambaserad konvertering

Alla fyra relevanta metoder accepteras `std::istream` / `std::ostream` Överbelastning för Pipeline-stil bearbetning utan att röra filsystemet:

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

Alltid öppna strömmar med std::ios::binary.Text-mode strömmar översätta linjeändar på Windows, korrupta binära CFB-data.

In-Memory Conversion (Bytes) och in-minnet omvandlas till

save() och save_to_eml() Båda har nollargument överbelastning returnerar std::vector<std::uint8_t>.Använd dessa för att undvika alla filsystem 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 omvandling

Skriv ett katalog med std::filesystem::directory_iterator för att konvertera alla .eml Filer i ett pass:

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 och bästa praxis

- Öppna alla filströmmar med `std::ios::binary` Både in och ut.
- Prefer `load_from_eml(path)` över ström överbelastning när du har en väg; vägen överbelastning hanterar filen öppnas intern och är något enklare.
- Använd bytesöverlåtelser (`save()` och `save_to_eml()` med inga arg) när data är kopplade till mellan tjänster för att undvika tillfälliga filer.
- Subject, body, HTML-kropp, sändare, mottagare och MIME-filer bevaras alla genom den fullständiga rundturen.
- IMAP-flaggor, routinghuvud och TNEF-kodat innehåll transporteras inte genom konvertering.

---

### Vanliga frågor

| Issue                                  | Cause                                  | Fixar                                                                                       |
| -------------------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------- |
| `load_from_eml` Hämta på en giltig fil | icke-CRLF linjeändningar i EML         | Säker EML använder RFC 5322 CRLF; vissa exportverktyg skriver bara LF                       |
| Saknade anslutningar efter EML → MSG   | icke-standard MIME bifogade kodning    | Kontrollera EML användning `multipart/mixed` med standard `Content-Disposition: attachment` |
| Vagt HTML-kropp efter MSG → EML        | Källa MSG har bara en platt-text kropp | Check `message.html_body()`;Om det är tomt, lagras endast tydlig text.                      |
| Strömproduktionen är korrupt           | Stream öppnas i textläge               | Aldrig använda `std::ios::binary`                                                           |
| Subject visar `?=` sekvenser           | RFC 2047 kodad-ord i original EML      | Decodera med en RFC 2047 bibliotek; biblioteket behåller kodad form                         |

---

### FAQ

#### Försvårar EML → MSG HTML-kroppen?

Ja, A är `text/html` MIME-del lagras i MAPI HTML kroppsegenskapen och är tillgänglig via `message.html_body()` efter laddning.

#### Är anslutningar bevarade i båda riktningarna?

Alla MIME-fästdelar transporteras genom `mapi_message` Anslutningslista . Binära bilagor är tillgängliga som `attachment.data` (a) och `std::vector<std::uint8_t>`).

#### Kan jag konvertera en enda EML till flera utgångsformat samtidigt?

Ladda EML en gång med `load_from_eml()`,Och ringer båda `save()` och `save_to_eml()` på samma in-minnes `mapi_message` och objekt.

#### är `load_from_eml()` Trådsäkerhet ?

Varje samtal skapar en oberoende `mapi_message` Exempel: flera trådar kan ringa `load_from_eml()` samtidigt så länge varje tråd använder sitt eget utgångsobjekt.

#### Vad händer med meddelanden utan en platt text kropp?

Om EML endast innehåller en `text/html` del av, `message.body()` återställer en tom sträng och `message.html_body()` bär HTML-innehållet. båda bevaras via MSG Seriering av .

---

### API Referens sammanfattning

| Klass / Metod                         | Beskrivning                                     |
| ------------------------------------- | ----------------------------------------------- |
| `mapi_message::load_from_eml(path)`   | Delar en EML-fil i ett `mapi_message`           |
| `mapi_message::load_from_eml(stream)` | Parse EML från en `std::istream`                |
| `mapi_message::save(path)`            | Serialize `mapi_message` Till en MSG-fil        |
| `mapi_message::save(stream)`          | Skriv MSG bytes till en `std::ostream`          |
| `mapi_message::save()`                | Återgå till MSG som `std::vector<std::uint8_t>` |
| `mapi_message::from_file(path)`       | Ladda upp en MSG-fil i ett `mapi_message`       |
| `mapi_message::from_stream(stream)`   | Ladda MSG från en `std::istream`                |
| `mapi_message::save_to_eml(path)`     | Skriv EML till en filvägen                      |
| `mapi_message::save_to_eml(stream)`   | Skriv EML bytes till en `std::ostream`          |
| `mapi_message::save_to_eml()`         | Återgå till EML som `std::vector<std::uint8_t>` |

## Se även

- [Aspose.Email for C++ — Enterprise Documentation](https://docs.aspose.com/email/cpp/)
 Svenska