SDK plików — proces e-mailowych plików .msg (C++)

Zestaw SDK plików obsługuje operacje etykietowania dla plików .msg w taki sam sposób, jak w przypadku dowolnego innego typu pliku, z wyjątkiem tego, że zestaw SDK wymaga aplikacji włączenia flagi funkcji MSG. Ten przewodnik szybkiego startu pokazuje, jak ustawić tę flagę.

Jak wspomniano wcześniej, utworzenie instancji mip::FileEngine wymaga obiektu ustawień mip::FileEngineSettings. Aplikacja korzysta z FileEngineSettings do przekazywania ustawień niestandardowych dla konkretnej instancji. Właściwość CustomSettingsmip::FileEngineSettings ustawia flagę enable_msg_file_type , aby umożliwić przetwarzanie plików .msg.

Wymagania wstępne

Jeśli jeszcze tego nie zrobiono, przed kontynuowaniem upewnij się, że zostały spełnione następujące wymagania wstępne:

Najpierw ukończ szybki start: inicjację aplikacji Pakietu SDK plików (C++), co tworzy początkowe rozwiązanie programu Visual Studio. Na tym szybkim przewodniku "Jak przetwarzać pliki wiadomości e-mail .msg (C++)" bazuje się na poprzednim.
Zapoznaj się z przewodnikiem Szybki start: wyświetlanie listy etykiet poufności (C++).
Recenzja Przewodnik szybkiego startu: ustawianie/uzyskiwanie etykiet dotyczących poziomu poufności (C++).
Zapoznaj się z pojęciami dotyczącymi MIP SDK dla plików e-mail.
Opcjonalnie: Zapoznaj się z pojęciami dotyczącymi silników plików w zestawie MIP SDK.
Opcjonalnie: Zapoznaj się z koncepcjami obsługi plików w zestawie MIP SDK.

Kroki implementacji wymagań wstępnych

Otwórz rozwiązanie programu Visual Studio utworzone w poprzednim artykule "Szybki start: inicjowanie aplikacji klienckiej (C++)".
Utwórz skrypt programu PowerShell do generowania tokenów dostępu, zgodnie z opisem w Szybki przewodnik: wyświetlanie listy etykiet poufności (C++).
Zaimplementuj klasę obserwatora, aby monitorować mip::FileHandler, jak wyjaśniono w przewodniku Szybki start: ustawianie/pobieranie etykiet poufności (C++).

Ustaw enable_msg_file_type i użyj File SDK do oznaczania pliku .msg

Dodaj poniższy kod tworzący mechanizm plików, aby ustawić flagę enable_msg_file_type i użyć mechanizmu plików do nadania etykiety plikowi .msg.

W Eksplorator rozwiązań otwórz plik .cpp w projekcie zawierający implementację main() metody . Domyślnie ma taką samą nazwę jak projekt zawierający go, który został określony podczas tworzenia projektu.

Dodaj następujące dyrektywy #include i using po odpowiadających im istniejących dyrektywach, na początku pliku:

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

Usuń implementację funkcji main() z poprzedniego przewodnika Szybki start. main() Wewnątrz treści wstaw następujący kod. W poniższym bloku kodu tworzenie silnika plików ustawia flagę enable_msg_file_type. mip::FileHandler obiekty utworzone przy użyciu silnika plików mogą następnie przetwarzać plik .msg.

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

Aby uzyskać więcej informacji na temat operacji na plikach, zobacz Pojęcia dotyczące obsługi plików.

Zastąp wartości symboli zastępczych w kodzie źródłowym następującymi wartościami:

Element zastępczy	Wartość
<identyfikator aplikacji>	Identyfikator aplikacji zarejestrowany w dzierżawie platformy Microsoft Entra, na przykład: `00001111-aaaa-2222-bbbb-3333cccc4444`.
<konto silnika>	Konto używane na potrzeby tożsamości silnika, na przykład: `user@tenant.onmicrosoft.com`.
<stan silnika>	Stan aplikacji zdefiniowanej przez użytkownika, na przykład: `My engine state`.
<ścieżka pliku wejściowego>	Pełna ścieżka do pliku komunikatu wejściowego testu, na przykład: `c:\\Test\\message.msg`.
<ścieżka pliku wyjściowego>	Pełna ścieżka do pliku wyjściowego, który jest kopią pliku wejściowego z etykietami, na przykład: `c:\\Test\\message_labeled.msg`.
<label-id>	Identyfikator etykiety uzyskany za pomocą `ListSensitivityLabels`, na przykład: `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Kompilowanie i testowanie aplikacji

Skompiluj aplikację kliencą przy użyciu F6 (rozwiązanie kompilacji). Jeśli nie masz błędów kompilacji, użyj klawisza F5 (Rozpocznij debugowanie), aby uruchomić aplikację.

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2026-09-21