Snabbstart: Ange och hämta en känslighetsetikett (C++)

Den här snabbstarten visar hur du använder fler MIP-fil-SDK:er. Genom att använda någon av de känslighetsetiketter som du angav i föregående snabbstart använder du en filhanterare för att ange och hämta etiketten på en fil. Filhanterarklassen exponerar olika åtgärder för att ange och hämta etiketter, eller skydd, för filtyper som stöds.

Förutsättningar

Om du inte redan har gjort det måste du slutföra följande krav innan du fortsätter:

Snabbstart: Lista känslighetsetiketter (C++). Slutför den här snabbstarten först. Den skapar en startlösning Visual Studio som visar en organisations känslighetsetiketter. Snabbstarten "Ange och hämta en känslighetsetikett" bygger på den föregående.
Alternativt: Översikt av filhanterare och begreppen i MIP SDK.

Implementera en observatörsklass för att övervaka filhanterarobjektet

Precis som i observatören som du implementerade för filprofilen och motorn i snabbstarten för programinitiering implementerar du nu en observatörsklass för ett filhanterarobjekt.

Skapa en grundläggande implementering för en filhanterarobservatör genom att utöka SDK:ts mip::FileHandler::Observer klass. Applikationen skapar en instans av observatören och använder den senare för att övervaka filhanterarens operationer.

Öppna Visual Studio-lösningen som du arbetade med i föregående artikel "Snabbstart: Lista känslighetsetiketter (C++)."
Lägg till en ny klass i projektet. Visual Studio genererar både huvud-/.h- och implementerings-/.cpp-filer åt dig:
- I Prieskumník riešení högerklickar du på projektnoden igen, väljer Lägg till och väljer sedan Klass.
- På dialogrutan Lägg till klass:
  - I fältet Klassnamn anger du "filehandler_observer". Observera att både .h-filen och .cpp filfält fylls i automatiskt, baserat på det namn du anger.
  - När du är klar väljer du OK.

När Visual Studio genererar .h- och .cpp-filerna för klassen öppnas båda filerna på redigeringsflikarna. Uppdatera varje fil för att implementera din nya observatörsklass:

Uppdatera "filehandler_observer.h" genom att välja/ta bort den genererade filehandler_observer klassen. Ta inte bort de förprocessordirektiv som genererades av föregående steg (#pragma, #include). Kopiera/klistra sedan in följande källa i filen efter befintliga förprocessordirektiv:

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

Uppdatera "filehandler_observer.cpp" genom att välja/ta bort den genererade filehandler_observer klassimplementeringen. Ta inte bort de förprocessordirektiv som genererades av föregående steg (#pragma, #include). Kopiera/klistra sedan in följande källa i filen efter befintliga förprocessordirektiv:

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

Du kan också använda F6 (Build Solution) för att köra en testkompilering/länk för din lösning och bekräfta att den har skapats innan du fortsätter.

Lägga till logik för att ange och hämta en känslighetsetikett

Använd objektet File engine för att lägga till logik som ställer in och hämtar en känslighetsetikett på en fil.

I Prieskumník riešení öppnar du filen .cpp i projektet som innehåller implementeringen av main() metoden. Det är som standard samma namn som det projekt som innehåller det, som du angav när projektet skapades.
Lägg till följande #include och using direktiv efter motsvarande befintliga direktiv överst i filen:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Mot slutet av elementet main(), efter system("pause"); och före return 0;, där du slutade i den föregående snabbstartsguiden, infoga följande 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");

Mot slutet av main() letar du reda på blocket för programavstängning som skapades i den första snabbstartsguiden och avkommenterar hanterarraden:

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

Ersätt platshållarvärdena i källkoden på följande sätt med hjälp av strängkonstanter:

Platshållare	Värde
<inmatningsfil-sökväg>	Den fullständiga sökvägen till en testindatafil, till exempel: `"c:\\Test\\Test.docx"`.
<innehållsidentifierare>	En människoläsbar identifierare för innehållet. Till exempel: För en fil använder du path\filename: `"c:\Test\Test.docx"` För ett e-postmeddelande använder du subject:sender: `"RE: Audit design:user1@contoso.com"`
<etikett-ID>	Ett känslighetsetikett-ID som kopierades från konsolens utdata i föregående snabbstart, till exempel: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<utdatafilssökväg>	Den fullständiga sökvägen till utdatafilen, som är en märkt kopia av indatafilen, till exempel: `"c:\\Test\\Test_labeled.docx"`.

Skapa och testa programmet

Skapa och testa klientprogrammet.

Använd F6 (Build Solution) för att skapa klientprogrammet. Om versionen inte har några fel använder du F5 (Starta felsökning) för att köra programmet.

Om projektet byggs och körs utan problem uppmanar applikationen dig att ange en åtkomsttoken varje gång SDK:t anropar din AcquireOAuth2Token()-metod. Precis som du gjorde tidigare i snabbstarten "Lista känslighetsetiketter" kör du PowerShell-skriptet för att hämta token varje gång med de värden som anges för $authority och $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 . . .

Verifiera etikettprogrammet genom att öppna utdatafilen och visuellt granska dokumentets inställningar för informationsskydd.

Anmärkning

Om du etiketterar ett Office-dokument men inte är inloggad med hjälp av ett konto från den Microsoft Entra klientorganisation som utfärdade åtkomsttoken (och känslighetsetiketter har konfigurerats) kan du uppmanas att logga in innan du kan öppna det märkta dokumentet.

Nästa steg

MIP File SDK C++-exempel

Feedback

Var den här sidan till hjälp?

Uppdaterades senast 2026-09-21