SDK voor bestanden - E-mail .msg bestanden verwerken (C++)

De File SDK ondersteunt labelbewerkingen voor .msg bestanden op dezelfde manier als elk ander bestandstype, behalve dat de SDK de toepassing nodig heeft om de MSG-functievlag in te schakelen. In deze quickstart ziet u hoe u deze vlag instelt.

Zoals eerder besproken, vereist instantiëren mip::FileEngine het mip::FileEngineSettings instellingenobject. De toepassing gebruikt FileEngineSettings om aangepaste instellingen voor een bepaald exemplaar door te geven. De CustomSettings eigenschap van mip::FileEngineSettings stelt de enable_msg_file_type vlag in om verwerking van .msg bestanden mogelijk te maken.

Vereiste voorwaarden

Als u dat nog niet hebt gedaan, moet u de volgende vereisten voltooien voordat u doorgaat:

Voltooi eerst de Quickstart: Initialisatie van bestands-SDK-toepassingen (C++), waarmee een eenvoudige Visual Studio-oplossing wordt gebouwd. Deze quickstart 'Hoe te - e-mailbericht .msg bestanden verwerken (C++)' is gebaseerd op de vorige.
Review Snelstart: Vertrouwelijkheidslabels (C++) opsommen.
Snelstart: Vertrouwelijkheidslabels instellen/ophalen (C++).
Bekijk de MIP SDK-concepten voor e-mailbestanden .
Optioneel: Bekijk de bestandsengines in de MIP SDK-concepten.
Optioneel: Bekijk de bestandshandlers in de MIP SDK-concepten.

Vereiste implementatiestappen

Open de Visual Studio-oplossing die u in het vorige artikel 'Quickstart: Initialisatie van clienttoepassingen (C++)' hebt gemaakt.
Maak een PowerShell-script voor het genereren van toegangstokens, zoals wordt uitgelegd in quickstart: Vertrouwelijkheidslabels (C++) vermelden.
Implementeer een waarnemerklasse om te bewakenmip::FileHandler, zoals wordt uitgelegd in quickstart: Vertrouwelijkheidslabels instellen/ophalen (C++).

Enable_msg_file_type instellen en bestands-SDK gebruiken om .msg bestand te labelen

Voeg de volgende code toe om de enable_msg_file_type vlag in te stellen en de bestandsengine te gebruiken om een .msg-bestand te labelen.

Open in Solution Explorer het bestand .cpp in uw project dat de implementatie van de main() methode bevat. Deze wordt standaard ingesteld op dezelfde naam als het project dat het bevat, die u hebt opgegeven tijdens het maken van het project.

Voeg de volgende #include- en using-instructies toe na de overeenkomstige bestaande instructies, bovenaan het bestand:

#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 
#include <iostream>    
using mip::FileHandler;   
using std::endl;

Verwijder de implementatie van de main() functie uit de vorige quickstart. Voeg in de main() hoofdtekst de volgende code in. In het volgende codeblok wordt bij het aanmaken van de bestandsengine de vlag enable_msg_file_type ingesteld. mip::FileHandler objecten die zijn gemaakt met behulp van de bestandsengine, kunnen vervolgens een .msg-bestand verwerken.

