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 que le SDK MIP .NET wrapper utilise au moment de l’exécution.

Remarque

Toute application cliente qui utilise les kits SDK de fichier, de stratégie ou de protection du wrapper MIP .NET nécessite les étapes décrites dans ce guide de démarrage rapide. 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. Suivez les prochains guides de démarrage rapide successivement, car chacun s’appuie sur le précédent, 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 découvrir comment le SDK et l’application cliente implémentent l’authentification et le consentement.

Créer une solution et un projet Visual Studio

Tout d’abord, créez et configurez la solution et le projet Visual Studio initiaux sur lesquels s’appuient les autres guides de démarrage rapide.

Ouvrez Visual Studio 2022 ou version ultérieure, 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 (ciblant .NET 8 ou version ultérieure).
- 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 le 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 ou en implémentant la IAuthDelegate.AcquireToken() fonction virtuelle. Les objets FileProfile et FileEngine créent une instance du délégué d’authentification et l’utilisent par la suite.

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. La AuthDelegateImplementation classe utilise _appInfo.ApplicationId pour fournir l’ID client à la bibliothèque d’authentification. ApplicationName et ApplicationVersion apparaissent 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. L’API transmet ces variables de chaîne dans la bibliothèque d’authentification et vous ne devez pas les manipuler. Saisissez le GUID du locataire dans le portail Azure correspondant à votre locataire. 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;
}

À présent, 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 ou implémentant GetUserConsent(). Le profil de fichier et les objets du moteur de fichiers instancient et utilisent ultérieurement le délégué de consentement. Le délégué de consentement reçoit l’adresse du service que l’utilisateur doit accepter d’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 le consentement pour accéder au service. Pour ce guide de démarrage, 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 clients du KIT de développement logiciel (SDK) qui utilisent des API MIP nécessitent des objets de profil et de moteur. 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 dans le code source que vous avez collé les valeurs de remplacement par les valeurs suivantes :

Espace réservé	Valeur	Exemple :
<id d’application>	L’ID d’application Microsoft Entra attribué à l’application enregistrée dans « Installation et configuration du SDK MIP » (2 instances).	0000111-aaaa-2222-bbbb-3333cccc4444
<nom convivial>	Nom convivial défini par l’utilisateur pour votre application.	Initialisation de l'Application
<Tenant-GUID>	ID de locataire de 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 découvrirez les SDK de fichiers MIP.

Répertorier les étiquettes de confidentialité

Commentaires

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

Last updated on 2026-09-21