Microsoft Information Protection SDK - Osservatori dell'API ProtezioneMicrosoft Information Protection SDK - Protection API Observers

L'API Protezione contiene tre classi osservatore.The Protection API contains three observer classes. I membri della classe osservatore sono virtuali e possono essere sottoposti a override per gestire i callback per le operazioni asincrone.Observer members are virtual and can be overridden to handle callbacks for asynchronous operations.

Al termine di un'operazione asincrona, viene chiamata la funzione membro OnXxx() corrispondente al risultato.When an asynchronous operation completes, the OnXxx() member function corresponding to the result is called. Sono esempi OnLoadSuccess(), OnLoadFailure() e OnAddEngineSuccess() per mip::ProtectionProfile::Observer.Examples are OnLoadSuccess(), OnLoadFailure(), and OnAddEngineSuccess() for mip::ProtectionProfile::Observer.

Gli esempi seguenti illustrano il modello promise/future, usato anche dagli esempi dell'SDK, e possono essere estesi per implementare il comportamento di callback desiderato.The examples below demonstrate the promise/future pattern, which is also used by the SDK samples, and can be extended to implement the desired callback behavior.

Implementazione dell'osservatore ProtectionProfileProtectionProfile Observer Implementation

Nell'esempio seguente è stata creata una classe ProtectionProfileObserverImpl derivata da mip::ProtectionProfile::Observer.In the following example, we've created a class, ProtectionProfileObserverImpl that is derived from mip::ProtectionProfile::Observer. Le funzioni membro sono state sottoposte a override per sfruttare il modello promise/future usato in tutti gli esempi.The member functions have been overridden to use the promise/future pattern used throughout the samples.

Dichiarazione della classe ProtectionProfileObserverImplProtectionProfileObserverImpl Class Declaration

Nell'intestazione si definisce ProtectionProfileObserverImpl, che deriva da mip::ProtectionProfile::Observer, quindi si esegue l'override di tutte le funzioni membro.In the header, we define ProtectionProfileObserverImpl, deriving from mip::ProtectionProfile::Observer, then override each of the member functions.

