Schnellstart: Initialisierung der Clientanwendung (C#)

In dieser Schnellstartanleitung erfahren Sie, wie Sie das Clientinitialisierungsmuster implementieren, das vom MIP SDK .NET Wrapper zur Laufzeit verwendet wird.

Hinweis

Jede Clientanwendung, die die MIP-.NET Wrapperdatei, Richtlinie oder Schutz-SDKs verwendet, erfordert die in dieser Schnellstartanleitung beschriebenen Schritte. Obwohl diese Schnellstartanleitung die Verwendung der Datei-SDKs veranschaulicht, gilt dieses Muster für Clients, die die Richtlinien- und Schutz-SDKs verwenden. Schließen Sie zukünftige Schnellstarts fortlaufend ab, da jeder auf dem vorherigen aufbaut, wobei es sich dabei um den ersten handelt. Dieser Code soll veranschaulichen, wie Sie mit dem MIP SDK beginnen und nicht für die Produktionsverwendung vorgesehen sind.

Voraussetzungen

Falls noch nicht geschehen, sorgen Sie für Folgendes:

Führen Sie die Schritte im Microsoft Information Protection (MIP)-SDK-Setup und -Konfiguration aus. Diese Schnellstartanleitung "Clientanwendungsinitialisierung" basiert auf der richtigen SDK-Einrichtung und -Konfiguration.
Optionalerweise:
- Überprüfen Sie Profil- und Modulobjekte. Die Profil- und Modulobjekte sind universelle Konzepte, die von Clients benötigt werden, die die MIP File/Policy/Protection SDKs verwenden.
- Überprüfen Sie die Authentifizierungskonzepte , um zu erfahren, wie das SDK und die Clientanwendung Authentifizierung und Zustimmung implementieren.

Visual Studio-Lösung und Projekt erstellen

Erstellen und konfigurieren Sie zunächst die erste Visual Studio Lösung und das Projekt, auf der die anderen Schnellstarts erstellt werden.

Öffnen Sie Visual Studio 2022 oder höher, wählen Sie das Menü "Datei ", "Neu", "Projekt" aus. Im Dialogfeld "Neues Projekt ":
- Wählen Sie im linken Bereich unter "Installiert" Visual C#die Option "Windows Desktop" aus.
- Wählen Sie im mittleren Bereich Konsolen-App aus (mit Zielversion .NET 8 oder höher).
- Aktualisieren Sie im unteren Bereich Name, Speicherort und den darin enthaltenen Projektmappennamen des Projekts.
- Wenn Sie fertig sind, klicken Sie unten rechts auf die Schaltfläche "OK ".
Fügen Sie dem Projekt das NuGet-Paket für das MIP File SDK hinzu:
- Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten (direkt unter dem oberen/Projektmappenknoten), und wählen Sie "NuGet-Pakete verwalten"...:
- Wenn die Registerkarte "NuGet-Paket-Manager " im Bereich "Editorgruppe" geöffnet wird:
  - Wählen Sie Durchsuchen aus.
  - Geben Sie "Microsoft.InformationProtection" in das Suchfeld ein.
  - Wählen Sie das Paket "Microsoft.InformationProtection.File" aus.
  - Klicken Sie auf "Installieren" und dann auf "OK", wenn das Bestätigungsdialogfeld Vorschau änderungen angezeigt wird.
Wiederholen Sie die vorstehenden Schritte zum Hinzufügen des MIP File SDK-Pakets, fügen Sie der Anwendung stattdessen "Microsoft.Identity.Client" hinzu.

Implementieren eines Authentifizierungsdelegats

Das MIP-SDK realisiert die Authentifizierung mithilfe der Erweiterbarkeit von Klassen, wodurch ein Mechanismus bereitgestellt wird, um Authentifizierungsaufgaben mit der Clientanwendung zu teilen. Der Client muss ein geeignetes OAuth2-Zugriffstoken erwerben und es zur Laufzeit dem MIP SDK bereitstellen.

Erstellen Sie nun eine Implementierung für einen Authentifizierungsdelegat, indem Sie die Schnittstelle des Microsoft.InformationProtection.IAuthDelegate SDK erweitern und die IAuthDelegate.AcquireToken() virtuelle Funktion außer Kraft setzen oder implementieren. Die Objekte FileProfile und FileEngine instanziieren und verwenden den Authentifizierungsdelegierten später.

Klicken Sie in Visual Studio mit der rechten Maustaste auf den Projektnamen, und wählen Sie dann "Klasse hinzufügen" aus.
Geben Sie "AuthDelegateImplementation" in das Feld "Name " ein. Klicken Sie auf Hinzufügen.
Fügen Sie using-Anweisungen für die Microsoft Authentication Library (MSAL) (MSAL) und die MIP-Bibliothek hinzu:
```
using Microsoft.InformationProtection;
using Microsoft.Identity.Client;
```
Setzen Sie AuthDelegateImplementation so, dass es Microsoft.InformationProtection.IAuthDelegate erbt und implementieren Sie eine private Variable von Microsoft.InformationProtection.ApplicationInfo sowie einen Konstruktor, der denselben Typ akzeptiert.
```
public class AuthDelegateImplementation : IAuthDelegate
{
   private ApplicationInfo _appInfo;
   // Microsoft Authentication Library IPublicClientApplication
   private IPublicClientApplication _app;
   public AuthDelegateImplementation(ApplicationInfo appInfo)
   {
       _appInfo = appInfo;
   }

}
```
Das ApplicationInfo Objekt enthält drei Eigenschaften. Die Klasse AuthDelegateImplementation verwendet _appInfo.ApplicationId, um der Authentifizierungsbibliothek die Client-ID bereitzustellen. ApplicationNameund ApplicationVersion werden in Microsoft Purview Überwachungsberichten angezeigt.

Fügen Sie die public string AcquireToken()-Methode hinzu. Diese Methode sollte Microsoft.InformationProtection.Identity sowie drei Zeichenfolgen akzeptieren: Autoritäts-URL, Ressourcen-URI und Anforderungen, falls erforderlich. Die API übergibt diese Zeichenfolgenvariablen an die Authentifizierungsbibliothek, und Sie sollten sie nicht bearbeiten. Geben Sie die Mandanten-GUID aus dem Azure Portal für Ihren Mandanten ein. Das Bearbeiten anderer Zeichenfolgen als der Mandanten-GUID kann dazu führen, dass die Authentifizierung fehlschlägt.

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

Erstellen Sie nun eine Implementierung für einen Consent-Delegaten, indem Sie die Schnittstelle Microsoft.InformationProtection.IConsentDelegate des SDK erweitern und GetUserConsent() überschreiben oder implementieren. Die File-Profil- und File-Engine-Objekten instanziieren und verwenden den Einwilligungsdelegaten später. Der Zustimmungsdelegat erhält die Adresse des Diensts, den der Benutzer zur Verwendung im url Parameter zustimmen muss. Die Stellvertretung sollte in der Regel einen Fluss bereitstellen, mit dem der Benutzer die Zustimmung für den Zugriff auf den Dienst annehmen oder ablehnen kann. Für diese Schnellstartanleitung codieren Sie Consent.Accept fest.

Fügen Sie mit dem zuvor verwendeten Visual Studio-Feature "Klasse hinzufügen" Ihrem Projekt eine weitere Klasse hinzu. Geben Sie dieses Mal "ConsentDelegateImplementation" in das Feld "Klassenname " ein.
Aktualisieren Sie nun ConsentDelegateImpl.cs , um Ihre neue Zustimmungsdelegatklasse zu implementieren. Fügen Sie die using-Anweisung für Microsoft.InformationProtection hinzu, und legen Sie die Klasse so fest, dass sie von IConsentDelegate erbt.
```
class ConsentDelegateImplementation : IConsentDelegate
{
     public Consent GetUserConsent(string url)
     {
          return Consent.Accept;
     }
}
```
Versuchen Sie optional, die Lösung zu erstellen, um sicherzustellen, dass sie ohne Fehler kompiliert wird.

Initialisieren des verwalteten Wrappers des MIP SDK

Öffnen Sie im Projektmappen-Explorer die CS-Datei im Projekt, die die Implementierung der Main()-Methode enthält. Standardmäßig wird derselbe Name wie das Projekt verwendet, das es enthält, das Sie während der Projekterstellung angegeben haben.
Entfernen Sie die generierte Implementierung von main().
Der verwaltete Wrapper enthält eine statische Klasse, Microsoft.InformationProtection.MIP die für die Initialisierung, das Erstellen von MipContextProfilen, das Laden von Profilen und das Freigeben von Ressourcen verwendet wird. Um den Wrapper für File SDK-Vorgänge zu initialisieren, rufen Sie MIP.Initialize() auf und übergeben MipComponent.File, um die Bibliotheken zu laden, die für Dateivorgänge erforderlich sind.
Fügen Main() Sie in Program.cs Folgendes hinzu, indem Sie die Anwendungs-ID< durch die ID der zuvor erstellten Microsoft Entra-Anwendungsregistrierung ersetzen>.

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

Erstellen eines Dateienprofils und einer Engine

Wie erwähnt, erfordern SDK-Clients, die MIP-APIs verwenden, Profil- und Modulobjekte. Schließen Sie den Codierungsteil dieser Schnellstartanleitung ab, indem Sie Code zum Laden der systemeigenen DLLs hinzufügen und dann die Profil- und Modulobjekte instanziieren.

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

Ersetzen Sie die Platzhalterwerte im Quellcode, in den Sie eingefügt haben, mithilfe der folgenden Werte:

Platzhalter	Wert	Beispiel
<application-id>	Die Microsoft Entra Anwendungs-ID, die der Anwendung zugewiesen ist, die in "MIP SDK-Setup und -Konfiguration" registriert ist (2 Instanzen).	00001111-aaaa-2222-bbbb-3333cccc44444
<Freundlicher Name>	Ein benutzerdefinierter freundlicher Name für Ihre Anwendung.	AppInitialization
<Mandanten-GUID>	Mandanten-ID für Ihren Microsoft Entra Mandanten.	TenantID

Führen Sie nun einen endgültigen Build der Anwendung aus, und beheben Sie alle Fehler. Der Code sollte erfolgreich erstellt werden.

Nächste Schritte

Nun, da Ihr Initialisierungscode vollständig ist, sind Sie bereit für die nächste Schnellstartanleitung, in der Sie erste Erfahrungen mit den MIP File SDKs sammeln.

Vertraulichkeitsbezeichnungen auflisten

Feedback

War diese Seite hilfreich?

Last updated on 2026-09-21