Inicio rápido: Inicialización de la aplicación cliente (C#)

En esta guía de inicio rápido se muestra cómo implementar el patrón de inicialización del cliente que usa el contenedor de .NET del SDK de MIP en tiempo de ejecución.

Nota:

Cualquier aplicación cliente que utilice los SDK de Archivo, Política o Protección del envoltorio MIP .NET requiere seguir los pasos descritos en esta guía de inicio rápido. Aunque en este inicio rápido se muestra el uso de los SDK de archivo, este mismo patrón se aplica a los clientes que usan los SDK de directiva y protección. Complete los inicios rápidos futuros en serie, ya que cada uno se basa en el anterior, siendo éste el primero. Este código está pensado para demostrar cómo empezar a trabajar con el SDK de MIP y no está destinado a su uso en producción.

Prerrequisitos

Si aún no lo ha hecho:

Completar los pasos de Instalación y configuración del SDK de Microsoft Information Protection (MIP). Este inicio rápido "Inicialización de la aplicación cliente" se basa en la instalación y configuración correctas 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 obtener información sobre cómo el SDK y la aplicación cliente implementan la autenticación y el consentimiento.

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 compilan 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, Visual C#, seleccione Escritorio de Windows.
- En el panel central, seleccione Aplicación de consola (destinada a .NET 8 o posterior).
- 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, haga clic en el botón Aceptar en la esquina inferior derecha.
Agregue el paquete NuGet para el SDK de archivos MIP al proyecto:
- En el Explorador de soluciones, haga clic con el botón derecho en el nodo del proyecto (directamente en el nodo superior o solución) 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 paquete "Microsoft.InformationProtection.File".
  - Haga clic en "Instalar" y después en "Aceptar" cuando se muestre el cuadro de diálogo de confirmación Vista previa de los cambios.
Repita los pasos anteriores para agregar el paquete del SDK de archivo de MIP, pero en su lugar agregue "Microsoft.Identity.Client" a la aplicación.

Implementación de un delegado de autenticación

El SDK de MIP implementa la autenticación mediante 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.

Ahora cree una implementación para un delegado de autenticación ampliando la interfaz Microsoft.InformationProtection.IAuthDelegate del SDK y sobrescribiendo o implementando la función virtual IAuthDelegate.AcquireToken(). Los objetos FileProfile y FileEngine instancian y usan posteriormente el delegado de autenticación.

Haga clic con el botón derecho en el nombre del proyecto en Visual Studio, seleccione Agregar y, a continuación, Clase.
Escriba "AuthDelegateImplementation" en el campo Nombre. Haga clic en Agregar.
Agregue instrucciones Using para la biblioteca de autenticación de Microsoft (MSAL) y la biblioteca de MIP:
```
using Microsoft.InformationProtection;
using Microsoft.Identity.Client;
```
Establezca que AuthDelegateImplementation herede Microsoft.InformationProtection.IAuthDelegate e implemente una variable privada de Microsoft.InformationProtection.ApplicationInfo y un constructor que acepte el mismo tipo.
```
public class AuthDelegateImplementation : IAuthDelegate
{
   private ApplicationInfo _appInfo;
   // Microsoft Authentication Library IPublicClientApplication
   private IPublicClientApplication _app;
   public AuthDelegateImplementation(ApplicationInfo appInfo)
   {
       _appInfo = appInfo;
   }

}
```
El objeto ApplicationInfo contiene tres propiedades. La AuthDelegateImplementation clase usa _appInfo.ApplicationId para proporcionar el identificador de cliente a la biblioteca de autenticación. ApplicationNamey ApplicationVersion aparecen en Microsoft Purview informes de auditoría.

Agregue el método public string AcquireToken(). Este método debe aceptar Microsoft.InformationProtection.Identity y tres cadenas: dirección URL de autoridad, URI de recursos y notificaciones, si es necesario. La API pasa estas variables de cadena a la biblioteca de autenticación y no debe manipularlas. Introduce el GUID del inquilino desde el Azure Portal correspondiente a tu inquilino. La edición de cadenas que no sean el GUID del inquilino podría dar lugar a un error al autenticarse.

public string AcquireToken(Identity identity, string authority, string resource, string claims)
{
   var authorityUri = new Uri(authority);
   authority = String.Format("https://{0}/{1}", authorityUri.Host, "<Tenant-GUID>");

   _app = PublicClientApplicationBuilder.Create(_appInfo.ApplicationId).WithAuthority(authority).WithDefaultRedirectUri().Build();
   var accounts = (_app.GetAccountsAsync()).GetAwaiter().GetResult();

   // Append .default to the resource passed in to AcquireToken().
   string[] scopes = new string[] { resource[resource.Length - 1].Equals('/') ? $"{resource}.default" : $"{resource}/.default" };
   var result = _app.AcquireTokenInteractive(scopes).WithAccount(accounts.FirstOrDefault()).WithPrompt(Prompt.SelectAccount)
              .ExecuteAsync().ConfigureAwait(false).GetAwaiter().GetResult();

   return result.AccessToken;
}

Ahora cree una implementación para un delegado de consentimiento ampliando la interfaz Microsoft.InformationProtection.IConsentDelegate del SDK y sobrescribiendo o implementando GetUserConsent(). El perfil File y los objetos del motor File instancian y utilizan posteriormente el delegado de consentimiento. El delegado de consentimiento recibe la dirección del servicio que el usuario debe autorizar para su uso en el parámetro url. Por lo general, el delegado debe proporcionar un flujo que permita al usuario aceptar o rechazar el consentimiento para acceder al servicio. Para este inicio rápido, codifique Consent.Acceptde forma rígida .

Con la misma característica "Agregar clase" de Visual Studio que ha usado antes, agregue otra clase al proyecto. Esta vez, escriba "ConsentDelegateImplementation" en el campo Nombre de clase.
Ahora, actualice ConsentDelegateImpl.cs para implementar la nueva clase de delegado de consentimiento. Agregue la instrucción Using para Microsoft.InformationProtection y establezca la clase para heredar IConsentDelegate.
```
class ConsentDelegateImplementation : IConsentDelegate
{
     public Consent GetUserConsent(string url)
     {
          return Consent.Accept;
     }
}
```
Opcionalmente, intente crear la solución para asegurarse de que se compila sin errores.

Inicialización del contenedor administrado del SDK de MIP

Con el Explorador de soluciones, abra el archivo .cs 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().
El contenedor administrado incluye una clase estática, Microsoft.InformationProtection.MIP, que se usa para inicializar, crear MipContext, cargar perfiles y liberar recursos. Para inicializar el contenedor para las operaciones del SDK de archivo, llame a MIP.Initialize(), pasando MipComponent.File para cargar las bibliotecas necesarias para las operaciones de archivo.
En Main(), en Program.cs, añada lo siguiente, sustituyendo <application-id> por el identificador del registro de aplicaciones de Microsoft Entra creado anteriormente.

using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.Exceptions;
using Microsoft.InformationProtection.File;
using Microsoft.InformationProtection.Protection;

namespace mip_sdk_dotnet_quickstart
{
    class Program
    {
        private const string clientId = "<application-id>";
        private const string appName = "<friendly-name>";

        static void Main(string[] args)
        {
            //Initialize Wrapper for File SDK operations
            MIP.Initialize(MipComponent.File);
            
        }
    }
}

Creación de un motor y un perfil de archivo

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 cargar los archivos DLL nativos y, a continuación, cree una instancia de los objetos de perfil y motor.

using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.File;

namespace mip_sdk_dotnet_quickstart
{
  class Program
  {
       private const string clientId = "<application-id>";
       private const string appName = "<friendly-name>";

       static void Main(string[] args)
       {
            // Initialize Wrapper for File SDK operations.
            MIP.Initialize(MipComponent.File);

            // Create ApplicationInfo, setting the clientID from Microsoft Entra App Registration as the ApplicationId.
            ApplicationInfo appInfo = new ApplicationInfo()
            {
                 ApplicationId = clientId,
                 ApplicationName = appName,
                 ApplicationVersion = "1.0.0"
            };

            // Instantiate the AuthDelegateImpl object, passing in AppInfo.
            AuthDelegateImplementation authDelegate = new AuthDelegateImplementation(appInfo);

            // Create MipConfiguration Object
            MipConfiguration mipConfiguration = new MipConfiguration(appInfo, "mip_data", LogLevel.Trace, false);

            // Create MipContext using Configuration
            MipContext mipContext = MIP.CreateMipContext(mipConfiguration);

            // Initialize and instantiate the File Profile.
            // Create the FileProfileSettings object.
            // Initialize file profile settings to create/use local state.
            var profileSettings = new FileProfileSettings(mipContext,
                                     CacheStorageType.OnDiskEncrypted,
                                     new ConsentDelegateImplementation());

            // Load the Profile async and wait for the result.
            var fileProfile = Task.Run(async () => await MIP.LoadFileProfileAsync(profileSettings)).Result;

            // Create a FileEngineSettings object, then use that to add an engine to the profile.
            // This pattern sets the engine ID to user1@tenant.com, then sets the identity used to create the engine.
            var engineSettings = new FileEngineSettings("user1@tenant.com", authDelegate, "", "en-US");
            engineSettings.Identity = new Identity("user1@tenant.com");

            var fileEngine = Task.Run(async () => await fileProfile.AddEngineAsync(engineSettings)).Result;

            // Application Shutdown
            // handler = null; // This will be used in later quick starts.
            fileEngine = null;
            fileProfile = null;
            mipContext.ShutDown();
            mipContext = null;
       }
  }
}

Sustituya los valores de los marcadores de posición en el código fuente que ha pegado por los siguientes valores:

Marcador de posición	Valor	Ejemplo
<application-id>	El identificador de aplicación de Microsoft Entra asignado a la aplicación registrada en "instalación y configuración del SDK de MIP" (2 instancias).	00001111-aaaa-2222-bbbb-3333cccc4444
<nombre amigable>	Nombre descriptivo de la aplicación definido por el usuario.	AppInitialization
<Tenant-GUID>	ID del inquilino de su inquilino de Microsoft Entra.	TenantID

Ahora realice una compilación final de la aplicación y resuelva los errores. El código debe crearse correctamente.

Pasos siguientes

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

Enumeración de las etiquetas de confidencialidad

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-09-21