Forem: Henrique Mauri

Aplicando o padrão Result em APIs com o .NET 9.0

Henrique Mauri — Wed, 05 Feb 2025 13:36:41 +0000

O uso do padrão Result em APIs melhora a manutenção do código e padroniza o retorno de operações. Com o .NET 9.0, podemos estruturar nossas APIs para lidar com sucesso, erros de negócio e falhas inesperadas de forma elegante.

O Que é o Padrão Result?

O padrão Result encapsula o resultado de uma operação, permitindo que seja retornado um objeto contendo:

Sucesso com um valor

Erro de negócio (exemplo: dados inválidos)

Falha inesperada (exemplo: exceções)

Isso evita o uso excessivo de exceções e melhora a previsibilidade do código.

Implementando o Padrão Result

Vamos começar definindo uma classe genérica Result:

public class Result<T>
{
    public bool IsSuccess { get; }
    public T? Value { get; }
    public string? ErrorMessage { get; }

    private Result(T value)
    {
        IsSuccess = true;
        Value = value;
    }

    private Result(string errorMessage)
    {
        IsSuccess = false;
        ErrorMessage = errorMessage;
    }

    public static Result<T> Success(T value) => new(value);
    public static Result<T> Failure(string errorMessage) => new(errorMessage);
}

Agora podemos usar essa estrutura nos serviços da nossa API.

Aplicando o Padrão em um Service

Crie um serviço que usa Result:

public class UserService
{
    private readonly Dictionary<int, string> _users = new()
    {
        { 1, "Henrique" },
        { 2, "Marta" }
    };

    public Result<string> GetUserById(int id)
    {
        if (!_users.TryGetValue(id, out var user))
        {
            return Result<string>.Failure("Usuário não encontrado.");
        }
        return Result<string>.Success(user);
    }
}

Integrando o Padrão Result em um Controller

Agora usamos esse serviço em um **controller **no ASP.NET Core 9.0:

[ApiController]
[Route("api/users")]
public class UsersController : ControllerBase
{
    private readonly UserService _userService = new();

    [HttpGet("{id}")]
    public IActionResult GetUser(int id)
    {
        var result = _userService.GetUserById(id);

        if (!result.IsSuccess)
        {
            return NotFound(new { error = result.ErrorMessage });
        }

        return Ok(new { user = result.Value });
    }
}

Exemplo de Requisição e Resposta

Requisição:

GET /api/users/1

Resposta (200 OK):

{
    "user": "Henrique"
}

Caso não encontre:

GET /api/users/99

Resposta (404 Not Found):

{
    "error": "Usuário não encontrado."
}

Melhorando com Tipos de Erro

Podemos adicionar uma classe de erros mais detalhada:

public class Error
{
    public string Code { get; }
    public string Message { get; }

    public Error(string code, string message)
    {
        Code = code;
        Message = message;
    }
}

Agora alteramos Result para incluir um objeto Error:

public class Result<T>
{
    public bool IsSuccess { get; }
    public T? Value { get; }
    public Error? Error { get; }

    private Result(T value)
    {
        IsSuccess = true;
        Value = value;
    }

    private Result(Error error)
    {
        IsSuccess = false;
        Error = error;
    }

    public static Result<T> Success(T value) => new(value);
    public static Result<T> Failure(string code, string message) => new(new Error(code, message));
}

Agora podemos usar códigos de erro mais descritivos:

public Result<string> GetUserById(int id)
{
    if (!_users.TryGetValue(id, out var user))
    {
        return Result<string>.Failure("USER_NOT_FOUND", "Usuário não encontrado.");
    }
    return Result<string>.Success(user);
}

E o controller agora responde de forma mais estruturada:

[HttpGet("{id}")]
public IActionResult GetUser(int id)
{
    var result = _userService.GetUserById(id);

    if (!result.IsSuccess)
    {
        return NotFound(new { errorCode = result.Error!.Code, message = result.Error.Message });
    }

    return Ok(new { user = result.Value });
}

Resposta agora:

{
    "errorCode": "USER_NOT_FOUND",
    "message": "Usuário não encontrado."
}

Conclusão

O uso do padrão Result no .NET 9.0 melhora a previsibilidade do código e evita o uso excessivo de exceções. Ele permite um tratamento estruturado de sucesso e falhas, deixando o código mais limpo e manutenção mais simples.

Se você já usa esse padrão ou tem dúvidas, deixe um comentário!

HttpClientFactory no .NET 8

Henrique Mauri — Fri, 22 Dec 2023 10:59:09 +0000

Reaproveitamento dos pools de conexões, reduzindo o consumo de recursos do socket, este é o resumo da utilização do HttpClientFactory no .NET.

