Guia de início rápido: inicialização do aplicativo cliente (C#)

Este quickstart mostra-lhe como implementar o padrão de inicialização do cliente que o wrapper .NET do MIP SDK usa em tempo de execução.

Observação

Qualquer aplicação cliente que utilize os SDKs de Ficheiro, Política ou Proteção do MIP .NET requer seguir os passos descritos neste guia de introdução rápida. Embora este início rápido demonstre o uso dos SDKs de ficheiros, este mesmo padrão aplica-se a clientes que utilizam os SDKs de Política e Protecção. Conclua os próximos guias de início rápido em série, porque cada um se baseia no anterior, sendo este o primeiro deles. Este código destina-se a demonstrar como começar a usar o MIP SDK e não se destina ao uso em produção.

Pré-requisitos

Se ainda não o fez, certifique-se de:

Conclua as etapas na instalação e configuração do SDK do Microsoft Information Protection (MIP). Este Início Rápido de Inicialização do Aplicativo Cliente depende da instalação e configuração adequadas do SDK.
Opcionalmente:
- Revise os objetos do perfil e do mecanismo. Os objetos de perfil e mecanismo são conceitos universais, exigidos por clientes que usam os SDKs de arquivo/política/proteção MIP.
- Revise os conceitos de Autenticação para aprender como o SDK e a aplicação cliente implementam autenticação e consentimento.

Criar uma solução e um projeto do Visual Studio

Primeiro, crie e configure a solução inicial do Visual Studio e o projeto, sobre os quais os outros quickstarts constroem.

Abra o Visual Studio 2022 ou versão posterior, selecione o menu Ficheiro , Novo, Projeto. Na caixa de diálogo Novo projeto :
- No painel esquerdo, em Instalado, Visual C#, selecione Área de Trabalho do Windows.
- No painel central, selecione Aplicação de Consola (destinada ao .NET 8 ou posterior).
- No painel inferior, atualize o nome do projeto, o local e o nome da solução que o contém de acordo.
- Quando terminar, clique no botão OK no canto inferior direito.
Adicione o pacote NuGet para o SDK de arquivo MIP ao seu projeto:
- No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto (diretamente abaixo do nó superior/solução) e selecione Gerenciar pacotes NuGet...:
- Quando a guia Gerenciador de Pacotes NuGet é aberta na área de guias Grupo de Editores:
  - Selecione Procurar.
  - Digite "Microsoft.InformationProtection" na caixa de pesquisa.
  - Selecione o pacote "Microsoft.InformationProtection.File".
  - Clique em "Instalar" e, em seguida, clique em "OK" quando a caixa de diálogo de confirmação de alterações de visualização for exibida.
Repita as etapas acima para adicionar o pacote MIP File SDK, mas em vez disso, adicione "Microsoft.Identity.Client" ao aplicativo.

Implementar um delegado de autenticação

O SDK MIP implementa a autenticação através da extensibilidade de classes, que fornece um mecanismo para partilhar o trabalho de autenticação com a aplicação cliente. O cliente deve adquirir um token de acesso OAuth2 adequado e fornecê-lo ao MIP SDK em tempo de execução.

Agora crie uma implementação para um delegado de autenticação estendendo a interface do Microsoft.InformationProtection.IAuthDelegate SDK e sobrescrevendo ou implementando a IAuthDelegate.AcquireToken() função virtual. Os objetos FileProfile e FileEngine instanciam e usam posteriormente o delegado de autenticação.

Clique com o botão direito do mouse no nome do projeto no Visual Studio, selecione Adicionar e depois Classe.
Digite "AuthDelegateImplementation" no campo Nome . Clique em Adicionar.
Adicione declarações 'using' para a Biblioteca de Autenticação da Microsoft (MSAL) e a biblioteca MIP.
```
using Microsoft.InformationProtection;
using Microsoft.Identity.Client;
```
Defina AuthDelegateImplementation para herdar Microsoft.InformationProtection.IAuthDelegate e implementar uma variável privada de Microsoft.InformationProtection.ApplicationInfo e um construtor que aceite o mesmo tipo.
```
public class AuthDelegateImplementation : IAuthDelegate
{
   private ApplicationInfo _appInfo;
   // Microsoft Authentication Library IPublicClientApplication
   private IPublicClientApplication _app;
   public AuthDelegateImplementation(ApplicationInfo appInfo)
   {
       _appInfo = appInfo;
   }

}
```
O ApplicationInfo objeto contém três propriedades. A classe AuthDelegateImplementation utiliza _appInfo.ApplicationId para fornecer o ID do cliente à biblioteca de autenticação. ApplicationNamee ApplicationVersion aparecem nos relatórios de auditoria da Microsoft Purview.

Adicione o método public string AcquireToken(). Esse método deve aceitar Microsoft.InformationProtection.Identity e três cadeias de caracteres: URL de autoridade, URI de recurso e declarações, se necessário. A API passa estas variáveis string para a biblioteca de autenticação, e não deves manipulá-las. Introduza o GUID do tenant no portal do Azure correspondente ao seu tenant. Editar strings que não sejam o GUID do tenant pode resultar numa falha de autenticação.

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

Agora, crie uma implementação para um delegado de consentimento, estendendo a interface Microsoft.InformationProtection.IConsentDelegate do SDK e substituindo ou implementando GetUserConsent(). O perfil de ficheiro e os objetos do motor de ficheiros instanciam e usam o delegado de consentimento mais tarde. O delegado de consentimento recebe o endereço do serviço que o utilizador deve consentir usar no url parâmetro. O delegado deve geralmente fornecer um fluxo que permita ao utilizador aceitar ou rejeitar o consentimento para aceder ao serviço. Para este guia de iniciação rápida, defina Consent.Accept diretamente no código.

Usando o mesmo recurso "Adicionar classe" do Visual Studio que usamos anteriormente, adicione outra classe ao seu projeto. Desta vez, digite "ConsentDelegateImplementation" no campo Nome da classe .
Agora atualize ConsentDelegateImpl.cs para implementar sua nova classe de delegado de consentimento. Adicione a instrução using para Microsoft.InformationProtection e defina a classe para herdar IConsentDelegate.
```
class ConsentDelegateImplementation : IConsentDelegate
{
     public Consent GetUserConsent(string url)
     {
          return Consent.Accept;
     }
}
```
Opcionalmente, tente criar a solução para garantir que ela seja compilada sem erros.

Inicializar o wrapper gerenciado do MIP SDK

No Gerenciador de Soluções, abra o arquivo de .cs em seu projeto que contém a Main() implementação do método. Por predefinição, usa o mesmo nome que o projeto que o contém, especificado durante a criação do projeto.
Remova a implementação gerada do main().
O wrapper gerenciado inclui uma classe estática, Microsoft.InformationProtection.MIP usada para inicialização, criação de um MipContext, carregando perfis e liberando recursos. Para inicializar o wrapper para operações com o SDK de Arquivos, chame MIP.Initialize(), passando MipComponent.File para carregar as bibliotecas necessárias para operações com ficheiros.
Em Main()Program.cs adicione o seguinte, substituindo <application-id> pela ID do Registro de Aplicativo Microsoft Entra criado 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);
            
        }
    }
}

Construir um perfil de arquivo e um motor

Como mencionado, os clientes SDK que usam APIs MIP requerem objetos de perfil e motor. Complete a parte de programação deste quickstart adicionando código para carregar as DLLs nativas e depois instanciando os objetos de perfil e do 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;
       }
  }
}

Substitua os valores provisórios no código-fonte que colou usando os seguintes valores:

Placeholder	Valor	Example
<ID do aplicativo>	O ID da aplicação Microsoft Entra atribuído à aplicação registada em "configuração e instalação do MIP SDK" (2 instâncias).	00001111-aaaa-2222-bbbb-3333cccc444
<nome-amigável>	Um nome amigável definido pelo usuário para seu aplicativo.	Inicialização da Aplicação
<Tenant-GUID>	ID de inquilino para o seu inquilino Microsoft Entra.	ID do locatário

Agora faça uma compilação final do aplicativo e resolva quaisquer erros. O seu código deve ser construído com sucesso.

Passos seguintes

Agora que o seu código de inicialização está completo, está pronto para o próximo quickstart, onde começa a experienciar os SDKs de ficheiros MIP.

Listar rótulos de sensibilidade

Comentários

Esta página foi útil?

Last updated on 2026-09-21