Démarrage rapide : Définir et obtenir une étiquette de sensibilité (C++)

Ce guide de démarrage rapide vous montre comment utiliser davantage de kits SDK de fichiers MIP. En utilisant l’une des étiquettes de confidentialité que vous avez répertoriées dans le guide de démarrage rapide précédent, vous utilisez un gestionnaire de fichiers pour définir et obtenir l’étiquette sur un fichier. La classe de gestionnaire de fichiers expose différentes opérations pour définir et obtenir des étiquettes ou une protection pour les types de fichiers pris en charge.

Prerequisites

Si ce n’est déjà fait, veillez à remplir les conditions préalables suivantes avant de continuer :

Démarrage rapide : Répertorier les étiquettes de confidentialité (C++). Suivez d’abord ce guide de démarrage rapide. Il crée une solution de démarrage Visual Studio qui répertorie les étiquettes de confidentialité d'une organisation. Ce guide de démarrage rapide « Définir et obtenir une étiquette de confidentialité » s’appuie sur le précédent.
Si vous le souhaitez , passez en revue les gestionnaires de fichiers dans les concepts du Kit de développement logiciel (SDK) MIP .

Implémenter une classe d’observateur pour surveiller l’objet gestionnaire de fichiers

Comme dans l’observateur que vous avez implémenté pour le profil de fichier et le moteur dans le guide de démarrage rapide d’initialisation de l’application, vous implémentez maintenant une classe d’observateur pour un objet de gestionnaire de fichiers.

Créez une implémentation de base pour un observateur de gestionnaires de fichiers en étendant la classe du Kit de mip::FileHandler::Observer développement logiciel (SDK). L’application instancie l’observateur et l’utilise ultérieurement pour surveiller les opérations de gestionnaire de fichiers.

Ouvrez la solution Visual Studio sur laquelle vous avez travaillé dans l’article précédent « Démarrage rapide : Répertorier les étiquettes de confidentialité (C++) ».
Ajoutez une nouvelle classe à votre projet. Visual Studio génère à la fois les fichiers d’en-tête/.h et d’implémentation/.cpp pour vous :
- Dans l’Explorateur de solutions, cliquez à nouveau avec le bouton droit sur le nœud du projet, sélectionnez Ajouter, puis sélectionnez Classe.
- Dans la boîte de dialogue Ajouter une classe :
  - Dans le champ Nom de la classe , entrez « filehandler_observer ». Notez que le fichier .h et les champs de fichier .cpp sont automatiquement renseignés en fonction du nom que vous entrez.
  - Lorsque vous avez terminé, sélectionnez OK.

Après Visual Studio génère les fichiers .h et .cpp pour la classe, les deux fichiers s’ouvrent sous les onglets de l’éditeur. Mettez à jour chaque fichier pour implémenter votre nouvelle classe d’observateur :

Mettez à jour « filehandler_observer.h », en sélectionnant/supprimant la classe générée filehandler_observer . Ne supprimez pas les directives de préprocesseur générées par l’étape précédente (#pragma, #include). Copiez/collez ensuite la source suivante dans le fichier, après toutes les directives de préprocesseur existantes :

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

Mettez à jour « filehandler_observer.cpp », en sélectionnant/supprimant l’implémentation de classe générée filehandler_observer . Ne supprimez pas les directives de préprocesseur générées par l’étape précédente (#pragma, #include). Copiez/collez ensuite la source suivante dans le fichier, après toutes les directives de préprocesseur existantes :

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

Si vous le souhaitez, utilisez F6 (Build Solution) pour exécuter une compilation/liaison de test de votre solution et vérifiez qu’elle est générée correctement avant de continuer.

Ajouter une logique pour définir et obtenir une étiquette de sensibilité

Utilisez l’objet de moteur de fichiers pour ajouter une logique permettant de définir et d’obtenir une étiquette de confidentialité sur un fichier.

Dans Explorateur de solutions, ouvrez le fichier .cpp dans votre projet qui contient l’implémentation de la main() méthode. Il a par défaut le même nom que le projet qui le contient, que vous avez spécifié lors de la création du projet.
Ajoutez les directives suivantes #include et using après les directives existantes correspondantes en haut du fichier :
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Vers la fin de l’élément main(), après system("pause"); et avant return 0;, à l’endroit où vous vous êtes arrêté dans le guide de démarrage rapide précédent, insérez le code suivant :

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

Vers la fin de main(), recherchez le bloc d’arrêt de l’application créé dans le premier guide de démarrage rapide et décommentez la ligne du gestionnaire :

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

Remplacez les valeurs fictives dans le code source comme suit, à l’aide de constantes de chaîne :

Espace réservé	Valeur
<chemin du fichier d'entrée>	Chemin complet d’un fichier d’entrée de test, par exemple : `"c:\\Test\\Test.docx"`.
<identifiant de contenu>	Identificateur lisible par l’utilisateur pour le contenu. Par exemple: Pour un fichier, utilisez path\filename : `"c:\Test\Test.docx"` Pour un e-mail, utilisez subject :sender : `"RE: Audit design:user1@contoso.com"`
<label-id>	ID d’étiquette de confidentialité, copié à partir de la sortie de la console dans le démarrage rapide précédent, par exemple : `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<output-file-path>	Chemin complet du fichier de sortie, qui est une copie étiquetée du fichier d’entrée, par exemple : `"c:\\Test\\Test_labeled.docx"`.

Concevoir et tester l’application

Générez et testez votre application cliente.

Utilisez F6 (Build Solution) pour générer votre application cliente. Si la build n’a aucune erreur, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

Si votre projet génère et s’exécute correctement, l’application invite à entrer un jeton d’accès chaque fois que le SDK appelle votre AcquireOAuth2Token() méthode. Comme vous l’avez fait précédemment dans le guide de démarrage rapide « Répertorier les étiquettes de confidentialité », exécutez votre script PowerShell pour obtenir le jeton à chaque fois à l’aide des valeurs fournies pour $authority et $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 . . .

Vérifiez l’application d’étiquette en ouvrant le fichier de sortie et en inspectant visuellement les paramètres de protection des informations du document.

Note

Si vous étiquetez un document Office, mais que vous n’êtes pas connecté avec un compte du locataire Microsoft Entra qui a émis le jeton d’accès (et que les étiquettes de confidentialité sont configurées), vous pourriez être invité à vous connecter avant de pouvoir ouvrir le document étiqueté.

Étapes suivantes

Exemple C++ du Kit de développement logiciel (SDK) de fichier MIP

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-09-25