Introdução

Não saber utilizar corretamente o HttpClient no .NET é um erro clássico, como criar várias instâncias no projeto, isso causa um acúmulo de utilização de sockets, aumentando o consumo de processamento e o famoso memory leak.

A criação de uma instância HttpClient cria internamente uma cadeia HttpMessageHandler, que é responsável por estabelecer uma conexão. Portanto, quando descartamos o HttpClient, na verdade descartamos o HttpMessageHandler, que acabará fechando a conexão. O risco é que a conexão não seja fechada assim que o cliente for descartado.

Uma solução para o problema acima era ter uma única instância de um HttpClient que seria compartilhada em toda aplicação.

Mas, o problema em utilizar uma única instância na solução é que as conexões seriam mantidas abertas e reutilizadas para sempre e quaisquer alterações de DNS feitas nos serviços remotos não seriam respeitadas.

Isso faria com que a aplicação apontassem para instâncias de servidor offline ou ambientes incorretos.

Apresentando a HttpClientFactory

O HttpClientFactory foi introduzido com .NETCore 2.1.
O HttpClientFactory nos dá um local central para configurar e criar HttpClients.
Ele gerencia o tempo de vida das cadeias HttpMessageHandler subjacentes. Ele faz isso gerenciando um pool desses MessageHandlers e mantendo-os abertos até que expirem.
Os MessageHandlers são mantidos ativos por no máximo 2 minutos.
O uso é simples e requer mudanças mínimas de código em sua aplicação.
Apenas chamar o método de extensão AddHttpClient no IServiceCollection oferece as vantagens do gerenciamento de instâncias pronto para uso.
Ele permite que você injete o HttpClientFactory em qualquer lugar da sua aplicação.

Exemplo de utilização do HttpClientFactory

O código abaixo é um exemplo de utilização do HttpClientFactory com o Polly, onde trabalharemos a resiliência.

public static class HttpClientCollectionEExtension
    {
        public static void ConfigureHttpClientService(this IServiceCollection services, IConfiguration configuration)
        {
            var retryPolicy = Policy
                .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode && r.StatusCode != HttpStatusCode.BadRequest)
                .WaitAndRetryAsync(new[]
                {
                    TimeSpan.FromSeconds(1),
                    TimeSpan.FromSeconds(3),
                    TimeSpan.FromSeconds(6)
                });

            services.AddHttpClient("taxa", c =>
            {
                c.BaseAddress = new Uri($"{configuration.GetSection("UrlApiTaxa").Value}");

                c.DefaultRequestHeaders.Add("Connection", "Keep-Alive");
                c.DefaultRequestHeaders.Add("Keep-Alive", "3600");
                c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");

            }).AddPolicyHandler(retryPolicy);
        }
    }

Depois de ser registrado em seu startup.cs, agora precisamos consumir este HttpClient, conforme o código de exemplo abaixo:

