Schnellstart: Festlegen und Abrufen einer Vertraulichkeitsbezeichnung (C++)

In dieser Schnellstartanleitung erfahren Sie, wie Sie mehr der MIP-Datei-SDKs verwenden. Mithilfe einer der Vertraulichkeitsbezeichnungen, die Sie in der vorherigen Schnellstartanleitung aufgelistet haben, verwenden Sie einen Dateihandler, um die Bezeichnung für eine Datei festzulegen und abzurufen. Die Dateihandlerklasse macht verschiedene Vorgänge zum Festlegen und Abrufen von Bezeichnungen oder Schutz für unterstützte Dateitypen verfügbar.

Voraussetzungen

Falls noch nicht geschehen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen, bevor Sie fortfahren:

Schnellstart: Auflisten von Vertraulichkeitsbezeichnungen (C++). Führen Sie zuerst diese Schnellstartanleitung aus. Sie erstellt eine Startlösung Visual Studio, die die Vertraulichkeitsbezeichnungen einer Organisation auflistet. Diese Schnellstartanleitung "Festlegen und Abrufen einer Vertraulichkeitsbezeichnung" baut auf dem vorherigen auf.
Optional: Überprüfen von Dateihandlern in den MIP SDK-Konzepten .

Implementieren einer Beobachterklasse zum Überwachen des File-Handlerobjekts

Wie bei dem Beobachter, den Sie im Quickstart zur Anwendungsinitialisierung für das Dateiprofil und die Engine implementiert haben, implementieren Sie nun eine Beobachterklasse für ein Dateiverwaltungsobjekt.

Erstellen Sie eine grundlegende Implementierung für einen Dateihandlerbeobachter, indem Sie die SDK-Klasse mip::FileHandler::Observer erweitern. Die Anwendung instanziiert den Beobachter und verwendet ihn später, um Dateihandlervorgänge zu überwachen.

Öffnen Sie die Visual Studio-Lösung, an der Sie im vorherigen Artikel "Schnellstart: Auflisten von Vertraulichkeitsbezeichnungen (C++)" gearbeitet haben.
Fügen Sie Ihrem Projekt eine neue Klasse hinzu. Visual Studio generiert sowohl die Header/.h- als auch die Implementierungs-/.cpp dateien für Sie:
- Klicken Sie im Projektmappen-Explorer erneut mit der rechten Maustaste auf den Projektknoten, wählen Sie "Hinzufügen" und dann "Klasse" aus.
- Im Dialogfeld "Klasse hinzufügen ":
  - Geben Sie im Feld "Klassenname " "filehandler_observer" ein. Beachten Sie, dass sowohl die H-Datei als auch .cpp Dateifelder basierend auf dem eingegebenen Namen automatisch ausgefüllt werden.
  - Wenn Sie fertig sind, wählen Sie OK aus.

Nachdem Visual Studio die Dateien .h und .cpp für die Klasse generiert hat, werden beide Dateien in Editortabs geöffnet. Aktualisieren Sie jede Datei, um Ihre neue Beobachterklasse zu implementieren:

