Szybki start: ustawianie i uzyskiwanie etykiety poufności (C++)

W tym przewodniku Szybki start pokazano, jak używać większej liczby zestawów SDK plików MIP. Korzystając z jednej z etykiet poufności wymienionych w poprzednim przewodniku Szybki start, używasz programu obsługi plików do ustawiania i odczytywania etykiety pliku. Klasa obsługi plików uwidacznia różne operacje ustawiania i pobierania etykiet lub ochrony obsługiwanych typów plików.

Wymagania wstępne

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

Szybki start: wyświetlanie etykiet poufności (C++). Najpierw ukończ ten przewodnik Szybki start. Tworzy ona początkowe rozwiązanie Visual Studio, które wyświetla listę etykiet poufności organizacji. Ten przewodnik Szybki start "Ustawianie i uzyskiwanie etykiety poufności" jest oparty na poprzednim przewodniku Szybki start.
Opcjonalnie: Zapoznaj się z koncepcjami obsługi plików w zestawie MIP SDK.

Implementowanie klasy obserwatora w celu monitorowania obiektu programu obsługi plików

Podobnie jak w przypadku obserwatora zaimplementowanego dla profilu pliku i silnika w przewodniku Szybki start dotyczącym inicjalizacji aplikacji, teraz zaimplementujesz klasę obserwatora dla obiektu obsługi plików.

Utwórz podstawową implementację dla obserwatora programu obsługi plików, rozszerzając klasę zestawu SDK mip::FileHandler::Observer . Aplikacja tworzy instancję obserwatora i wykorzystuje ją później do monitorowania operacji procedury obsługi plików.

Otwórz rozwiązanie programu Visual Studio, nad którym pracowałeś w poprzednim artykule "Szybki start: Lista etykiet poufności (C++)".
Dodaj nową klasę do projektu. Visual Studio generuje pliki header/.h i implementation/.cpp:
- W Eksploratorze rozwiązań ponownie kliknij prawym przyciskiem myszy węzeł projektu, wybierz polecenie Dodaj, a następnie wybierz pozycję Klasa.
- W oknie dialogowym Dodawanie klasy :
  - W polu Nazwa klasy wprowadź "filehandler_observer". Zwróć uwagę, że zarówno plik h , jak i pola pliku .cpp są wypełniane automatycznie na podstawie wprowadzonej nazwy.
  - Po zakończeniu wybierz przycisk OK.

Po wygenerowaniu przez program Visual Studio plików .h i .cpp dla tej klasy oba pliki zostaną otwarte na kartach edytora. Zaktualizuj każdy plik, aby zaimplementować nową klasę obserwatora:

Zaktualizuj "filehandler_observer.h", wybierając/usuwając wygenerowaną filehandler_observer klasę. Nie usuwaj dyrektyw preprocesora wygenerowanych w poprzednim kroku (#pragma, #include). Następnie skopiuj/wklej następujące źródło do pliku po istniejących dyrektywach preprocesora:

#include <memory>
#include "mip/file/file_engine.h"
#include "mip/file/file_handler.h"

class FileHandlerObserver final : public mip::FileHandler::Observer {
public:
   FileHandlerObserver() { }
   // Observer implementation
   void OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) override;
   void OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
   void OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) override;
   void OnCommitFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;		
};

Zaktualizuj "filehandler_observer.cpp", wybierając/usuwając implementację klasy filehandler_observer wygenerowanej. Nie usuwaj dyrektyw preprocesora wygenerowanych w poprzednim kroku (#pragma, #include). Następnie skopiuj/wklej następujące źródło do pliku po istniejących dyrektywach preprocesora:

void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
   promise->set_value(fileHandler);
}

void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
   promise->set_exception(error);
}

void FileHandlerObserver::OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<bool>>(context);
   promise->set_value(committed);
}

void FileHandlerObserver::OnCommitFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<bool>>(context);
   promise->set_exception(error);
}

Opcjonalnie użyj klawisza F6 (Kompiluj rozwiązanie), aby uruchomić kompilowanie/łącze testowe rozwiązania i potwierdzić, że kompilacja została pomyślnie skompilowana przed kontynuowaniem.

Dodaj logikę do ustawiania i pobierania etykiety poufności

Użyj obiektu aparatu plików, aby dodać logikę ustawiającą i pobierającą etykietę poufności dla pliku.

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 odpowiednich istniejących dyrektywach na początku pliku:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Pod koniec sekcji system("pause");, po return 0; i przed main(), w miejscu, w którym zakończono poprzedni przewodnik Szybki start, wstaw następujący kod:

// Set up async FileHandler for input file operations
string inputFilePath = "<input-file-path>";
string actualFilePath = "<content-identifier>";
std::shared_ptr<FileHandler> handler;
try
{
     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);
     handler = handlerFuture.get();
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid input file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}

