Microsoft Information Protection SDK: conceptos de perfil del SDK de protección

Los dos ejemplos siguientes muestran cómo crear el objeto profileSettings con almacenamiento local para almacenamiento de estado, así como solo en memoria.

Cargar un perfil

Ahora que ProtectionProfileObserverImpl el está definido, lo usaremos para crear una instancia mip::ProtectionProfile de . La creación mip::ProtectionProfile del objeto requiere mip::ProtectionProfile::Settings .

ProtectionProfile::Configuración Parámetros

  • std::shared_ptr<MipContext>: el mip::MipContext objeto que se inicializó para almacenar información de la aplicación, ruta de acceso de estado, etc.
  • mip::CacheStorageType: Define cómo almacenar el estado: en la memoria, en el disco o en el disco y cifrado.
  • std::shared_ptr<mip::ConsentDelegate>: Puntero compartido de clase mip::ConsentDelegate .
  • std::shared_ptr<mip::ProtectionProfile::Observer> observer: Un puntero compartido a la implementación del Observer perfil (en PolicyProfile , y ProtectionProfileFileProfile ).

Los dos ejemplos siguientes muestran cómo crear el objeto profileSettings con almacenamiento local para almacenamiento de estado, así como solo en memoria.

Almacenar el estado solo en la memoria

mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };

std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
				                                                                                  "mip_data",
                                                                                        		  mip::LogLevel::Trace,
                                                                                                  false);

std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

ProtectionProfile::Settings profileSettings(
    mMipContext,                                        // mipContext object
    mip::CacheStorageType::InMemory,                   // use in memory storage    
    std::make_shared<ConsentDelegateImpl>(),           // new consent delegate
    std::make_shared<ProtectionProfileObserverImpl>()); // new protection profile observer

Configuración de perfil de lectura y escritura desde la ruta de almacenamiento en disco

mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };

std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
    		                                                                                       "mip_data",
                                                                                       			   mip::LogLevel::Trace,
                                                                                                   false);

std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

ProtectionProfile::Settings profileSettings(
    mMipContext,                                         // mipContext object
    mip::CacheStorageType::OnDisk,                      // use on disk storage    
    std::make_shared<ConsentDelegateImpl>(),            // new consent delegate
    std::make_shared<ProtectionProfileObserverImpl>()); // new protection profile

A continuación, use el patrón de promesa/futuro para cargar el ProtectionProfile archivo .

auto profilePromise = std::make_shared<std::promise<std::shared_ptr<ProtectionProfile>>>();
auto profileFuture = profilePromise->get_future();
ProtectionProfile::LoadAsync(profileSettings, profilePromise);

Si hemos cargado un perfil y esa operación se ha realizado correctamente, ProtectionProfileObserverImpl::OnLoadSuccess nuestra implementación mip::ProtectionProfile::Observer::OnLoadSuccess se denomina. El objeto resultante o el puntero de excepción, así como el contexto, se pasan como parámetros a la función. El contexto es un puntero a los std::promise que hemos creado para controlar la operación asincrónica. La función simplemente establece el valor de la promesa en el objeto ProtectionProfile (contexto). Cuando se usa la función Future.get() principal, el resultado se puede almacenar en un objeto nuevo.

//get the future value and store in profile.
auto profile = profileFuture.get();

Ponerla juntos

Después de haber implementado completamente los observadores y el delegado de autenticación, ahora es posible cargar por completo un perfil. El botón de seguridad de código siguiente supone que todos los encabezados necesarios ya están incluidos.

int main()
{
    const string userName = "MyTestUser@contoso.com";
    const string password = "P@ssw0rd!";
    const string clientId = "MyClientId";

    mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };

    std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
				                                                                                       "mip_data",
                                                                                        			   mip::LogLevel::Trace,
                                                                                                       false);

    std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

    ProtectionProfile::Settings profileSettings(
        mMipContext,                                    // mipContext object
        mip::CacheStorageType::OnDisk,                 // use on disk storage        
        std::make_shared<ConsentDelegateImpl>(),       // new consent delegate
        std::make_shared<ProfileObserver>());          // new protection profile observer

    auto profilePromise = std::make_shared<promise<shared_ptr<ProtectionProfile>>>();
    auto profileFuture = profilePromise->get_future();
    ProtectionProfile::LoadAsync(profileSettings, profilePromise);
    auto profile = profileFuture.get();
}

El resultado final es que hemos cargado correctamente el perfil y almacenado en el objeto llamado profile .

Pasos siguientes

Ahora que se ha agregado el perfil, el siguiente paso es agregar un motor al perfil.

Conceptos del motor de protección