public class TaxaJurosExternalClient : ITaxaJurosExternalClient
    {
        public readonly IHttpClientFactory _factory;

        public TaxaJurosExternalClient(IHttpClientFactory factory)
        {
            _factory = factory;
        }

        public async Task<double> GetTaxaJuros()
        {
            var client = _factory.CreateClient("taxa");

            var result = await client.GetAsync("Get");

            var resultContent = await result.Content.ReadAsStringAsync();

            var resultObject = JsonSerializer.Deserialize<TaxaJurosOutput>(resultContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

            return resultObject.Taxa;

        }
    }

Repare que nenhuma instância do HttpClient foi criado, simplesmente é reutilizado da nossa configuração no startup.cs, o que deixa seu código muito mais performático e organizado.

O exemplo completo de utilização do HttpClientFactory com o Polly, você confere no link abaixo:

https://github.com/hgmauri/sample-httpclientfactory-polly

Azure SignalR no .NET 8

Henrique Mauri — Wed, 13 Dec 2023 18:42:16 +0000

O SignalR é uma biblioteca open source da Microsoft criada em 2011 por Damian Edwards e David Fowler, com a finalidade de facilitar a implementação de aplicações que demandam funcionalidades em tempo real.  Essa funcionalidade permite que o código do lado do servidor envie conteúdo aos clientes instantaneamente.

Um exemplo clássico de utilização do SignalR é o chat, onde um cliente envia mensagem para outro cliente em tempo real, passando pelo servidor SignalR, que faz o papel de hub entre as duas conexões, trabalhando como uma classe que fornece endpoints que tornam o envio e o recebimento de mensagens em tempo real possível.

Neste artigo utilizaremos o Azure SignalR como serviço em um projeto .NET 8.

Configurando o SignalR no Azure

Os maiores benefícios em utilizar o SignalR no Azure são: escalabilidade, balanceamento de carga e baixa latência, deixando seu ambiente muito mais transparente, robusto e confiável.

Nosso primeiro passo é preparar e configurar o SignalR no Azure, clicando no serviço informado conforme imagem abaixo:

Em seguida, é necessário configurar os dados básicos da instalação. Neste exemplo utilizaremos a região sul do Brasil para instalar nosso servidor de socket:

Utilizaremos o tipo de serviço Default com o plano Standard do SignalR, esse plano é ideal para produção, pelo principal fato de contar com SLA de 99.9%. Em média, o valor mensal para esse serviço gira em torno de R$ 250,00, o que é muito barato, por exemplo, para uma infraestrutura com várias aplicações.

Logo depois da instalação, é necessário copiar a connection string, que será utilizada na nossa codificação .NET:

Configurando o SignalR no .NET 8

Para entender melhor como o SignalR funciona, utilizaremos três projetos:

SignalR.Socket.Server: Projeto principal utilizado como servidor socket, nele fica configurado o Azure SignalR e nossos hubs.
**SignalR.Socket.Receive: Projeto responsável por receber notificações que passam pelo SignalR.
SignalR.Socket.Sender: Projeto de exemplo de envio de mensagens de uma ponta à outra.

No projeto Server é necessário instalar o pacote Microsoft.Azure.SignalR e configurar nosso startup.cs com a connection string do Azure SignalR

public class Startup
{
    const string CORS_SIGNALR_POLICY_NAME = "signalr";
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSignalR(options =>
        {
            options.KeepAliveInterval = TimeSpan.FromMinutes(20);
            options.ClientTimeoutInterval = TimeSpan.FromMinutes(40);
            options.HandshakeTimeout = TimeSpan.FromMinutes(5);
            options.MaximumParallelInvocationsPerClient = 10;
            options.MaximumReceiveMessageSize = 10 * 1024 * 1024;
            options.StreamBufferCapacity = 50;
            options.EnableDetailedErrors = true;
        }).AddAzureSignalR(Configuration.GetSection("AzureSignalR:ConnectionString").Value);

        services.AddCors(options =>
        {
            options.AddPolicy(CORS_SIGNALR_POLICY_NAME, builder => builder
                    .AllowAnyHeader()
                    .AllowAnyMethod()
                    .SetIsOriginAllowed((host) => true)
                    .AllowCredentials()
            );

        });

        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();

        app.UseCors(CORS_SIGNALR_POLICY_NAME);
        app.UseRouting();

        app.UseAuthorization();

        app.UseAzureSignalR(routes =>
        {
            routes.MapHub<SocketHub>("/sockethub");
        });

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Socket no ar!");
            });
            endpoints.MapControllers();
        });
    }
}

Repare que a configuração do CORS está permitindo todos os tipos de conexões, o que não é indicado por questão de segurança, deixado apenas para realizar nossos testes.

Existem configurações extras em AddSignalR, que foram de acordo com a documentação oficial, onde também indicam as boas práticas de utilização.

Nosso próximo passo é configurar o hub, chamado de SocketHub.cs:

public class SocketHub : Hub
{
    public override async Task OnConnectedAsync()
    {
        var context = Context.GetHttpContext();

        lock (UserSocket.UsersSocket)
        {
            UserSocket.UsersSocket.Add(new Users
            {
                DateTime = DateTime.Now,
                Application = context?.Request?.Headers["Host"],
                Environment = context?.Request?.Headers["Origin"],
                ConnectionId = Context.ConnectionId,
                UserName = Context.User?.Identity?.Name ?? Context.ConnectionId
            });
        }

        await base.OnConnectedAsync();
    }

    public override async Task OnDisconnectedAsync(Exception exception)
    {
        var user = UserSocket.UsersSocket?.FirstOrDefault(p => p.ConnectionId == Context?.ConnectionId);

        if (user != null)
        {
            lock (UserSocket.UsersSocket)
            {
                UserSocket.UsersSocket.Remove(user);
            }
        }

        await base.OnDisconnectedAsync(exception);
    }

    public async Task SendPrivateMessage(string login, string type, string message, string body)
    {
        var connectionId = UserSocket.UsersSocket.Where(x => x.UserName == login);

        foreach (var connection in connectionId)
        {
            await Clients.Client(connection.ConnectionId).SendAsync("ReceiveMessage", login, type, message, body);
        }
    }

