Início rápido: inicialização do aplicativo cliente para SDKs de proteção (C#)

Esse início rápido mostra como implementar o padrão de inicialização do cliente, usado pelo wrapper .NET do SDK da PIM em tempo de execução.

Observação

As etapas descritas neste início rápido são necessárias para todo aplicativo cliente que usa o SDK de Proteção do wrapper .NET da PIM. Esse Início rápido deve ser feito em série após a inicialização do aplicativo e a implementação das classes de representante de autenticação e consentimento.

Pré-requisitos

Caso ainda não tenha feito, faça o seguinte:

• Conclua as etapas em Instalação e configuração do SDK da PIM (Proteção de Informações da Microsoft). Esse início rápido "Configuração de perfil de proteção e mecanismo" depende da instalação e configuração adequadas do SDK.
• Se desejar:
  • Examine o Perfil e os objetos do mecanismo. O perfil e os objetos do mecanismo são conceitos universais, exigidos por clientes que usam os SDKs de Arquivo, Políticas e Proteção da PIM.
  • Examine os Conceitos de autenticação para saber como a autenticação e o consentimento são implementados pelo aplicativo cliente e o SDK.

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

Primeiro, criamos e configuramos a solução e o projeto iniciais do Visual Studio, nos quais os outros inícios rápidos serão baseados.

1. Abra o Visual Studio 2017, selecione o menu Arquivo, 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 Aplicativo de Console (.NET Framework)

   • No painel inferior, atualize corretamente o Nome e a Localização do projeto e o Nome da solução que o contém.

   • Ao terminar, clique no botão OK, no canto inferior direito.

     

2. Adicione o pacote Nuget do SDK de Arquivos da PIM ao seu projeto:

   • No Gerenciador de Soluções, clique com o botão direito do mouse sobre o nó do projeto (logo abaixo do nó superior/da solução) e selecione Gerenciar pacotes NuGet...:
   • Quando a guia Gerenciador de Pacotes NuGet for aberta na área de guias do Grupo do Editor:
     • Selecione Procurar.
     • Insira "Microsoft.InformationProtection" na caixa de pesquisa.
     • Selecione o pacote "Microsoft.InformationProtection.File".
     • Clique em "Instalar", depois clique em "OK" quando a caixa de diálogo de confirmação Visualizar alterações for exibida.

3. Repita as etapas acima para adicionar o pacote do SDK da PIM, mas, em vez disso, adicione "Microsoft.IdentityModel.Clients.ActiveDirectory" ao aplicativo.

Implementar um representante de autenticação e um representante de consentimento

Se ainda não tiver sido implementado, siga as etapas listadas na inicialização do aplicativo do SDK de arquivo para implementar o representante de consentimento e autenticação.

Inicializar o wrapper gerenciado do SDK da PIM

1. No Gerenciador de Soluções, abra o arquivo .cs no projeto que contém a implementação do método Main(). Ele usa como padrão o mesmo nome que o projeto em que está contido, que você especificou durante a criação do projeto.

2. Remova a implementação gerada de main().

3. O wrapper gerenciado inclui uma classe estática, Microsoft.InformationProtection.MIP, usada para inicialização, criando um MipContext, carregando perfis e liberando recursos. Para inicializar o wrapper para operações do SDK do arquivo, chame MIP.Initialize(), passando MipComponent.Protection para carregar as bibliotecas necessárias para operações de proteção.

4. Em Main() em Program.cs, adicione o seguinte, substituindo <application-id> pela ID do Registro de Aplicativo do Microsoft Entra criado anteriormente.

using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.Exceptions;
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 Protection SDK operations
            MIP.Initialize(MipComponent.Protection);
        }
    }
}

Construir um perfil de proteção e um mecanismo

Como já foi mencionado, os objetos Perfil e Mecanismo são necessários para os clientes do SDK que usam as APIs da PIM. Conclua a parte de codificação deste início rápido, adicionando código para carregar as DLLs nativas e então instanciar os objetos perfil e mecanismo.

using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.Exceptions;
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 Protection SDK operations.
               MIP.Initialize(MipComponent.Protection);

               // 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 = MIP.CreateMipContext(mipConfiguration);
                
               // Initialize and instantiate the ProtectionProfile.
               // Create the ProtectionProfileSettings object.
               // Initialize protection profile settings to create/use local state.
               var profileSettings = new ProtectionProfileSettings(mipContext,
                                        CacheStorageType.OnDiskEncrypted,                                        
                                        new ConsentDelegateImplementation());

               // Load the Profile async and wait for the result.
               var protectionProfile = Task.Run(async () => await MIP.LoadProtectionProfileAsync(profileSettings)).Result;

               // Create a ProtectionEngineSettings object, then use that to add an engine to the profile.
               var engineSettings = new ProtectionEngineSettings("user1@tenant.com", authDelegate, "", "en-US");
               engineSettings.Identity = new Identity("user1@tenant.com");
               var protectionEngine = Task.Run(async () => await protectionProfile.AddEngineAsync(engineSettings)).Result;

               // Application Shutdown
               // handler = null; // This will be used in later quick starts.
               protectionEngine = null;
               protectionProfile = null;
               mipContext = null;
          }
     }
}

3. Substitua os valores de espaço reservado no código-fonte que você colou, usando os seguintes valores:

   Espaço reservado	Valor	Exemplo
   <application-id>	ID de Aplicativo do Microsoft Entra atribuída ao aplicativo registrado na "Instalação e configuração do SDK da PIM" (2 instâncias).	0edbblll-8773-44de-b87c-b8c6276d41eb
   <friendly-name>	Um nome amigável definido pelo usuário para o seu aplicativo.	AppInitialization

4. Agora, faça uma compilação final do aplicativo e resolva todos os erros. Seu código deve ser compilado com sucesso.

Próximas etapas

Agora que o código de inicialização está concluído, você está pronto para o próximo guia de início rápido, em que começará a experimentar os SDKs de Proteção da PIM.

Listar modelos de proteção