int main()
{
    // Construct/initialize objects required by the application's profile object
    ApplicationInfo appInfo { "<application-id>",                    // ApplicationInfo object (App ID, name, version)
                              "<application-name>", 
                              "1.0" 
    };

    std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(appInfo,
				                                                                                       "mip_data",
                                                                                        			   mip::LogLevel::Trace,
                                                                                                       false,
                                                                                                       mip::CacheStorageType::OnDisk);

    std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

    auto profileObserver = make_shared<ProfileObserver>();                      // Observer object
    auto authDelegateImpl = make_shared<AuthDelegateImpl>("<application-id>");  // Authentication delegate object (App ID)
    auto consentDelegateImpl = make_shared<ConsentDelegateImpl>();              // Consent delegate object

    // Construct/initialize profile object
    FileProfile::Settings profileSettings(mMipContext, mip::CacheStorageType::OnDisk,
        consentDelegateImpl, profileObserver);

    // Set up promise/future connection for async profile operations; load profile asynchronously
    auto profilePromise = make_shared<promise<shared_ptr<FileProfile>>>();
    auto profileFuture = profilePromise->get_future();
    try
    {
        mip::FileProfile::LoadAsync(profileSettings, profilePromise);
    }
    catch (const std::exception& e)
    {
        std::cout << "An exception occurred. Are the Settings and ApplicationInfo objects populated correctly?\n\n"<< e.what() << "'\n";
        system("pause");
        return 1;
    }

    auto profile = profileFuture.get();

    // Construct/initialize engine object
    FileEngine::Settings engineSettings(
                            mip::Identity("<engine-account>"),      // Engine identity (account used for authentication)
                            authDelegateImpl,                       // Token acquisition implementation
                            "<engine-state>",                       // User-defined engine state
                            "en-US");                               // Locale (default = en-US)

    //Set enable_msg_file_type flag as true
    std::vector<std::pair<string, string>> customSettings;
    customSettings.emplace_back(mip::GetCustomSettingEnableMsgFileType(), "true");
    engineSettings.SetCustomSettings(customSettings);

    // Set up promise/future connection for async engine operations; add engine to profile asynchronously
    auto enginePromise = make_shared<promise<shared_ptr<FileEngine>>>();
    auto engineFuture = enginePromise->get_future();
    profile->AddEngineAsync(engineSettings, enginePromise);
    std::shared_ptr<FileEngine> engine;

    try
    {
        engine = engineFuture.get();
    }
    catch (const std::exception& e)
    {
        cout << "An exception occurred... is the access token incorrect/expired?\n\n"<< e.what() << "'\n";
        system("pause");
        return 1;
    }

    //Set file paths
    string inputFilePath = "<input-file-path>"; //.msg file to be labeled
    string actualFilePath = inputFilePath;
    string outputFilePath = "<output-file-path>"; //labeled .msg file
    string actualOutputFilePath = outputFilePath;

    //Create a file handler for original file
    auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
    auto handlerFuture = handlerPromise->get_future();

    engine->CreateFileHandlerAsync(inputFilePath,
                                    actualFilePath,
                                    true,
                                    std::make_shared<FileHandlerObserver>(),
                                    handlerPromise);

    auto fileHandler = handlerFuture.get();

    //List labels available to the user    

    // Use mip::FileEngine to list all labels
    auto labels = engine->ListSensitivityLabels();

    // Iterate through each label, first listing details
    for (const auto& label : labels) {
        cout << label->GetName() << " : " << label->GetId() << endl;

        // get all children for mip::Label and list details
        for (const auto& child : label->GetChildren()) {
            cout << "->  " << child->GetName() << " : " << child->GetId() << endl;
        }
    }

    string labelId = "<labelId-id>"; //set a label ID to use

    // Labeling requires a mip::LabelingOptions object. 
    // Review API ref for more details. The sample implies that the file was labeled manually by a user.
    mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);

    // Resolve the label ID to a mip::Label, then apply it.
    auto label = engine->GetLabelById(labelId);
    fileHandler->SetLabel(label, labelingOptions, mip::ProtectionSettings());

    // Commit changes, save as outputFilePath
    auto commitPromise = std::make_shared<std::promise<bool>>();
    auto commitFuture = commitPromise->get_future();

    if(fileHandler->IsModified())
    {
        fileHandler->CommitAsync(outputFilePath, commitPromise);
    }
    
    if (commitFuture.get()) {
        cout << "\n Label applied to file: " << outputFilePath << endl;
    }
    else {
        cout << "Failed to label: " + outputFilePath << endl;
        return 1;
    }

    // Create a new handler to read the label
    auto msgHandlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
    auto msgHandlerFuture = msgHandlerPromise->get_future();

    engine->CreateFileHandlerAsync(inputFilePath,
                                    actualFilePath,
                                    true,
                                    std::make_shared<FileHandlerObserver>(),
                                    msgHandlerPromise);

    auto msgFileHandler = msgHandlerFuture.get();

    cout << "Original file: " << inputFilePath << endl;
    cout << "Labeled file: " << outputFilePath << endl;
    cout << "Label applied to file : " 
            << msgFileHandler->GetLabel()->GetLabel()->GetName() 
            << endl;
    
    // Application shutdown. Null out profile, engine, handler.
    // Application may crash at shutdown if resources aren't properly released.
    msgFileHandler = nullptr;
    fileHandler = nullptr;
    engine = nullptr;
    profile = nullptr;
    mMipContext->ShutDown();
    mMipContext = nullptr;

    return 0;
}

Zie bestandshandlerconcepten voor meer informatie over bestandsbewerkingen.

Vervang de tijdelijke aanduidingen in de broncode door de volgende waarden:

Plaatsvervanger	Waarde
<toepassings-ID>	De toepassings-id zoals geregistreerd bij de Microsoft Entra-tenant, bijvoorbeeld: `00001111-aaaa-2222-bbbb-3333cccc4444`.
<engine-account>	Het account dat wordt gebruikt voor de identiteit van de engine, bijvoorbeeld: `user@tenant.onmicrosoft.com`.
<motorconditie>	Door de gebruiker gedefinieerde toepassingsstatus, bijvoorbeeld: `My engine state`.
<input-file-path>	Het volledige pad naar een testinvoerberichtbestand, bijvoorbeeld: `c:\\Test\\message.msg`.
<uitvoer-bestand-pad>	Het volledige pad naar het uitvoerbestand, een gelabelde kopie van het invoerbestand, bijvoorbeeld: `c:\\Test\\message_labeled.msg`
<label-id>	De label-id die is opgehaald met behulp van `ListSensitivityLabels`bijvoorbeeld: `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

De toepassing bouwen en testen

Gebruik F6 (Build Solution) om uw clienttoepassing te bouwen. Als u geen buildfouten hebt, gebruikt u F5 (Foutopsporing starten) om uw toepassing uit te voeren.

Feedback

Is deze pagina nuttig?

Last updated on 2026-09-21