Microsoft Information Protection SDK - Osservatori di Policy SDK

Policy SDK contiene una classe observer. I membri observer sono virtuali e devono essere sottoposti a override per gestire i callback per le operazioni asincrone.

• mip::PolicyProfile::Observer

Al termine di un'operazione asincrona, viene chiamata la OnXxx() funzione membro corrispondente al risultato. Gli esempi sono OnLoadSuccess(), OnLoadFailure()e OnAddEngineSuccess() per mip::Profile::Observer.

Gli esempi seguenti illustrano il modello promise/future, che viene usato anche dagli esempi dell'SDK e possono essere estesi per implementare il comportamento di callback desiderato.

Implementazione di Profile Observer

Nell'esempio seguente è stata creata una classe derivata ProfileObserver da mip::Profile::Observer. Le funzioni membro sono state ridefinite per utilizzare il pattern future/promise adottato in tutti gli esempi.

Nota: gli esempi seguenti sono implementati solo parzialmente e non includono sostituzioni per gli mip::ProfileEngine osservatori correlati.

profile_observer.h

Nell'intestazione si definisce ProfileObserver, derivando da mip::Profile::Observer, quindi si esegue l'override di ognuna delle funzioni membro.

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

Nell'implementazione stessa viene definita un'azione da eseguire per ogni funzione membro osservatore.

Ogni membro accetta due parametri. Il primo è un puntatore condiviso alla classe gestita dalla funzione . ProfileObserver::OnLoadSuccess si aspetterebbe di ricevere un mip::Profile. ProfileObserver::OnAddEngineSuccess si aspetterebbe mip::ProfileEngine.

Il secondo è un puntatore condiviso al contesto. Nell'implementazione, il contesto è un riferimento a un std::promise, passato come shared_ptr<void>. La prima riga della funzione esegue il cast di questo oggetto in std::promise, quindi archiviato in un oggetto denominato promise.

Infine, il futuro è pronto impostando promise->set_value() e passando l'oggetto 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

Quando si esegue un'operazione asincrona, l'implementazione dell'osservatore viene passata al costruttore delle impostazioni o alla funzione asincrona stessa.