//ProtectionProfileObserverImpl.h
class ProtectionProfileObserverImpl final : public mip::ProtectionProfile::Observer {
public:
  ProtectionProfileObserverImpl() { }
  void OnLoadSuccess(const shared_ptr<mip::ProtectionProfile>& profile, const shared_ptr<void>& context) override;
  void OnLoadFailure(const exception_ptr& error, const shared_ptr<void>& context) override;
  void OnAddEngineSuccess(const shared_ptr<mip::ProtectionEngine>& engine, const shared_ptr<void>& context) override;
  void OnAddEngineError(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implementazione di ProtectionProfileObserverImplProtectionProfileObserverImpl Implementation

Nell'implementazione stessa si definisce semplicemente un'azione da eseguire per ogni funzione membro dell'osservatore.In the implementation itself, we simply define an action to take for each observer member function.

Ogni membro accetta due parametri.Each member accepts two parameters. Il primo è un puntatore condiviso alla classe gestita nella funzione.The first is a shared pointer to the class we're handling in the function. ProtectionObserver::OnLoadSuccess si aspetta di ricevere un mip::ProtectionProtection, ProtectionObserver::OnAddEngineSuccess si aspetta mip::ProtectionEngine.ProtectionObserver::OnLoadSuccess would expect to receive a mip::ProtectionProtection, ProtectionObserver::OnAddEngineSuccess would expect mip::ProtectionEngine.

Il secondo è un puntatore condiviso al contesto.The second is a shared pointer to the context. In questa implementazione il contesto è un riferimento a std::promise, passato come shared_ptr<void>.In our implementation the context is a reference to a std::promise, passed in as shared_ptr<void>. La prima riga della funzione esegue il cast su std::promise, che viene poi archiviato in un oggetto denominato promise.The first line of the function casts this to std::promise, then stored in an object called promise.

Infine, l'elemento future viene preparato impostando promise->set_value() e passando l'oggetto mip::ProtectionProtection.Finally, the future is made ready by setting the promise->set_value() and passing in the mip::ProtectionProtection object.

//protection_observers.cpp

void ProtectionProfileObserverImpl::OnLoadSuccess(
  const shared_ptr<mip::ProtectionProfile>& profile,
  const shared_ptr<void>& context) {
  auto loadPromise = static_cast<promise<shared_ptr<mip::ProtectionProfile>>*>(context.get());
  loadPromise->set_value(profile);
};

void ProtectionProfileObserverImpl::OnLoadFailure(const exception_ptr& error, const shared_ptr<void>& context) {
  auto loadPromise = static_cast<promise<shared_ptr<mip::ProtectionProfile>>*>(context.get());
  loadPromise->set_exception(error);
};

void ProtectionProfileObserverImpl::OnAddEngineSuccess(
  const shared_ptr<mip::ProtectionEngine>& engine,
  const shared_ptr<void>& context) {
  auto addEnginePromise = static_cast<promise<shared_ptr<mip::ProtectionEngine>>*>(context.get());
  addEnginePromise->set_value(engine);
};

void ProtectionProfileObserverImpl::OnAddEngineError(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto addEnginePromise = static_cast<promise<shared_ptr<mip::ProtectionEngine>>*>(context.get());
  addEnginePromise->set_exception(error);
};

Quando si crea un'istanza di qualsiasi classe dell'SDK o si usa una funzione che esegue operazioni asincrone, l'implementazione dell'osservatore verrà passata al costruttore delle impostazioni o alla funzione asincrona stessa.When we instantiate any SDK class or use a function that performs asynchronous operations, we will pass the observer implementation to the settings constructor or async function itself. Quando si creano istanze dell'oggetto mip::ProtectionProfile::Settings, il costruttore accetta mip::ProtectionProfile::Observer come uno dei parametri.When instantiating the mip::ProtectionProfile::Settings object, the constructor takes in mip::ProtectionProfile::Observer as one of the parameters. L'esempio seguente mostra l'implementazione personalizzata ProtectionProfileObserverImpl, usata in un costruttore mip::ProtectionProfile::Settings.The example below shows our custom ProtectionProfileObserverImpl, used in a mip::ProtectionProfile::Settings constructor.

Implementazione dell'osservatore ProtectionHandlerProtectionHandler Observer Implementation

In modo analogo all'osservatore di protezione, mip::ProtectionHandler implementa una classe mip::ProtectionHandler::Observer per la gestione delle notifiche degli eventi asincroni durante le operazioni di protezione.Similar to the Protection observer, mip::ProtectionHandler implements a mip::ProtectionHandler::Observer class for handling asynchronous event notifications during protection operations. L'implementazione è simile a quella descritta in dettaglio in precedenza.The implementation is similar to that detailed above. L'implementazione ProtectionHandlerObserverImpl è definita parzialmente di seguito.ProtectionHandlerObserverImpl is partially defined below. L'implementazione completa è disponibile nel repository degli esempi su GitHub.The full implementation can be found in our GitHub sample repo.

Dichiarazione della classe ProtectionHandlerObserverImplProtectionHandlerObserverImpl Class Declaration

//protection_observers.h

class ProtectionHandlerObserverImpl final : public mip::ProtectionHandler::Observer {
public:
  ProtectionHandlerObserverImpl() { }
  void OnCreateProtectionHandlerSuccess(const shared_ptr<mip::ProtectionHandler>& protectionHandler, const shared_ptr<void>& context) override;
  void OnCreateProtectionHandlerError(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implementazione parziale di ProtectionHandlerObserverImplProtectionHandlerObserverImpl Partial Implementation

Questo esempio riguarda solo le prime due funzioni, ma le funzioni rimanenti usano un modello simile per queste implementazioni e per ProtectionObserver.This sample is just the first two functions, but the remaining functions use a similar pattern to these and to ProtectionObserver.

//protection_observers.cpp

void ProtectionHandlerObserverImpl::OnCreateProtectionHandlerSuccess(
  const shared_ptr<mip::ProtectionHandler>& protectionHandler,
  const shared_ptr<void>& context) {
  auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
  createProtectionHandlerPromise->set_value(protectionHandler);
};

void ProtectionHandlerObserverImpl::OnCreateProtectionHandlerError(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
  createProtectionHandlerPromise->set_exception(error);
};