Microsoft Information Protection SDK: Observadores del SDK de protección

El SDK de protección contiene tres clases de observador. Los miembros del observador son virtuales y se pueden invalidar para controlar las devolución de llamada para las operaciones asincrónicas.

Cuando se completa una operación asincrónica, se llama a la función OnXxx() miembro correspondiente al resultado. Algunos ejemplos OnLoadSuccess() son , y para OnLoadFailure()OnAddEngineSuccess()mip::ProtectionProfile::Observer .

En los ejemplos siguientes se muestra el patrón de promesa/futuro, que también se usa en los ejemplos del SDK y se puede ampliar para implementar el comportamiento de devolución de llamada deseado.

Implementación de ProtectionProfile Observer

En el siguiente ejemplo, hemos creado una clase, ProtectionProfileObserverImpl que se deriva de mip::ProtectionProfile::Observer . Las funciones de miembro se han anulado para usar el patrón de promesa/futuro usado en las muestras.

Declaración de clase ProtectionProfileObserverImpl

En el encabezado, definimos ProtectionProfileObserverImpl , derivando de y, a continuación, mip::ProtectionProfile::Observer reemplazamos cada una de las funciones miembro.

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

Implementación de ProtectionProfileObserverImpl

En la propia implementación, simplemente definimos una acción para cada función miembro del observador.

Cada miembro acepta dos parámetros. El primero es un puntero compartido a la clase que estamos administrando en la función. ProtectionObserver::OnLoadSuccess esperaría recibir un mip::ProtectionProtection , ProtectionObserver::OnAddEngineSuccess esperaría mip::ProtectionEngine .

El segundo es un puntero compartido al contexto. En nuestra implementación, el contexto es una referencia a una std::promise , que se pasa como shared_ptr<void> . La primera línea de la función la convierte en y, a std::promise continuación, se almacena en un objeto llamado promise .

Por último, el futuro está listo estableciendo el promise->set_value() objeto y mip::ProtectionProtection pasandolo.

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

Cuando creamos instancias de cualquier clase de SDK o usamos una función que realiza operaciones asincrónicas, pasaremos la implementación del observador al constructor de configuración o a la función asincrónica en sí. Al crear una instancia del mip::ProtectionProfile::Settings objeto, el constructor toma mip::ProtectionProfile::Observer como uno de los parámetros. En el ejemplo siguiente se muestra nuestro ProtectionProfileObserverImpl personalizado , usado en un mip::ProtectionProfile::Settings constructor.

Implementación de ProtectionHandler Observer

De forma similar al observador de protección, implementa una clase para controlar las mip::ProtectionHandlermip::ProtectionHandler::Observer notificaciones asincrónicas de eventos durante las operaciones de protección. La implementación es similar a la que se ha detallado anteriormente. ProtectionHandlerObserverImpl se define parcialmente a continuación. La implementación completa se puede encontrar en nuestro repositorio GitHub ejemplo.

Declaración de clase ProtectionHandlerObserverImpl

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

Implementación parcial protectionHandlerObserverImpl

Este ejemplo es solo las dos primeras funciones, pero las funciones restantes usan un patrón similar a estas y a 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);
};