ASP .NET Core 3.1 -  Usando Session

Hoje veremos como usar Session em uma aplicação ASP .NET Core MVC 3.1.

O protocolo HTTP é um protocolo sem estado. Por padrão, as requisições HTTP são mensagens independentes que não retêm os valores do usuário.

No entanto, o estado pode ser armazenado usando diversas abordagens e uma delas é usar o Session State.

O estado da sessão é um cenário do ASP.NET Core para armazenamento de dados do usuário enquanto o usuário navega em uma aplicação Web. Ele usa um armazenamento mantido pelo aplicativo para manter os dados nas requisições de um cliente. Os dados da sessão são apoiados por um cache e considerados dados efêmeros. O site deve continuar funcionando sem os dados da sessão.

Obs:Os dados críticos da aplicação devem ser armazenados em um banco de dados e guardados em cache na sessão apenas como uma otimização de desempenho.

Dessa forma a ASP .NET Core mantém o estado da sessão, fornecendo um cookie ao cliente que contém um ID da sessão de cookie que :

De forma geral, o estado da sessão exibe os seguintes comportamentos:

Como configurar a Session

Por padrão o pacote Microsoft.AspNetCore.Session é incluído implicitamente pelo framework e fornece um middleware para gerenciar o estado da sessão.

Para habilitar o middleware da sessão, a Inicialização deve conter:

A seguir veremos um exemplo básico de como usar Session na ASP .NET Core.

recursos usados:

Criando o projeto ASP .NET Core MVC

Vamos criar um novo projeto no VS 2019 Community chamado Aspc_Session1 usando o template :

A seguir selecione o template Web Application(Model-View-Controller) e clique em Create.

Precisamos Incluir no projeto o pacote Newtonsoft.Json para realizar a serialização e deserialização de objetos :

Install-Package Newtonsoft.json

Configurando e habilitando o uso de Session

Para habilitar o uso de Session precisamos incluir no método ConfigureServices o respectivo serviço:

 public void ConfigureServices(IServiceCollection services)
 {
            services.AddDistributedMemoryCache();
            services.AddSession(options =>
            {
                options.IdleTimeout = TimeSpan.FromSeconds(10);
                options.Cookie.HttpOnly = true;
                options.Cookie.IsEssential = true;
            });
            services.AddControllersWithViews();
 }

No código acima estamos habilitando o cache distribuído para melhorar o desempenho e escalabilidade da aplicação.

A seguir habilitamos o session state e definimos em 10 segundos o tempo que a sessão pode ficar ociosa antes que seu conteúdo seja abandonado. (Cada acesso à sessão redefine o tempo limite, e, isso não se aplica ao cookie).

Depois definimos que o cookie poderá ser acessado por scripts do lado do cliente e que ele é essencial para que a aplicação funcione corretamente.

Agora precisamos habilitar o middleware no método Configure incluindo :  app.UseSession();

Finalmente, como vamos precisar injetar a implementação IHttpContextAccessor na view vamos configurar o serviço incluindo no método ConfigureServices :

 public void ConfigureServices(IServiceCollection services)
 {
            services.AddDistributedMemoryCache();
            services.AddSession(options =>
            {
                options.IdleTimeout = TimeSpan.FromSeconds(10);
                options.Cookie.HttpOnly = true;
                options.Cookie.IsEssential = true;
            });

            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
            services.AddControllersWithViews();
 }

Pronto. Já podemos usar a Session em nossa aplicação.

Usando Session no Controller e na View

Vamos incluir na pasta Models a classe User com duas propriedades que iremos usar apenas para mostrar o teste da Sesssion:

    public class User
    {
        public int Id { get; set; }
        public string Nome { get; set; }
    }

A seguir vamos criar na pasta Controllers o controlador UserController que vamos usar para testar a Session.

using Microsoft.AspNetCore.Mvc;

namespace Aspc_Session1.Controllers
{
    public class UserController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

Agora abra o controlador HomeController e inclua o código a seguir:

using Aspc_Session1.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
namespace Aspc_Session1.Controllers
{
    public class HomeController : Controller
    {

        public IActionResult Index()
        {
            HttpContext.Session.SetString("SessionNome", "Macoratti");
            HttpContext.Session.SetInt32("SessionIdade", 54);

            var userInfo = new User()
            {
                Id = 1,
                Nome = "Macoratti"
            };
            HttpContext.Session.SetString("SessionUser", JsonConvert.SerializeObject(userInfo));
            return View();
        }
    }
}

Neste código estamos atribuindo valores às variáveis de sessão SessionNome e SessionIdade usando os métodos SetString e SetInt32.

A seguir criamos uma instância da classe User e atribuímos os valores do objeto userInfo à sessão fazendo a serialização do objeto.

Obtendo os valores da Session

Agora vamos obter da sessão as variáveis e o objeto incluído na sessão na view Index e no controlador UserController.

Abra a view Index.cshtml na pasta Views/Home e inclua o código para obter os valores da Session:

@using Microsoft.AspNetCore.Http
@inject Microsoft.AspNetCore.Http.IHttpContextAccessor HttpContextAccessor
@{
    ViewData["Title"] = "Home Page";
}
    <div class="text-center">
        <h2 class="display-4">Usando Session</h2>
        <hr />
        <h3>Valores obtidos da Session</h3>
        <hr />
        Nome : @HttpContextAccessor.HttpContext.Session.GetString("SessionNome")
        <br />
        Idade : @HttpContextAccessor.HttpContext.Session.GetInt32("SessionIdade")
    </div>

Estamos injetando o serviço IHttpContextAcessor e recuperando da Session os valores que incluímos no controlador HomeController.

Agora no controlador UserController vamos recuperar o objeto userInfo do tipo User:

    public class UserController : Controller
    {
        public IActionResult Index()
        {
            var userInfo = JsonConvert.DeserializeObject<User>
               (HttpContext.Session.GetString("SessionUser"));
            return View(userInfo);
        }
    }

Para exibir o valor recuperado vamos criar a view Index.cshtml na pasta /Views/User :

@model User
<div class="text-center">
    <h2 class="display-4">Usando Session</h2>
    <hr />
    <h3>Valores do objeto do tipo User</h3>
    <hr />
    ID : @Model.Id
    <br />
    Nome : @Model.Nome
</div>

Para executar e testar vamos ajustar o arquivo _Layout.cshtml para exibir o link para acessar a view Index do controlador UserController:

<div class="navbar-collapse collapse d-sm-inline-flex flex-sm-row-reverse">
    <ul class="navbar-nav flex-grow-1">
        <li class="nav-item">
            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
       </li>
      <li class="nav-item">
          <a class="nav-link text-dark" asp-area="" asp-controller="User" asp-action="Index">User</a>
     </li>
   </ul>
</div>

Agora é só alegria...

Vamos executar o projeto e verificar que os valores atribuídos à Session estão sendo recuperados na view e no Controller da aplicação:

Pegue o projeto aqui:  Aspc_Session1.zip  (sem as referências)

"Não vos prendais a um jugo desigual com os infiéis; porque, que sociedade tem a justiça com a injustiça? E que comunhão tem a luz com as trevas?"
2 Coríntios 6:14

Referências:

José Carlos Macoratti