Inicio rápido: Inicialización de aplicaciones cliente para SDK de protección (C++)

En este inicio rápido se muestra cómo implementar el patrón de inicialización de cliente que usa el SDK de C++ de MIP en tiempo de ejecución.

Nota:

Cualquier aplicación cliente que use los SDK de protección miP requiere los pasos descritos en este inicio rápido. Complete estos inicios rápidos en serie después de la inicialización de la aplicación y la implementación de clases de delegado de autenticación y delegados de consentimiento.

Prerrequisitos

Si aún no lo ha hecho:

Completar los pasos de Instalación y configuración del SDK de Microsoft Information Protection (MIP). Esta guía de inicio rápido de "Inicialización de la aplicación cliente" depende de una correcta instalación y configuración del SDK.
Opcionalmente:
- Revise Objetos de perfil y motor. Los objetos de perfil y motor son conceptos universales, necesarios para los clientes que usan los SDK de archivos, directivas o protección de MIP.
- Revise Conceptos de autenticación para información sobre cómo el SDK y la aplicación cliente implementan la autenticación y el consentimiento.
- Revise Conceptos de observador para más información sobre los observadores y cómo se implementan. El SDK de MIP usa el patrón de observador para implementar notificaciones de eventos asincrónicos.

Creación de una solución y un proyecto de Visual Studio

En primer lugar, cree y configure la solución y el proyecto iniciales de Visual Studio en los que se basan las otras guías de inicio rápido.

Abra Visual Studio 2022 o posterior, seleccione el menú Archivo , Nuevo, Proyecto. En el cuadro de diálogo Nuevo proyecto:
- En el panel de la izquierda, en Instalados, Otros lenguajes, seleccione Visual C++.
- En el panel central, seleccione Aplicación de consola de Windows.
- En el panel inferior, actualice el Nombre y la Ubicación del proyecto, y el Nombre de la solución en la que se incluye, según corresponda.
- Cuando termine, seleccione Aceptar en la esquina inferior derecha.
Agregue el paquete NuGet para el SDK de protección de MIP al proyecto:
- En Explorador de soluciones, haga clic con el botón derecho en el nodo del proyecto directamente en el nodo de la solución superior y seleccione Administrar paquetes NuGet...:
- Cuando se abra la pestaña Administrador de paquetes NuGet en el área de pestañas del grupo de editores:
  - Selecciona Examinar.
  - Escriba Microsoft.InformationProtection en el cuadro de búsqueda.
  - Seleccione el Microsoft.InformationProtection.Protection paquete.
  - Seleccione Instalar y, a continuación, seleccione Aceptar cuando aparezca el cuadro de diálogo de confirmación Vista previa de cambios .

Implementación de clases de observador para supervisar los objetos de perfil y motor de protección

Ahora cree una implementación básica para una clase de observador de perfil de protección mediante la extensión de la clase del mip::ProtectionProfile::Observer SDK. El SDK crea una instancia del observador y lo usa más adelante para supervisar la carga del objeto de perfil de protección y agregar el objeto de motor al perfil.

Agregue una nueva clase al proyecto, que genera los archivos de encabezado (.h) e implementación (.cpp) automáticamente:
- En Explorador de soluciones, vuelva a hacer clic con el botón derecho en el nodo del proyecto, seleccione Agregar y, a continuación, seleccione Clase.
- En el cuadro de diálogo Agregar clase:
  - En el campo Nombre de clase , escriba profile_observer. Tenga en cuenta que Visual Studio rellena automáticamente los campos de archivo .h y .cpp en función del nombre que escriba.
  - Cuando haya terminado, seleccione Aceptar.

Después de generar los archivos .h y .cpp para la clase , Visual Studio abre ambos archivos en las pestañas Grupo de editores. Ahora actualice cada archivo para implementar la nueva clase de observador:

Actualice profile_observer.h seleccionando y eliminando la clase generada profile_observer . No quite las directivas de preprocesador que generó el paso anterior (#pragma, #include). A continuación, copie y pegue el siguiente código fuente en el archivo después de las directivas de preprocesador existentes, si las hubiera:

#include <memory>
#include "mip/protection/protection_profile.h"
using std::exception_ptr;
using std::shared_ptr;


class ProtectionProfileObserver final : public mip::ProtectionProfile::Observer {
public:
     ProtectionProfileObserver() { }
     void OnLoadSuccess(const std::shared_ptr<mip::ProtectionProfile>& profile, const std::shared_ptr<void>& context) override;
     void OnLoadFailure(const std::exception_ptr& Failure, const std::shared_ptr<void>& context) override;
     void OnAddEngineSuccess(const std::shared_ptr<mip::ProtectionEngine>& engine, const std::shared_ptr<void>& context) override;
     void OnAddEngineFailure(const std::exception_ptr& Failure, const std::shared_ptr<void>& context) override;
};

Actualice profile_observer.cpp seleccionando y eliminando la implementación de clase generada profile_observer . No quite las directivas de preprocesador que generó el paso anterior (#pragma, #include). A continuación, copie y pegue el siguiente código fuente en el archivo después de las directivas de preprocesador existentes, si las hubiera:

#include <future>

using std::promise;
using std::shared_ptr;
using std::static_pointer_cast;
using mip::ProtectionEngine;
using mip::ProtectionProfile;

void ProtectionProfileObserver::OnLoadSuccess(const shared_ptr<ProtectionProfile>& profile, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionProfile>>>(context);
     promise->set_value(profile);
}

void ProtectionProfileObserver::OnLoadFailure(const std::exception_ptr& error, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionProfile>>>(context);
     promise->set_exception(error);
}

void ProtectionProfileObserver::OnAddEngineSuccess(const shared_ptr<ProtectionEngine>& engine, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionEngine>>>(context);
     promise->set_value(engine);
}

void ProtectionProfileObserver::OnAddEngineFailure(const std::exception_ptr& error, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionEngine>>>(context);
     promise->set_exception(error);
}

Repita el paso 1 para agregar una nueva clase para el observador del motor de protección, engine_observer, al proyecto. Esta clase genera los archivos de encabezado (.h) e implementación (.cpp).

Actualice engine_observer.h seleccionando y eliminando la clase generada engine_observer . No quite las directivas de preprocesador que generó el paso anterior (#pragma, #include). A continuación, copie y pegue el siguiente código fuente en el archivo después de las directivas de preprocesador existentes, si las hubiera:

#include <memory>
#include "mip/protection/protection_engine.h"
using std::vector;
using std::exception_ptr;
using std::shared_ptr;

class ProtectionEngineObserver final : public mip::ProtectionEngine::Observer {
  public:
  ProtectionEngineObserver() {}
  void OnGetTemplatesSuccess(const vector<std::shared_ptr<mip::TemplateDescriptor>>& templateDescriptors, const shared_ptr<void>& context) override;
  void OnGetTemplatesFailure(const exception_ptr& Failure, const shared_ptr<void>& context) override;

};

Actualice engine_observer.cpp seleccionando y eliminando la implementación de clase generada engine_observer . No quite las directivas de preprocesador que generó el paso anterior (#pragma, #include). A continuación, copie y pegue el siguiente código fuente en el archivo después de las directivas de preprocesador existentes, si las hubiera:

#include "mip/protection/protection_profile.h"
#include "engine_observer.h"

using std::promise;
void ProtectionEngineObserver::OnGetTemplatesSuccess(const vector<shared_ptr<mip::TemplateDescriptor>>& templateDescriptors,const shared_ptr<void>& context) {
    auto loadPromise = static_cast<promise<vector<shared_ptr<mip::TemplateDescriptor>>>*>(context.get());
    loadPromise->set_value(templateDescriptors);
  };

  void ProtectionEngineObserver::OnGetTemplatesFailure(const exception_ptr& Failure, const shared_ptr<void>& context) {
    auto loadPromise = static_cast<promise<vector<shared_ptr<mip::TemplateDescriptor>>>*>(context.get());
    loadPromise->set_exception(Failure);
  };

Si lo desea, puede usar Ctrl+Mayús+B (Compilar la solución) para ejecutar una compilación y un enlazado de prueba de la solución, y comprobar que se genera correctamente antes de continuar.

El SDK de MIP implementa la autenticación a través de la extensibilidad de clases, que proporciona un mecanismo para compartir la autenticación con la aplicación cliente. El cliente debe adquirir un token de acceso de OAuth2 adecuado y proporcionarlo al SDK de MIP en tiempo de ejecución.

Cree una implementación para un delegado de autenticación extendiendo la clase mip::AuthDelegate del SDK y sobrescribiendo o implementando la función virtual pura mip::AuthDelegate::AcquireOAuth2Token(). Siga los pasos que se detallan en Inicio rápido de inicialización de la aplicación del SDK de archivos. El perfil de protección y los objetos del motor de protección instancian y utilizan posteriormente el delegado de autenticación.

Ahora cree una implementación de un delegado de consentimiento extendiendo la clase mip::ConsentDelegate del SDK y sobrescribiendo o implementando la función virtual pura mip::AuthDelegate::GetUserConsent(). Siga los pasos que se detallan en Inicio rápido de inicialización de la aplicación del SDK de archivos. Los objetos Protection profile y Protection engine instancian y usan posteriormente el delegado de consentimiento.

Creación de un motor y un perfil de protección

Como se mencionó, los clientes del SDK que usan api de MIP requieren objetos de perfil y motor. Complete la parte de codificación de este inicio rápido agregando código para crear instancias de los objetos de perfil y motor:

En el Explorador de soluciones, abra el archivo .cpp del proyecto que contiene la implementación del método main(). De manera predeterminada, tiene el mismo nombre que el proyecto que lo contiene, que especificó al crear el proyecto.
Quite la implementación generada de main(). No quite las directivas de preprocesador generadas por Visual Studio durante la creación del proyecto (#pragma, #include). Anexe el código siguiente después de las directivas de preprocesador:

#include "mip/mip_context.h"  
#include "auth_delegate.h"
#include "consent_delegate.h"
#include "profile_observer.h"
#include"engine_observer.h"

using std::promise;
using std::future;
using std::make_shared;
using std::shared_ptr;
using std::string;
using std::cout;
using mip::ApplicationInfo;
using mip::ProtectionProfile;
using mip::ProtectionEngine;

int main(){

  // Construct/initialize objects required by the application's profile object
  // ApplicationInfo object (App ID, name, version)
  ApplicationInfo appInfo{"<application-id>",                    
                          "<application-name>",
                          "<application-version>"};

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

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

  auto profileObserver = make_shared<ProtectionProfileObserver>(); // Observer object
  auto authDelegateImpl = make_shared<AuthDelegateImpl>("<application-id>"); // Authentication delegate object (App ID)
  auto consentDelegateImpl = make_shared<ConsentDelegateImpl>(); // Consent delegate object

  // Construct/initialize profile object
  ProtectionProfile::Settings profileSettings(
    mMipContext,
    mip::CacheStorageType::OnDisk,      
    consentDelegateImpl,
    profileObserver);

  // Set up promise/future connection for async profile operations; load profile asynchronously
  auto profilePromise = make_shared<promise<shared_ptr<ProtectionProfile>>>();
  auto profileFuture = profilePromise->get_future();
  try
  {
    mip::ProtectionProfile::LoadAsync(profileSettings, profilePromise);
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... are the Settings and ApplicationInfo objects populated correctly?\n\n"
          << e.what() << "'\n";
    system("pause");
    return 1;
  }

  auto profile = profileFuture.get();

  // Construct/initialize engine object
  ProtectionEngine::Settings engineSettings(       
     mip::Identity("<engine-account>"),         // Engine identity (account used for authentication)
     authDelegateImpl,                          // Reference to mip::AuthDelegate implementation
     "",                                        // ClientData field
     "en-US");                                  // Locale (default = en-US)

  // Set the engineId so it can be cached and reused. 
  engineSettings.SetEngineId("<engine-account>");

  // Set up promise/future connection for async engine operations; add engine to profile asynchronously
  auto enginePromise = make_shared<promise<shared_ptr<ProtectionEngine>>>();
  auto engineFuture = enginePromise->get_future();
  profile->AddEngineAsync(engineSettings, enginePromise);
  std::shared_ptr<ProtectionEngine> engine;

  try
  {
    engine = engineFuture.get();
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... is the access token incorrect/expired?\n\n"
         << e.what() << "'\n";
    system("pause");
    return 1;
  }

  // Application shutdown. Null out profile and engine, call ReleaseAllResources();
  // Application may crash at shutdown if resources aren't properly released.
  engine = nullptr;
  profile = nullptr;
  mMipContext->ShutDown();
  mMipContext = nullptr;

  return 0;
}

Sustituya todos los valores de marcador de posición del código fuente que ha pegado por constantes de cadena:

Marcador de posición	Valor	Ejemplo
<application-id>	El identificador de aplicación (GUID) de Microsoft Entra asignado a la aplicación que registró en el paso n.º 2 del artículo instalación y configuración del SDK de MIP. Reemplace ambas instancias.	`"00001111-aaaa-2222-bbbb-3333cccc4444"`
<nombre de aplicación>	Nombre descriptivo de la aplicación definido por el usuario. Debe contener caracteres ASCII válidos (excepto '; ') e idealmente coincide con el nombre de la aplicación que usó en el registro de Microsoft Entra.	`"AppInitialization"`
<versión de la aplicación>	Información de versión definida por el usuario para la aplicación. Debe contener caracteres ASCII válidos (excepto ';').	`"1.1.0.0"`
<engine-account>	Cuenta usada para la identidad del motor. Cuando se autentique con una cuenta de usuario durante la adquisición de tokens, debe coincidir con este valor.	`"user1@tenant.onmicrosoft.com"`
<estado del motor>	Estado definido por el usuario que se va a asociar al motor.	`"My App State"`

Ahora realice una compilación final de la aplicación y resuelva los errores. El código debe compilarse correctamente, pero no se ejecuta correctamente hasta completar el siguiente inicio rápido. Si ejecuta la aplicación, verá un resultado similar al siguiente. La aplicación construye correctamente el perfil de protección y el motor de protección, pero no activa el módulo de autenticación y no tiene un token de acceso hasta que complete el siguiente inicio rápido.
```
 C:\MIP Sample Apps\ProtectionQS\Debug\ProtectionQS.exe (process 8252) exited with code 0.
 To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
 Press any key to close this window . . .
```

Pasos siguientes

Ahora que el código de inicialización está completo, ya está listo para el siguiente inicio rápido, donde comienza a experimentar el SDK de protección de MIP.

Enumeración de plantillas de protección

Explore el ejemplo de C++ del SDK de protección de MIP en GitHub.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-09-21