SDK Microsoft Information Protection - observateurs du SDK de protection

Le kit de développement logiciel (SDK) Protection contient trois classes d’observateur. Vous pouvez remplacer les membres d’observateurs virtuels pour gérer les rappels pour les opérations asynchrones.

Lorsqu’une opération asynchrone se termine, le SDK appelle la OnXxx() fonction membre qui correspond au résultat. Des exemples sont OnLoadSuccess(), OnLoadFailure() et OnAddEngineSuccess() pour mip::ProtectionProfile::Observer.

Les exemples suivants illustrent le modèle promesse/futur. Les exemples du Kit de développement logiciel (SDK) utilisent également ce modèle et vous pouvez l’étendre pour implémenter le comportement de rappel souhaité.

Implémentation de l’observateur ProtectionProfile

L’exemple suivant crée une classe, ProtectionProfileObserverImplqui dérive de mip::ProtectionProfile::Observer. Les fonctions membres remplacent la classe de base pour utiliser le modèle de promesse/futur utilisé dans les exemples.

Déclaration de classe ProtectionProfileObserverImpl

Le fichier d’en-tête définit ProtectionProfileObserverImpl, le fait dériver de mip::ProtectionProfile::Observer, puis redéfinit chacune des fonctions membres.

//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 OnAddEngineFailure(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implémentation de ProtectionProfileObserverImpl

L’implémentation définit une action à entreprendre pour chaque fonction membre d’observateur.

Chaque membre accepte deux paramètres. Le premier est un pointeur partagé vers la classe gérée par la fonction. ProtectionObserver::OnLoadSuccess s’attend à recevoir un mip::ProtectionProfile. ProtectionObserver::OnAddEngineSuccess attend mip::ProtectionEngine.

Le deuxième est un pointeur partagé vers le contexte. Dans cette implémentation, le contexte est une référence à un std::promise, passé en tant que shared_ptr<void>. La première ligne de la fonction convertit cette valeur std::promiseen , puis la stocke dans un objet appelé promise.

Enfin, le code prépare l’avenir en définissant promise->set_value() et en transmettant l’objet mip::ProtectionProfile .

//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::OnAddEngineFailure(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto addEnginePromise = static_cast<promise<shared_ptr<mip::ProtectionEngine>>*>(context.get());
  addEnginePromise->set_exception(error);
};

Lorsque vous instanciez une classe sdk ou utilisez une fonction qui effectue des opérations asynchrones, transmettez l’implémentation de l’observateur au constructeur de paramètres ou à la fonction asynchrone elle-même. Lorsque vous instanciez l’objet mip::ProtectionProfile::Settings , le constructeur accepte mip::ProtectionProfile::Observer l’un des paramètres. L’exemple suivant montre l’élément personnalisé ProtectionProfileObserverImpl, utilisé dans un constructeur mip::ProtectionProfile::Settings.

Implémentation de l’observateur ProtectionHandler

Comme pour l’observateur Protection, mip::ProtectionHandler implémente une classe mip::ProtectionHandler::Observer pour gérer les notifications d’événement asynchrone pendant les opérations de protection. L’implémentation est similaire à l’implémentation précédente. L’exemple suivant définit ProtectionHandlerObserverImplpartiellement . L’implémentation complète se trouve dans l’exemple de référentiel GitHub.

Déclaration de classe 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 OnCreateProtectionHandlerFailure(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implémentation partielle de ProtectionHandlerObserverImpl

Cet exemple inclut uniquement les deux premières fonctions, mais les fonctions restantes utilisent un modèle similaire à ces fonctions et à 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::OnCreateProtectionHandlerFailure(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
  createProtectionHandlerPromise->set_exception(error);
};

Étapes suivantes

  • Last updated on