Démarrage rapide : Initialisation de l’application cliente (C#)

Ce guide de démarrage rapide vous montre comment implémenter le modèle d’initialisation du client, utilisé par le wrapper .NET du SDK MIP au moment de l’exécution.

Remarque

Les étapes décrites dans ce guide de démarrage rapide sont requises pour toutes les applications clientes qui utilisent le wrapper .NET MIP avec les SDK de fichiers, de stratégies ou de protection. Bien que ce guide de démarrage rapide illustre l’utilisation des kits SDK File, ce même modèle s’applique aux clients qui utilisent les kits SDK de stratégie et de protection. Les démarrages rapides futurs doivent être effectués en série, car chacun s’appuie sur le précédent, avec celui-ci étant le premier. Ce code est destiné à montrer comment commencer avec le KIT SDK MIP et n’est pas destiné à une utilisation en production.

Conditions préalables

Si ce n’est déjà fait, veillez à :

Effectuez les étapes de configuration et de configuration du Kit de développement logiciel (SDK) Microsoft Information Protection (MIP). Ce guide de démarrage rapide « Initialisation de l’application cliente » s’appuie sur la configuration et l’installation appropriées du Kit de développement logiciel (SDK).
Optionnellement:
- Passez en revue les objets profil et moteur. Les objets de profil et de moteur sont des concepts universels, requis par les clients qui utilisent les kits SDK MIP File/Policy/Protection.
- Passez en revue les concepts d’authentification pour savoir comment l’authentification et le consentement sont implémentés par le Kit de développement logiciel (SDK) et l’application cliente.

Créer une solution et un projet Visual Studio

Tout d’abord, nous créons et configurons la solution et le projet Visual Studio initiaux, sur lesquels les autres démarrages rapides seront générés.

Ouvrez Visual Studio 2019, sélectionnez le menu Fichier , Nouveau, Projet. Dans la boîte de dialogue Nouveau projet :
- Dans le volet gauche, sous Installé, Visual C#, sélectionnez Windows Desktop.
- Dans le volet central, sélectionnez Application console (.NET Framework)
- Dans le volet inférieur, mettez à jour le nom du projet, l’emplacement et le nom de solution contenant en conséquence.
- Lorsque vous avez terminé, cliquez sur le bouton OK en bas à droite.
Ajoutez le package NuGet pour le Kit de développement logiciel (SDK) de fichier MIP à votre projet :
- Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet (directement sous le nœud supérieur/solution), puis sélectionnez Gérer les packages NuGet... :
- Lorsque l’onglet Gestionnaire de package NuGet s’ouvre dans la zone onglets Groupe d’éditeurs :
  - Cliquez sur Parcourir.
  - Entrez « Microsoft.InformationProtection » dans la zone de recherche.
  - Sélectionnez le package « Microsoft.InformationProtection.File ».
  - Cliquez sur « Installer », puis sur « OK » lorsque la boîte de dialogue de confirmation Visualiser les modifications s’affiche.
Répétez les étapes ci-dessus pour ajouter le package sdk de fichier MIP, mais ajoutez plutôt « Microsoft.Identity.Client » à l’application.

Implémenter un délégué d’authentification

Le SDK MIP implémente l’authentification à l’aide de l’extensibilité de classe, qui fournit un mécanisme permettant de partager l’authentification avec l’application cliente. Le client doit acquérir un jeton d’accès OAuth2 approprié et fournir au SDK MIP au moment de l’exécution.

À présent, créez une implémentation pour un délégué d’authentification, en étendant l’interface du Kit de Microsoft.InformationProtection.IAuthDelegate développement logiciel (SDK) et en remplaçant/implémentant la IAuthDelegate.AcquireToken() fonction virtuelle. Le délégué d’authentification est instancié et utilisé ultérieurement par les objets FileProfile et FileEngine.

Cliquez avec le bouton droit sur le nom du projet dans Visual Studio, sélectionnez Ajouter , puis Classe.
Entrez « AuthDelegateImplementation » dans le champ Nom . Cliquez sur Ajouter.
Ajoutez des instructions d’utilisation à l’aide de la bibliothèque Microsoft Authentication Library (MSAL) et de la bibliothèque MIP :
```
using Microsoft.InformationProtection;
using Microsoft.Identity.Client;
```
Définir AuthDelegateImplementation afin d'hériter Microsoft.InformationProtection.IAuthDelegate et implémenter une variable privée de type Microsoft.InformationProtection.ApplicationInfo et un constructeur qui accepte le même type.
```
public class AuthDelegateImplementation : IAuthDelegate
{
   private ApplicationInfo _appInfo;
   // Microsoft Authentication Library IPublicClientApplication
   private IPublicClientApplication _app;
   public AuthDelegateImplementation(ApplicationInfo appInfo)
   {
       _appInfo = appInfo;
   }

}
```
L’objet ApplicationInfo contient trois propriétés. _appInfo.ApplicationId sera utilisé dans la classe AuthDelegateImplementation pour fournir l’ID client à la bibliothèque d’authentification. ApplicationName et ApplicationVersion sera exposé dans les rapports d’audit Microsoft Purview.

Ajoutez la méthode public string AcquireToken(). Cette méthode doit accepter Microsoft.InformationProtection.Identity et trois chaînes : URL d’autorité, URI de ressource et revendications, si nécessaire. Ces variables de chaîne sont transmises à la bibliothèque d’authentification par l’API et ne doivent pas être manipulées. Veuillez saisir le GUID du locataire depuis le portail Azure pour votre client. La modification de chaînes autres que le GUID du locataire peut entraîner un échec de l’authentification.

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

Maintenant, créez une implémentation pour un délégué de consentement, en étendant l’interface du Kit de Microsoft.InformationProtection.IConsentDelegate développement logiciel (SDK) et en remplaçant/implémentant GetUserConsent(). Le délégué de consentement est instancié et utilisé ultérieurement par les objets de profil File et de moteur File. Le délégué de consentement est fourni avec l’adresse du service que l’utilisateur doit consentir à utiliser dans le url paramètre. Le délégué doit généralement fournir un flux qui permet à l’utilisateur d’accepter ou de rejeter son consentement pour accéder au service. Pour ce démarrage rapide, codez en dur Consent.Accept.

À l’aide de la même fonctionnalité « Ajouter une classe » de Visual Studio que nous avons utilisée précédemment, ajoutez une autre classe à votre projet. Cette fois, entrez « ConsentDelegateImplementation » dans le champ Nom de la classe .
Mettez maintenant à jour ConsentDelegateImpl.cs pour implémenter votre nouvelle classe de délégué pour le consentement. Ajoutez l’instruction using pour Microsoft.InformationProtection et définissez la classe pour hériter IConsentDelegate.
```
class ConsentDelegateImplementation : IConsentDelegate
{
     public Consent GetUserConsent(string url)
     {
          return Consent.Accept;
     }
}
```
Si vous le souhaitez, essayez de générer la solution pour vous assurer qu’elle se compile sans erreur.

Initialiser le wrapper managé du kit de développement logiciel (SDK) MIP

À partir de l’Explorateur de solutions, ouvrez le fichier .cs dans votre projet qui contient l’implémentation de la Main() méthode. Il a par défaut le même nom que le projet qui le contient, que vous avez spécifié lors de la création du projet.
Supprimez l’implémentation générée de main().
Le wrapper managé inclut une classe statique, Microsoft.InformationProtection.MIP utilisée pour l’initialisation, la création d’un MipContextprofil de chargement et la libération de ressources. Pour initialiser le wrapper pour les opérations du SDK de fichiers, appelez MIP.Initialize(), en passant MipComponent.File afin de charger les bibliothèques nécessaires aux opérations de fichier.
Dans Main()Program.cs ajoutez ce qui suit, en <remplaçant l’ID d’application par l’ID> de l’inscription d’application Microsoft Entra créée précédemment.

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

Construire un profil de fichier et un moteur

Comme mentionné, les objets de profil et de moteur sont requis pour les clients sdk utilisant des API MIP. Terminez la partie de codage de ce guide de démarrage rapide, en ajoutant du code pour charger les DLL natives, puis instanciez les objets de profil et de moteur.

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

Remplacez les valeurs d’espace réservé dans le code source que vous avez collé, avec les valeurs suivantes :

Espace réservé	Valeur	Exemple :
<id d’application>	ID d’application Microsoft Entra affecté à l’application inscrite dans « Configuration et configuration du Kit de développement logiciel (SDK) MIP » (2 instances).	0edbblll-8773-44de-b87c-b8c6276d41eb
<nom convivial>	Nom convivial défini par l’utilisateur pour votre application.	Initialisation de l'Application
<TENANT-GUID>	Tenant-ID pour votre locataire Microsoft Entra	TenantID

Effectuez maintenant une build finale de l’application et résolvez toutes les erreurs. Votre code doit se compiler avec succès.

Étapes suivantes

Maintenant que votre code d’initialisation est terminé, vous êtes prêt pour le prochain guide de prise en main, où vous commencerez à découvrir les SDK de fichiers MIP.

Répertorier les étiquettes de confidentialité

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-04-30