    public async Task SendNotification(string mensagem)
    {
        await Clients.All.SendAsync("ReceiveGenericEvent", mensagem, DateTime.Now.Ticks.ToString());
    }
}

Além dos métodos de sobrecarga de conectar e desconectar, temos o método SendPrivateMessage responsável por enviar uma mensagem para um usuário específico e o método SendNotification, que é responsável por enviar uma mensagem para todos clientes que estiverem "escutando" o método ReceiveGenericEvent.

amos configurar o pacote Microsoft.AspNetCore.SignalR.Client no projeto Sender (Console Application), responsável por enviar mensagens:

static async Task SenderClient(string nomeUsuario)
{
    var connection = new HubConnectionBuilder()
        .WithUrl("http://localhost:5005/sockethub", options =>
        {
            options.Headers["Application"] = "API Sender";
        })
        .WithAutomaticReconnect()
        .Build();

    await connection.StartAsync();
    Console.WriteLine("Connection started.");

    connection.Closed += async (error) =>
    {
        await Task.Delay(new Random().Next(0, 5) * 1000);
        await connection.StartAsync();
    };

    while (true)
    {
        Thread.Sleep(400);

        await connection.SendAsync($"SendNotification", $"{nomeUsuario} - {DateTime.Now:G}");
        Console.WriteLine($"Send Message: {nomeUsuario} - {DateTime.Now:G}");
    }
}

A classe HubConnectionBuilder é responsável pela conexão com nosso servidor SignalR (que está em execução na url http://localhost:5005/sockethub), nela também temos o método WithAutomaticReconnect() que é utilizado como resiliência para manter a conexão sempre ativa com nosso servidor.

Finalmente temos a configuração do projeto Receive (Console Application), responsável por receber todas as mensagens enviadas pelo projeto Sender:

static async Task Main(string[] args)
{
    var connection = new HubConnectionBuilder()
        .WithUrl("http://localhost:5005/sockethub", options =>
        {
            options.Headers["Application"] = "API Receive";
        })
        .WithAutomaticReconnect()
        .Build();

    await connection.StartAsync();
    Console.WriteLine("Connection started.");

    connection.On<string, string>("ReceiveGenericEvent", async (id, runningTime) =>
    {
        await ReceiveAsync(id, runningTime);
    });

    connection.Closed += async (error) =>
    {
        await Task.Delay(new Random().Next(0, 5) * 1000);
        await connection.StartAsync();
    };
    Console.ReadLine();
}

private static Task ReceiveAsync(string id, string runningTime)
{
    Console.WriteLine($"Receive Message: {id} - {runningTime}");
    return Task.CompletedTask;
}

O subscribe do método ReceiveGenericEvent do código acima é configurado no método SendNotification do nosso SocketHub.cs.

Para testar, é necessário marcar todos os três projetos como inicializáveis no Visual Studio:

Ao executar os três projetos, é possível ver a orquestração de mensagens do SignalR:

É muito simples, seguro e prático de configurar e utilizar o Azure SignalR, uma ferramenta incrível que pode ser utilizado em vários cenários, principalmente em ambientes com microservices, comunicações entre o backend / frontend e chamadas assíncronas.

Os detalhes completos você encontra no meu GitHub: https://github.com/hgmauri/signalr-socket-dotnet5

.NET 6

Henrique Mauri — Tue, 21 Sep 2021 12:28:00 +0000

O novo .NET chegou junto com o C# 10, cheio de novidades que simplificam o desenvolvimento e com muito mais performance para essa versão estável do .NET 6 LTS (Long Time Support).

Neste artigo vamos configurar a nova versão do .NET no Visual Studio 2022.

Instalação

Visual Studio 2022 - É tudo o que precisa.

.NET 6 foi testado com Visual Studio 16.9 Preview 4 e Visual Studio 2022 Preview. Tente usar essas compilações se quiser experimentar o .NET 6.

Criando um projeto .NET 6

Com seu Visual Studio instalado, crie um novo projeto do tipo ASP.NET Core Web App:

Em seguida escolha o nome do seu projeto e selecione o .NET 6 como Framework:

O projeto em .NET 6.0 está muito mais limpo e simples de codificar. Um ponto bem legal é a possibilidade de utilizar o GlobalUsings, o que permite, em um único arquivo arquivo, ter todos os using do projeto.

Os detalhes completos das novidades do .NET 6.0 e C#10 você encontra no meu GitHub:
https://github.com/hgmauri/sample-dotnet6

Azure SignalR no .NET 5.0

Henrique Mauri — Fri, 03 Sep 2021 09:20:40 +0000

Neste artigo utilizaremos o Azure SignalR como serviço em um projeto .NET 5.