Kit de développement logiciel (SDK) Microsoft Information Protection - Observateurs du kit de développement logiciel (SDK) Protection

Le kit de développement logiciel (SDK) Protection contient trois classes d’observateur. Les membres observateurs sont virtuels et peuvent être remplacés pour gérer les rappels pour les opérations asynchrones.

• Profil de protection : mip::ProtectionProfile::Observer
• Moteur de protection : mip::ProtectionEngine::Observer
• Gestionnaire de protection : mip::ProtectionHandler::Observer

Quand une opération asynchrone se termine, la fonction du membre OnXxx() correspondant au résultat est appelée. Des exemples sont OnLoadSuccess(), OnLoadFailure() et OnAddEngineSuccess() pour mip::ProtectionProfile::Observer.

Les exemples ci-dessous illustrent le modèle de promesse/avenir, qui est également utilisé par les exemples du kit de développement logiciel (SDK) et peut être étendu pour implémenter le comportement de rappel souhaité.

Implémentation de l’observateur ProtectionProfile

Dans l’exemple suivant, nous avons créé une classe, ProtectionProfileObserverImpl, dérivée de mip::ProtectionProfile::Observer. Les fonctions membres ont été remplacées pour utiliser le modèle promesse/avenir utilisé dans les exemples.

Déclaration de la classe ProtectionProfileObserverImpl

Dans l’en-tête, nous définissons ProtectionProfileObserverImpl, dérivant de mip::ProtectionProfile::Observer, puis remplaçons 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 OnAddEngineError(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implémentation de ProtectionProfileObserverImpl

Dans l’implémentation elle-même, nous définissons simplement une action à entreprendre pour chaque fonction membre de l’observateur.

Chaque membre accepte deux paramètres. Le premier est un pointeur partagé vers la classe que nous gérons dans la fonction. ProtectionObserver::OnLoadSuccess s’attendrait à recevoir un mip::ProtectionProtection, ProtectionObserver::OnAddEngineSuccess s’attendrait à mip::ProtectionEngine.

Le deuxième est un pointeur partagé vers le contexte. Dans notre 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 le convertit en std::promise, puis est stockée dans un objet appelé promise.

Enfin, l’avenir est prêt en définissant la fonction promise->set_value() et en la passant dans l’objet mip::ProtectionProtection.

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

Lorsque nous instancions une classe SDK ou utilisons une fonction qui effectue des opérations asynchrones, nous passons l’implémentation de l’observateur au constructeur des paramètres ou à la fonction asynchrone elle-même. Lors de l’instanciation de l’objet mip::ProtectionProfile::Settings, le constructeur prend en entrée mip::ProtectionProfile::Observer comme l’un des paramètres. L’exemple ci-dessous montre notre 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 à celle décrite ci-dessus. ProtectionHandlerObserverImpl est partiellement défini ci-dessous. L’implémentation complète est disponible dans notre référentiel d’exemples GitHub.

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

Implémentation partielle de ProtectionHandlerObserverImpl

Cet exemple ne montre que les deux premières fonctions, mais les autres fonctions utilisent un modèle similaire à ceux-ci 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::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);
};