Microsoft Information Protection SDK: Observadores del SDK de directivas

El SDK de directivas contiene una clase de observador. Los miembros del observador son virtuales y deben reemplazarse 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::Profile::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 Observador de perfil

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

Nota:Los ejemplos siguientes solo se implementan parcialmente y no incluyen invalidaciones para los observadores relacionados.

profile_observer.h

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

class ProfileObserver final : public mip::Profile::Observer {
public:
ProfileObserver() { }
  void OnLoadSuccess(const std::shared_ptr<mip::Profile>& profile, const std::shared_ptr<void>& context) override;
  void OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
  //TODO: Implement remaining members
};

profile_observer.cpp

En la propia implementación, 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 controla la función. ProfileObserver::OnLoadSuccess esperaría recibir un mip::Profile . ProfileObserver::OnAddEngineSuccess esperaría mip::ProfileEngine .

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::Profile pasandolo.

#include "profile_observer.h"
#include <future>

//Called when Profile is successfully loaded
void ProfileObserver::OnLoadSuccess(const std::shared_ptr<mip::Profile>& profile, const std::shared_ptr<void>& context) {
  //cast context to promise
  auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::Profile>>>(context);
  //set promise value to profile
  promise->set_value(profile);
}

//Called when Profile fails to load
void ProfileObserver::OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
  auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::Profile>>>(context);
  promise->set_exception(error);
}

//TODO: Implement remaining observer members

Al realizar cualquier operación asincrónica, la implementación del observador se pasa al constructor de configuración o a la propia función asincrónica.