ASP .NET Core -  Dicas de desempenho

Neste artigo veremos algumas dicas para aumentar o desempenho das aplicações ASP .NET Core.

O desempenho é muito importante; é um fator importante para o sucesso de qualquer aplicação web. As novas versões da ASP.NET Core 3.0 incluíram vários aprimoramentos que reduzem o uso de memória e melhoram a o desempenho.

A seguir veremos algumas orientações para usar esses recursos baseadas na documentação da Microsoft:
(fonte: https://docs.microsoft.com/pt-br/aspnet/core/performance/performance-best-practices?view=aspnetcore-3.1)

1- Prefira usar chamadas assíncronas

Tente evitar chamadas síncronas ao desenvolver aplicativos ASP.NET Core. A chamada síncrona bloqueia a próxima execução até que a execução atual seja concluída. Ao buscar dados de uma API ou executar operações como operações de entrada e saída (E/S) ou chamada independente, execute a chamada de maneira assíncrona.

Assim todas as chamadas a API com acesso a dados devem ser assíncronas.

Evite usar Task.Wait e Task.Result e tente usar await.

Assim evite usar o código abaixo que usa uma chamada síncrona:

public class BadStreamReaderController : Controller
{
    [HttpGet("/contoso")]
    public ActionResult<ContosoData> Get()
    {
        var json = new StreamReader(Request.Body).ReadToEnd();

        return JsonSerializer.Deserialize<ContosoData>(json);
    }
}

E prefira usar este código assíncrono:

public class GoodStreamReaderController : Controller
{
    [HttpGet("/contoso")]
    public async ActionResult<ContosoData> Get()
    {
        var json = await new StreamReader(Request.Body).ReadToEnd();

        return JsonSerializer.Deserialize<ContosoData>(json);
    }
}

Neste exemplo não existe o bloqueio da thread durante a leitura dos dados.

2- Utilize consulta assíncronas

As consultas assíncronas evitam o bloqueio de uma thread enquanto a consulta é executada no banco de dados. As consultas assíncronas são importantes para aplicativos clientes rápidos e responsivos.

Exemplos:  ToListAsync(), ToArrayAsync(), SingeAsync()

public async Task<List> GetBlogsAsync()
{
    using (var context = new BloggingContext())
    {
        return await context.Blogs.ToListAsync();
    }
}

3-  Salve dados de forma assíncrona

O salvamento assíncrono evita um bloqueio na thread enquanto as alterações são gravadas no banco de dados. Ao usar o EF Core temos acesso ao método DbContext.SaveChangesAsync() como uma alternativa assíncrona ao método síncrono DbContext.SaveChanges().

public static async Task AddBlogAsync(string url)
{
    using (var context = new BloggingContext())
    {
        var blogContent = new BlogContent { Url = url };
        context.Blogs.Add(blogContent);
        await context.SaveChangesAsync();
    }
}

4- Procure otimizar o acesso aos dados

Procure melhorar o desempenho de uma aplicação, otimizando sua lógica de acesso a dados. A maioria dos aplicativos depende totalmente de um banco de dados. Eles precisam buscar dados do banco de dados, processar os dados e exibi-los. Se este for um processo demorado, o aplicativo levará muito mais tempo para carregar.

Algumas recomendações para otimizar a lógica de acesso a dados:

5- Use o cache

Podemos aumente o desempenho de uma aplicação reduzindo o número de solicitações para o servidor. Evite requisições para o servidor toda vez e armazene em cache os dados. Armazene a resposta para o futuro e use-a na próxima vez em que fizer um request para a mesma resposta.

A seguir algumas técnicas de armazenamento em cache:

6- Use a serialização JSON

A partir da ASP .NET Core 3.0 podemos usar o namespace System.Text.Json para serialização JSON por padrão. Agora, você pode ler e gravar JSON de forma assíncrona obtendo um melhor desempenho do que usar o pacote Newtonsoft.Json.  Este pacote oferece os seguintes recursos para processamento JSON:

- Alta performance;
- Alocação baixa;
- Recursos compatíveis com padrões;
- Serialização de objetos para texto JSON e desserialização de texto JSON para objetos;

7- Reduza as requisições HTTP

Reduzir o número de requisições HTTP é uma das principais otimizações. Coloque em cache as páginas da web e evite redirecionamentos do lado do cliente para reduzir o número de conexões feitas com o servidor da web.

Use as seguintes técnicas para reduzir as solicitações HTTP:

- Use minificação.
- Use agrupamento.
- Use imagens sprite.

Reduzindo  as requisições HTTP, essas técnicas ajudam as páginas a carregar mais rapidamente.

8- Lance exceções somente quando necessário

Exceções devem ser raras. Lançar e capturar exceções consumirá mais tempo em relação a outros padrões de fluxo de código. Assim procure não criar e capturar exceções no fluxo normal do programa e use exceções somente quando forem necessárias.

 Recomendações:

9- Use a compactação do response

A compactação de resposta, que compacta o tamanho de um arquivo, é outro fator para melhorar o desempenho. Na ASP.NET Core, a compactação de resposta está disponível como um componente de middleware.

Geralmente, as respostas não são compactadas nativamente. Isso geralmente inclui CSS, JavaScript, HTML, XML e JSON.

Obs: O pacote Microsoft.AspNetCore.ResponseCompression é implicitamente incluído nas aplicações ASP .NET Core.

O trecho de código a seguir mostrar um exemplo de como habilitar o middleware de compressão de resposta para os tipos MIME padrão  e os provedores de compressão :

 public class Startup
 {
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddResponseCompression();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        app.UseResponseCompression();
    }
 }

Os provedores são:

public void ConfigureServices(IServiceCollection services)
{
    services.AddResponseCompression(options =>
    {
        options.Providers.Add<BrotliCompressionProvider>();
        options.Providers.Add<GzipCompressionProvider>();
        options.Providers.Add<CustomCompressionProvider>();
        options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
                new[] { "image/svg+xml" });
    });
}

10- Use os novos recursos de acessabilidade HttpContext

A acessibilidade do HttpContext é válida apenas desde que haja uma solicitação HTTP ativa na ASP.NET Core.

A seguir vou deixar o link de algumas sugestões para acessar o HttpContext na documentação da Microsoft de forma a otimizar o desempenho da aplicação:

Essas são algumas recomendações que vão aumentar o desempenho da sua aplicação ASP .NET Core.

E estamos conversados.

"(Disse Jesus) Ainda um pouco, e o mundo não me verá mais, mas vós me vereis; porque eu vivo, e vós vivereis."
João 14:19

Referências:

José Carlos Macoratti