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

Article
01/30/2024

Le kit de développement logiciel (SDK) File contient deux classes d’observateur. Les membres observateurs sont virtuels et peuvent être remplacés pour gérer les rappels d’événements.

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::FileProfile::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 du profil de fichier

Dans l’exemple suivant, nous avons créé une classe, ProfileObserver, dérivée de mip::FileProfile::Observer. Les fonctions membres ont été remplacées pour utiliser le modèle avenir/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 observateurs associés au mip::FileEngine.

profile_observer.h

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

class ProfileObserver final : public mip::FileProfile::Observer {
public:
ProfileObserver() { }
  void OnLoadSuccess(const std::shared_ptr<mip::FileProfile>& profile, const std::shared_ptr<void>& context) override;
  void OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
  //TODO: Implement mip::FileEngine related observers.
};

profile_observer.cpp

Dans l’implémentation elle-même, nous définissons 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. ProfileObserver::OnLoadSuccess s’attendrait à recevoir un mip::FileProfile. ProfileObserver::OnAddEngineSuccess s’attendrait à mip::FileEngine.

Le deuxième est un pointeur partagé vers le contexte. Dans notre implémentation, le contexte est une référence à une std::promise, passée par référence en tant que std::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::FileProfile.

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

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

//Called when FileProfile 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::FileProfile>>>(context);
  promise->set_exception(error);
}

//TODO: Implement mip::FileEngine related observers.

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::FileProfile::Settings, le constructeur prend en entrée mip::FileProfile::Observer comme l’un des paramètres. L’exemple ci-dessous montre notre ProfileObserver utilisé dans un constructeur mip::FileProfile::Settings.

Implémentation de l’observateur FileHandler

Similaire à l’observateur de profil, le mip::FileHandler implémente une classe mip::FileHandler::Observers pour gérer les notifications d’événements asynchrones pendant les opérations de fichier. L’implémentation est similaire à celle décrite ci-dessus. FileHandlerObserver est partiellement défini ci-dessous.

file_handler_observer.h

#include "mip/file/file_handler.h"

class FileHandlerObserver final : public mip::FileHandler::Observer {
public:
  void OnCreateFileHandlerSuccess(
      const std::shared_ptr<mip::FileHandler>& fileHandler,
      const std::shared_ptr<void>& context) override;

  void OnCreateFileHandlerFailure(
      const std::exception_ptr& error,
      const std::shared_ptr<void>& context) override;

  //TODO: override remaining member functions inherited from mip::FileHandler::Observer
};

file_handler_observer.cpp

Cet exemple ne montre que les deux premières fonctions, mais les autres fonctions utilisent un modèle similaire à ceux-ci et à ProfileObserver.

#include "file_handler_observer.h"

void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
    promise->set_value(fileHandler);
}

void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
    promise->set_exception(error);
}

//TODO: override remaining member functions inherited from mip::FileHandler::Observer

Partager via