Aktualisieren Sie "filehandler_observer.h", indem Sie die generierte filehandler_observer Klasse auswählen/löschen. Entfernen Sie die vom vorherigen Schritt generierten Präprozessordirektiven nicht (#pragma, #include). Kopieren/fügen Sie dann die folgende Quelle nach vorhandenen Präprozessordirektiven in die Datei ein:

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

Aktualisieren Sie "filehandler_observer.cpp", indem Sie die generierte filehandler_observer Klassenimplementierung auswählen/löschen. Entfernen Sie die vom vorherigen Schritt generierten Präprozessordirektiven nicht (#pragma, #include). Kopieren/fügen Sie dann die folgende Quelle nach vorhandenen Präprozessordirektiven in die Datei ein:

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

Verwenden Sie optional F6 (Buildlösung), um eine Testkompilierung/Verknüpfung Ihrer Lösung auszuführen und zu bestätigen, dass sie erfolgreich erstellt wurde, bevor Sie fortfahren.

Hinzufügen von Logik zum Festlegen und Abrufen einer Vertraulichkeitsbezeichnung

Fügen Sie Logik zum Festlegen und Abrufen einer Vertraulichkeitsbezeichnung für eine Datei hinzu, indem Sie das File-Engine-Objekt verwenden.

Öffnen Sie in Projektmappen-Explorer die datei .cpp in Ihrem Projekt, die die Implementierung der main() Methode enthält. Standardmäßig wird derselbe Name wie das Projekt verwendet, das es enthält, das Sie während der Projekterstellung angegeben haben.
Fügen Sie die folgenden #include und using direktiven nach den entsprechenden vorhandenen Direktiven am Anfang der Datei hinzu:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Fügen Sie gegen Ende des main()-Bodys, nach system("pause"); und vor return 0;, wo Sie im vorherigen Schnellstart aufgehört haben, den folgenden Code ein:

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

Suchen Sie am Ende von main() den Block zum Herunterfahren der Anwendung, den Sie in ersten Schnellstartanleitung erstellt haben, und heben Sie die Auskommentierung der Zeile für den Handler auf:

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

Ersetzen Sie die Platzhalterwerte im Quellcode wie folgt durch Zeichenfolgenkonstanten:

Platzhalter	Wert
<Eingabedateipfad>	Der vollständige Pfad zu einer Testeingabedatei, z. B.: `"c:\\Test\\Test.docx"`.
<Inhalts-ID>	Ein lesbarer Bezeichner für den Inhalt. Beispiel: Verwenden Sie für eine Datei "Pfad\Dateiname": `"c:\Test\Test.docx"` Verwenden Sie für eine E-Mail "subject:sender": `"RE: Audit design:user1@contoso.com"`
<Bezeichnungs-ID>	Eine Vertraulichkeitsbezeichnungs-ID, die aus der Konsolenausgabe im vorherigen Schnellstart kopiert wird, z. B. `"f42a3342-8706-4288-bd31-ebb85995028z"`
<Ausgabedateipfad>	Der vollständige Pfad zur Ausgabedatei, bei der es sich um eine beschriftete Kopie der Eingabedatei handelt, z. B.: `"c:\\Test\\Test_labeled.docx"`.

Erstellen und Testen der Anwendung

Erstellen und testen Sie Ihre Clientanwendung.

Verwenden Sie F6 (Lösung erstellen), um Ihre Clientanwendung zu erstellen. Wenn der Build keine Fehler aufweist, verwenden Sie F5 (Debuggen starten), um Ihre Anwendung auszuführen.

Wenn Ihr Projekt erfolgreich erstellt und ausgeführt wird, fordert die Anwendung jedes Mal, wenn das SDK Ihre AcquireOAuth2Token() Methode aufruft, ein Zugriffstoken ein. Führen Sie wie zuvor im Schnellstart „Vertraulichkeitsbezeichnungen auflisten“ Ihr PowerShell-Skript aus, um jeweils das Token mit den für $resourceUrl und $authority angegebenen Werten abzurufen.

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

Überprüfen Sie die Bezeichnungsanwendung, indem Sie die Ausgabedatei öffnen und die Informationsschutzeinstellungen des Dokuments visuell prüfen.

Hinweis

Wenn Sie ein Office-Dokument mit einer Vertraulichkeitsbezeichnung versehen, aber nicht mit einem Konto des Microsoft Entra-Mandanten angemeldet sind, der das Zugriffstoken ausgestellt hat (und Vertraulichkeitsbezeichnungen konfiguriert sind), werden Sie möglicherweise aufgefordert, sich anzumelden, bevor Sie das mit einer Vertraulichkeitsbezeichnung versehene Dokument öffnen können.

Nächste Schritte

MIP File SDK C++-Beispiel

Feedback

War diese Seite hilfreich?

Zuletzt aktualisiert um 2026-09-21