Observateurs du SDK de stratégie de Microsoft Information Protection

Le Kit de développement logiciel (SDK) policy contient une classe d’observateur. Les membres observateurs sont virtuels et doivent être remplacés pour gérer les rappels pour les opérations asynchrones.

• mip::PolicyProfile::Observer

Lorsqu’une opération asynchrone se termine, la OnXxx() fonction membre correspondant au résultat est appelée. Voici des exemples : OnLoadSuccess(), OnLoadFailure()et OnAddEngineSuccess() pour mip::Profile::Observer.

Les exemples ci-dessous illustrent le modèle de promesse/futur, 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 de profil

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

Remarque : Les exemples ci-dessous ne sont implémentés que partiellement et n’incluent pas de remplacements pour les mip::ProfileEngine observateurs associés.

profile_observer.h

Dans l’en-tête, nous définissons ProfileObserver, dérivant de mip::Profile::Observer, puis substituons chacune des fonctions membres.

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

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

Chaque membre accepte deux paramètres. Le premier est un pointeur partagé vers la classe gérée par la fonction. ProfileObserver::OnLoadSuccess s’attendrait à recevoir un mip::Profile. ProfileObserver::OnAddEngineSuccess s'attendrait à mip::ProfileEngine.

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 convertit this en std::promise, puis le stocke dans un objet appelé promise.

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

#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

Lors de l’exécution d’une opération asynchrone, l’implémentation de l’observateur est passée au constructeur de paramètres ou à la fonction asynchrone elle-même.