ASP .NET Core - Usando o ASP .NET Core Identity - II


Neste artigo vou mostrar como usar ASP .NET Core Identity e a autenticação baseada em Claims e como implementá-la em uma aplicação ASP .NET Core 2.0.

Na primeira parte do artigo apresentamos a ASP.NET Core Identity e como ela funciona de forma bem resumida.

Vamos agora criar um projeto ASP .NET Core vazio e implementar a ASP .NET Core Identity na prática passo a passo.

Recursos usados:

Criando o projeto ASP .NET Core

Abra o VS 2017 Community e crie um novo projeto selecionando o template Web -> ASP .NET Web Application e informe o nome AspNetCore_Identity;

A seguir selecione o template Empty sem autenticação e clique no botão OK;

Temos assim nosso projeto criado vazio conforme mostrado abaixo:



Como vemos não temos muito conteúdo em um projeto vazio. Vamos nos ater aos dois arquivos :

Abrindo o arquivo Statup.cs temos o seguinte código:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
namespace AspNetCore_Identity
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
        }
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        }
    }
}

O método ConfigureServices é usado para configurar os diferentes serviços como Entity Framework, Identity, etc usados na aplicação.

O método Configure é usado para configurar o pipeline de tratamento das requisições usando um middleware.

Durante o desenvolvimento da nossa aplicação estaremos fazendo mudanças em ambos os métodos.

Outra coisa interessante sobre o ASP.NET Core 2.0 é que ele possui um arquivo .csproj em vez de um arquivo project.json. Você pode abrir o arquivo .csproj clicando com o botão direito do mouse sobre o nome do projeto no Solution Explorer e a seguir clicar em Edit (ProjectName) .csproj.



Se abrimos o arquivo .csproj, veremos que o metapackage Microsoft.AspNetCore.All está referenciado.

Todos os pacotes nuget necessários para ASP.NET Core 2.x e Entity Framework Core 2.x estão incluídos no pacote Microsoft.AspNetCore.All.

Aplicações ASP.NET Core 2.0 agora referenciam um único pacote Microsoft.AspNetCore.All para incluir todos os pacotes ASP.NET Core com a versão do produto. Isso faz com que o arquivo .csproj seja pequeno e limpo. É uma maneira mais fácil de incluir todas as referências dos pacotes da ASP.NET Core sem se preocupar com suas diferentes versões.

O assembly de referência primária para o sistema Identity é o pacote Microsoft.AspNetCore.Identity. Este pacote contém o conjunto básico de interfaces para ASP.NET Core Identity.

As seguintes dependências são necessárias para usar o sistema de identidade em aplicativos ASP.NET Core:

Preparando os Modelos (Models)

O namespace Microsoft.AspNetCore.Identity define os seguintes modelos para gerenciamento de usuários:

IdentityUser
IdentityRole
IdentityUserRole
IdentityUserClaim
IdentityUserLogin
IdentityUserToken
IdentityRoleClaim


Podemos usar essas classes diretamente em nosso aplicação, como podemos também definir nossa própria classe e herdar dessas classes.

Vamos estender a classe IdentityUser e adicionar as propriedades nome e sobrenome neste modelo.

Para fazer isso, vamos adicionar uma pasta Models (Project->New Folder) no projeto e a seguir criar uma classe(Project-> Add Class) chamada ApplicationUser que herda da classe IdentityUser com o seguinte código:

    public class ApplicationUser : IdentityUser
    {
       public string Nome { get; set; }
       public string Sobrenome { get; set; }
    }

Podemos notar que a classe ClaimsPrincipal possui uma propriedade Identities que retorna a coleção de ClaimsIdentity. Isso significa que um Usuário pode ter múltiplas identidades.

Preparando o Entity Framework

A ASP.NET Core Identity vem com o pacote Entity Framework Core Identity, que possui uma implementação do EF Core para armazenar as informações do usuário no banco de dados do SQL Server.

O namespace Microsoft.AspNetCore.Identity.EntityFrameworkCore implementa a classe IdentityDbContext<TUser> que herda de DbContext. Esta classe fornece os DbSets prontos para todos os modelos de identidade. (DbContext representa o banco de dados e DbSets representam as tabelas)

