Szybki start: inicjowanie aplikacji klienckiej (C#)

Ten przewodnik Szybki start pokaże, jak wdrożyć wzorzec inicjowania klienta używany przez zawijacz .NET zestawu SDK MIP w środowisku uruchomieniowym.

Wymagania wstępne

Jeśli jeszcze tego nie zrobić, pamiętaj, aby:

• Wykonaj czynności opisane w te Microsoft Information Protection (MIP) SDK konfiguracji. Ten przewodnik Szybki start "Inicjowanie aplikacji klienckich" korzysta z odpowiedniej konfiguracji i konfiguracji zestawu SDK.
• Opcjonalnie:
  • Przejrzyj obiekty profilów i aparatów. Obiekty profilu i aparatu to uniwersalne koncepcje wymagane przez klientów, którzy korzystają z zestawów SDK plików/zasad/ochrony miP.
  • Zapoznaj się z pojęciami uwierzytelniania, aby dowiedzieć się, jak uwierzytelnianie i zgoda są zaimplementowane przez zestaw SDK i aplikację kliencną.

Tworzenie Visual Studio i projektu

Najpierw tworzymy i konfigurujemy początkowe Visual Studio rozwiązania i projektu, na którym będą konstruowane inne szybkie starty.

1. Otwórz Visual Studio 2019, wybierz menu Plik,Nowy,Project. W oknie Project dialogowym Nowy:

   • W okienku po lewej stronie w obszarze Zainstalowano, Visual C#wybierz pozycję Windows pulpit.

   • W środkowym okienku wybierz pozycję Aplikacja konsoli (.NET Framework)

   • W dolnym okienku zaktualizuj odpowiednio nazwę projektu,lokalizację i odpowiednio zawierającą nazwę rozwiązania.

   • Po zakończeniu kliknij przycisk OK w prawym dolnym rogu.

     

2. Dodaj pakiet Nuget do zestawu SDK pliku MIP do projektu:

   • W Eksploratorze rozwiązańkliknij prawym przyciskiem myszy węzeł projektu (bezpośrednio pod węzłem górnego/węzła rozwiązania) i wybierz pozycję Zarządzaj pakietami NuGet projektu...:
   • Gdy karta NuGet Menedżer pakietów zostanie otwarta w obszarze kart Grupy edytorów:
     • Wybierz pozycję Przeglądaj.
     • W polu wyszukiwania wprowadź "Microsoft.InformationProtection".
     • Wybierz pakiet "Microsoft.InformationProtection.File".
     • Kliknij przycisk "Zainstaluj", a następnie kliknij przycisk "OK", gdy zostanie wyświetlone okno dialogowe potwierdzenia zmian w podglądzie.

3. Powtórz powyższe czynności w celu dodania pakietu ZESTAWU SDK pliku MIP, ale zamiast tego dodaj do aplikacji plik "Microsoft.Identity.Client".

Implementowanie pełnomocnika uwierzytelniania

Zestaw SDK protokołu MIP implementuje uwierzytelnianie za pomocą rozszerzalności klasy, który udostępnia mechanizm udostępniania uwierzytelniania podczas pracy z aplikacją kliencową. Klient musi uzyskać odpowiedni token dostępu OAuth2 i podać zestaw SDK MIP w czasie wykonywania.

Teraz utwórz implementację pełnomocnika uwierzytelniania, rozszerzając interfejs zestawu SDK Microsoft.InformationProtection.IAuthDelegate i zastępując/implementując funkcję IAuthDelegate.AcquireToken() wirtualną. Pełnomocnik uwierzytelniania zostanie wystąpienia i będzie później używany przez FileProfile obiekty FileEngine i.

1. Kliknij prawym przyciskiem myszy nazwę projektu w programie Visual Studio, wybierz pozycję Dodaj, a następnie pozycję Klasa.

2. Wprowadź "AuthDelegateImplementation" w polu Name (Nazwa). Kliknij przycisk Dodaj.

3. Dodaj instrukcje użycia dla biblioteki Microsoft Authentication Library (ADAL) i biblioteki MIP:

   using Microsoft.InformationProtection;
   using Microsoft.Identity.Client;
   

4. Set AuthDelegateImplementation to inherit and implement a private variable of and a Microsoft.InformationProtection.IAuthDelegateMicrosoft.InformationProtection.ApplicationInfo constructor that accepts the same type.

   public class AuthDelegateImplementation : IAuthDelegate
   {
      private ApplicationInfo _appInfo;
      // Microsoft Authentication Library IPublicClientApplication
      private IPublicClientApplication _app;
      public AuthDelegateImplementation(ApplicationInfo appInfo)
      {
          _appInfo = appInfo;
      }
   
   }
   

   Obiekt ApplicationInfo ma trzy właściwości. Będzie on używany w klasie do zapewnienia identyfikatora _appInfo.ApplicationIdAuthDelegateImplementation klienta do biblioteki uwierzytelniania. ApplicationName i ApplicationVersion będą one nasuwniane w raportach usługi Azure Information Protection Analytics.

5. Dodaj public string AcquireToken() metodę. Ta metoda powinna być Microsoft.InformationProtection.Identity akceptowana i zawierała trzy ciągi: adres URL urzędu, URI zasobu i oświadczenia, jeśli są wymagane. Te zmienne ciągu zostaną przekazane przez interfejs API do biblioteki uwierzytelniania i nie powinny być modyfikowane. Wprowadź identyfikator GUID dzierżawy z portalu Azure Portal dla swojej dzierżawy. Edytowanie ciągów innych niż identyfikator GUID dzierżawy może spowodować niepowodzenie uwierzytelniania.

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

Implementowanie pełnomocnika zgody

Teraz utwórz implementację pełnomocnika zgody, rozszerzając interfejs zestawu SDK Microsoft.InformationProtection.IConsentDelegate i zastępując/implementując. GetUserConsent() Pełnomocnik zgody jest wystąpienia i używany później przez obiekty Profil pliku i Aparat plików. Pełnomocnik zgody jest podany wraz z adresem usługi, na używanie jej przez użytkownika w url parametrze. Pełnomocnik powinien ogólnie udostępnić przepływ, który umożliwia użytkownikowi zaakceptowanie lub odrzucenie zgody na dostęp do usługi. Aby szybko rozpocząć pracę z kodem Consent.Accept .

1. Używając tej samej Visual Studio "Dodaj zajęcia" użytej wcześniej, dodaj kolejne zajęcia do projektu. Tym razem wprowadź "ConsentDelegateImplementation" w polu Nazwa zajęć.

2. Teraz zaktualizuj consentDelegateImpl.cs, aby zaimplementować nową klasę pełnomocnika zgody. Dodaj instrukcje using dla Microsoft.InformationProtection i ustaw klasę dziedziczącą IConsentDelegate .

   class ConsentDelegateImplementation : IConsentDelegate
   {
        public Consent GetUserConsent(string url)
        {
             return Consent.Accept;
        }
   }
   

3. Opcjonalnie spróbuj utworzyć rozwiązanie, aby zapewnić, że będzie ono kompilowane bez błędów.

Inicjowanie zarządzanego opakowania zestawu SDK MIP

1. W Eksploratorze rozwiązańotwórz plik cs w projekcie, który zawiera implementację metody. Domyślna nazwa jest taka sama jak nazwa projektu zawierającego projekt, która jest określona podczas tworzenia projektu.

2. Usuń wygenerowaną implementację main() programu .

3. Zarządzane zawijanie zawiera klasy statyczne, używane do inicjowania, tworzenia , ładowania profilów Microsoft.InformationProtection.MIPMipContext i zwalniania zasobów. Aby zainicjować zawijanie dla operacji zestawu File SDK, wywołaj pozycję , przechodząc do w celu załadowania bibliotek MIP.Initialize()MipComponent.File niezbędnych do operacji na plikach.

4. W Main()Main() dodaj > następujące dane, zastępując identyfikator aplikacji identyfikatorem utworzonej wcześniej rejestracji aplikacji usługi Azure AD.

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

Konstruowanie profilu pliku i aparatu

Jak wspomniano, obiekty profilu i aparatu są wymagane dla klientów zestawu SDK korzystających z interfejsów API miP. Ukończ kodowanie tej funkcji Szybki start, dodając kod w celu załadowania natywnych bibliotek DLL, a następnie wystąpienia obiektów profilu i aparatu.

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

3. Zamień wartości zastępcze w wklejonym kodzie źródłowym na następujące wartości:

   Symbol zastępczy	Wartość	Przykład
   <application-id>	Identyfikator aplikacji usługi Azure AD przypisany do aplikacji zarejestrowanej w "konfiguracji i konfiguracji zestawu SDK MIP" (2 wystąpienia).	0edbblll-8773-44de-b87c-b8c6276d41eb
   <przyjazna nazwa>	Zdefiniowana przez użytkownika przyjazna nazwa aplikacji.	AppInitialization
   <Identyfikator GUID dzierżawy>	Identyfikator dzierżawy dzierżawy usługi Azure AD	TenantID

4. Teraz wykonaj ostateczną kompilację aplikacji i rozwiąż wszelkie błędy. Kod powinien zostać pomyślnie skompilowany.

Następne kroki

Teraz, gdy kod inicjowania został ukończony, możesz rozpocząć kolejny szybki start, w którym będą dostępne zestawy SDK plików MIP.