Microsoft Information Protection SDK - Schutz-SDK-Beobachter

Artikel
01/30/2024

Das Protection SDK enthält drei Beobachterklassen. Beobachter-Member sind virtuell und können überschrieben werden, um Rückrufe für asynchrone Vorgänge zu verarbeiten.

Wenn ein asynchroner Vorgang abgeschlossen wird, wird die OnXxx()-Memberfunktion, die dem Ergebnis entspricht, genannt. Beispiele sind OnLoadSuccess(), OnLoadFailure(), und OnAddEngineSuccess() für mip::ProtectionProfile::Observer.

Die folgenden Beispiele veranschaulichen das zugesagte/zukünftige Muster, das auch von den SDK-Beispielen verwendet wird, und kann erweitert werden, um das gewünschte Rückrufverhalten zu implementieren.

ProtectionProfile Beobachter-Implementierung

Im folgenden Beispiel haben wir eine Klasse erstellt, ProtectionProfileObserverImpl die von mip::ProtectionProfile::Observer abgeleitet ist. Die Memberfunktionen wurden überschrieben, um das in den Beispielen verwendete Zusage-/zukünftige Muster zu verwenden.

ProtectionProfileObserverImpl-Klassendeklaration

In der Kopfzeile definieren wir ProtectionProfileObserverImpl, abgeleitet von mip::ProtectionProfile::Observer, und überschreiben dann jede der Memberfunktionen.

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

ProtectionProfileObserverImpl-Implementierung

In der Implementierung selbst definieren wir einfach eine Aktion, die für jede Beobachter-Memberfunktion zu ergreifen ist.

Jedes Member akzeptiert zwei Parameter. Der erste ist ein gemeinsamer Zeiger auf die Klasse, die wir in der Funktion behandeln. ProtectionObserver::OnLoadSuccess würde erwarten, ein mip::ProtectionProtection zu erhalten, ProtectionObserver::OnAddEngineSuccess würde mip::ProtectionEngine erwarten.

Die zweite ist ein freigegebener Zeiger auf den Kontext. In unserer Implementierung ist der Kontext ein Verweis auf ein std::promise, übergeben als shared_ptr<void>. Die erste Zeile der Funktion überträgt dies nach std::promise und wird dann in einem Objekt gespeichert, das promise heißt.

Letztendlich wird die Zukunft vorbereitet, indem das promise->set_value()-Objekt festgelegt und mip::ProtectionProtection übergeben wird.

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

Wenn wir eine SDK-Klasse instanziieren oder eine Funktion verwenden, die asynchrone Vorgänge ausführt, übergeben wir die Beobachterimplementierung an den Einstellungskonstruktor oder die asynchrone Funktion selbst. Beim Instanziieren des mip::ProtectionProfile::Settings-Objekts verwendet der Konstruktor mip::ProtectionProfile::Observer als einen der Parameter. Das folgende Beispiel zeigt unser benutzerdefiniertes ProtectionProfileObserverImpl, das in einem mip::ProtectionProfile::Settings-Konstruktor verwendet wird.

ProtectionHandler-Beobachterimplementierung

Ähnlich wie der Protection-Beobachter implementiert mip::ProtectionHandler eine mip::ProtectionHandler::Observer-Klasse zum Behandeln asynchroner Ereignisbenachrichtigungen während Schutzvorgängen. Die Implementierung ähnelt dem oben Beschriebenen. ProtectionHandlerObserverImpl wird teilweise unten definiert. Die vollständige Implementierung finden Sie in unserem GitHub-Beispiel-Repository.

ProtectionHandlerObserverImpl-Klassendeklaration

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

Partielle Implementierung von ProtectionHandlerObserverImpl

Dieses Beispiel ist nur die ersten beiden Funktionen, die übrigen Funktionen jedoch verwenden ein ähnliches Muster wie diese und wie 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);
};

Freigeben über