Assim, podemos criar a classe ApplicationDbContext que herda de IdentityDbContext<ApplicationUser>.

Vamos adicionar uma pasta denominada Data ao projeto e criar uma classe chamada ApplicationDbContext nesta pasta com o código a seguir:

using AspNetCore_Identity.Models;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
namespace AspNetCore_Identity.Data
{
    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        { }
        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);
        }
    }
}

Definindo a string de conexão com o SQL Server

Antes de iniciar a configuração dos serviçoes vamos definir a string de conexão com o banco de dados SQL Server que iremos criar no projeto. Fazemos isso no arquivo appsettings.json.

Como não temos esse arquivo no projeto vamos criá-lo. No menu Project clique em Add New Item;

A seguir selecione o template JSON File e informe o nome appsettings.json:

Abra o arquivo appsettings.json e inclua o código a seguir:

{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=MACORATTI;Initial Catalog=DemoIdentity;Integrated Security=True"
  }
}

Neste código estou definindo uma string de conexão com o servidor MACORATTI e o banco de dados DemoIdentity, que será criado em nosso projeto.

Nota: Você deve usar a string de conexão do seu servidor e pode também dar outro nome para o banco de dados.

Preparando o serviço e o Middleware

Na etapa anterior, parece que não usamos a string de conexão na classe ApplicationDbContext. Em vez disso, injetamos DbContextOptions usando a Injeção de Dependência. Dessa forma agora devemos configurar isso no método ConfigureServices da classe Startup. 

O método ConfigureServices é opcional; mas, se usado, é chamado antes do método Configure pelo host. O host pode configurar alguns serviços antes que os métodos de Inicialização sejam chamados. Por convenção, as opções de configuração são definidas neste método.

Para recursos que requerem uma configuração substancial, existem métodos de extensão Add[Service] no IServiceCollection.

Outra coisa importante que temos a fazer é configurar os serviços relacionados ao ASP.NET Core Identity para a injeção de dependência.

Para isso abra a classe Startup e inclua o código abaixo no método ConfigureServices:

using AspNetCore_Identity.Data;
using AspNetCore_Identity.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
namespace AspNetCore_Identity
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        public IConfiguration Configuration { get; }
        public void ConfigureServices(IServiceCollection services)
        {
           services.AddDbContext<ApplicationDbContext> (options =>
                              options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
           services.AddIdentity<ApplicationUser,IdentityRole>()
                                                      .AddEntityFrameworkStores<ApplicationDbContext>()
                                                      .AddDefaultTokenProviders();
        }
       .....
    }
}

Registramos o contexto representando por ApplicationDbContext como um serviço em IServiceCollection e configuramos o contexto para se conectar com o SQL Server usando a string de conexão definida no arquivo appsettings com o nome de DefaultConnection.

A seguir incluímos o sistema de configuração padrão do Identity para o ApplicationUser e os perfis definidos em IdentityRole.

Também incluimos uma implementação do Entity Framework para o armazenamento da informação do Identity usando os provedores padrão.

Com tudo isso já configurado podemos agora definir o middleware do Identity para usar os seus recursos. Fazemos isso incluindo o código abaixo no método Configure:

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.UseAuthentication();
            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }

O recurso Identity está habilitado para o aplicativo chamando o middleware app.UseAuthentication() que adiciona uma autenticação baseada em cookie ao pipeline de solicitação.

Aproveitamos também para incluir um serviço MVC usando o middleware app.UseMvc() e definindo uma rota padrão que aciona o método Action Index do controlador Home.

Na próxima parte do artigo veremos como configurar o ambiente para usar o Migrations a assim criamos o banco de dados e as tabelas para o nosso projeto.

"E estava ali um homem que, havia trinta e oito anos, se achava enfermo.Jesus disse-lhe: Levanta-te, toma o teu leito, e anda.Logo aquele homem ficou são; e tomou o seu leito, e andava. E aquele dia era sábado."
João 5:5-9

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:


José Carlos Macoratti