// Set a label on input file
try
{
     string labelId = "<label-id>";
     cout << "\nApplying Label ID " << labelId << " to " << inputFilePath << endl;
     mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);
     handler->SetLabel(engine->GetLabelById(labelId), labelingOptions, mip::ProtectionSettings());
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
     system("pause");
     return 1; 
}

// Commit changes, save as a different/output file
string filePathOut = "<output-file-path>";
try
{
 	cout << "Committing changes" << endl;
     auto commitPromise = std::make_shared<std::promise<bool>>();
     auto commitFuture = commitPromise->get_future();
     handler->CommitAsync(filePathOut, commitPromise);
 	if (commitFuture.get()) {
 		cout << "\nLabel committed to file: " << filePathOut << endl;
 	}
 	else {
 		cout << "Failed to label: " + filePathOut << endl;
 		return 1;
 	}
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid commit file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}
system("pause");

// Set up async FileHandler for output file operations
actualFilePath = "<content-identifier>";
try
{
     auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
     auto handlerFuture = handlerPromise->get_future();
     engine->CreateFileHandlerAsync(
          filePathOut,
          actualFilePath,
          true,
          std::make_shared<FileHandlerObserver>(),
          handlerPromise);

     handler = handlerFuture.get();
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid output file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}

// Get the label from output file
try
{
     cout << "\nGetting the label committed to file: " << filePathOut << endl;
     auto label = handler->GetLabel();
     cout << "Name: " + label->GetLabel()->GetName() << endl;
     cout << "Id: " + label->GetLabel()->GetId() << endl;
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}
system("pause");

Pod koniec main() znajdź blok zamykania aplikacji utworzony w pierwszym przewodniku Szybki start i odkomentuj wiersz programu obsługi:

// Application shutdown. Null out profile and engine, call ReleaseAllResources();
// Application may crash at shutdown if resources aren't properly released.
profile = nullptr;
engine = nullptr;
handler = nullptr;
mipContext = nullptr;

Zastąp wartości symboli zastępczych w kodzie źródłowym w następujący sposób, używając stałych ciągów:

Zastępczy element	Wartość
<ścieżka pliku wejściowego>	Pełna ścieżka do pliku wejściowego testu, na przykład: `"c:\\Test\\Test.docx"`.
<identyfikator zawartości>	Czytelny dla człowieka identyfikator zawartości. Przykład: W przypadku pliku użyj ścieżki\nazwy pliku: `"c:\Test\Test.docx"` W przypadku wiadomości e-mail użyj tematu:sender: `"RE: Audit design:user1@contoso.com"`
<label-id>	Identyfikator etykiety poufności skopiowany z danych wyjściowych konsoli w poprzednim przewodniku Szybki start, na przykład: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<ś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\\Test_labeled.docx"`.

Kompilowanie i testowanie aplikacji

Skompiluj i przetestuj aplikację kliencą.

Użyj F6 (Kompiluj rozwiązanie) do stworzenia aplikacji klienckiej. Jeśli kompilacja nie zawiera błędów, użyj klawisza F5 (Rozpocznij debugowanie), aby uruchomić aplikację.

Jeśli projekt kompiluje się i uruchamia pomyślnie, aplikacja prosi o token dostępu za każdym razem, gdy SDK wywołuje metodę AcquireOAuth2Token(). Tak jak poprzednio w przewodniku „Szybki start: wyświetlanie etykiet poufności listy” uruchom skrypt programu PowerShell, aby za każdym razem uzyskać token dostępu przy użyciu wartości podanych dla $authority i $resourceUrl.

Run the PowerShell script to generate an access token using the following values, then copy/paste it below:

Sensitivity labels for your organization:
Non-Business : 87ba5c36-17cf-14793-bbc2-bd5b3a9f95cz
Public : 83867195-f2b8-2ac2-b0b6-6bb73cb33afz
General : f42a3342-8706-4288-bd31-ebb85995028z
Confidential : 074e457c-5848-4542-9a6f-34a182080e7z
Highly Confidential : f55c2dea-db0f-47cd-8520-a52e1590fb6z
Press any key to continue . . .

Applying Label ID 074e457c-5848-4542-9a6f-34a182080e7z to c:\Test\Test.docx
Committing changes

Label committed to file: c:\Test\Test_labeled.docx
Press any key to continue . . .

Getting the label committed to file: c:\Test\Test_labeled.docx
Name: Confidential
Id: 074e457c-5848-4542-9a6f-34a182080e7z
Press any key to continue . . .

Zweryfikuj aplikację etykiet, otwierając plik wyjściowy i wizualnie sprawdzając ustawienia ochrony informacji dokumentu.

Uwaga / Notatka

Jeśli oznaczasz dokument pakietu Office, ale nie jesteś zalogowany(-a) za pomocą konta z dzierżawy Microsoft Entra, która wydała token dostępu (a etykiety poufności są skonfigurowane), przed otwarciem dokumentu z etykietą może zostać wyświetlony monit o zalogowanie się.

Następne kroki

Przykład zestawu MIP File SDK języka C++

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2026-09-21