DEV Community: Wellington Martins

Benchmarks Clients Http

Wellington Martins — Wed, 20 Jul 2022 12:35:01 +0000

Uma ação que faz parte do dia a dia na vida de um desenvolvedor, é a necessidade de consumir alguma API utilizando chamadas HTTP.

Para tal tarefa temos hoje algumas libs (bibliotecas), que tornam nosso trabalho mais fácil.

Realizei um benchmark com as libs mais populares no universo dotnet:

HttpClient:

É uma classe nativa do dotnet sendo a mais utilizada.

Podemos utilizar o HttpClient para enviar requisições HTTP e receber respostas HTTP baseada em um URI.

RestSharp:

É uma lib http client open-source, utilizada para o consumo de APIs.

Baseado nisso, podemos utiliza-lá instalando-a através do NuGet Package Manager.

RestSharp pode se comunicar com qualquer API usando o protocolo HTTP, seu proposito é o consumo de REST APIs.

Flurl:

É uma lib http client, seu nome é um trocadilho com Fluent URL.

Ele se descreve como "Um builder de URL moderno, fluente, assíncrono, testável, portável, cheio de buzzords e uma biblioteca com um client HTTP para dotnet”.

De fato a descrição é precisa com o que essa lib entrega.

Refit:

O Refit é uma biblioteca para dotnet com o intuito de facilitar o consumo de API's REST.

A ideia é fornecer interfaces que abstraem a comunicação com os serviços HTTP possibilitando a escrita de um código limpo e de baixo acoplamento usando poucas linhas de código.

Cenário para o benchmark:

Todas as requests foram realizadas para o jsonplaceholder, uma api fake utilizada para testes, mais informações sobre clique aqui.
Foram executadas 3 rodadas de testes, onde o resultado é o average das três execuções.
Utilizei os verbos: POST, PUT e GET.

Resultados:

Quando realizamos um POST com um body, temos o Refit com o melhor resultado praticamente empatado com o Flurl, já o RestSharp obteve a pior performance.

No consumo de memória o Flurl fica com o troféu, HttClient e Refit praticamente empatados, mais um vez o RestSharp obteve o pior resultado.

Já quando realizamos um PUT com um body, tivemos uma performance próxima entre todos. RestSharp sendo o mais rápido com o HttpClient sendo o mais lento.

Porém, quando analisamos o consumo de memória a vantagem do RestSharp vai por água abaixo, visto que ele tem um consumo de memória extremamente alto comparado com o Refit e o HttpClient que ficam praticamente empatados em primeiro.

Aqui foi realizado um Get sem nenhum filtro ou parâmetro retornando um total de 200 resultados.

Mais uma vez tivemos todos as libs com performance extremamente próxima tendo o HttpClient com uma ligeira vantagem.

Novamente quanto o assunto é consumo de memória todo o nivelamento no quesito velocidade vai por água abaixo para o RestSharp, novamente tendo o pior consumo de memória.

Refit mais uma vez mostra um consumo muito baixo de memória, comparado com os demais.

Conclusão:

Após os testes temos um resultado extremamente positivo para o Refit. Apresentando velocidades equivalentes ou até mais rápidas que os demais, fora o quesito consumo de memória onde ele sempre esteve entre os melhores.

O RestSharp tem um sério problema no consumo de memória, visto que em todos os testes seu consumo de memória foi discrepante comparado aos outros.

Claro que mais itens devem ser levados em consideração quando formos escolher qual deles utilizar, mas dar uma chance para o Refit parece ser uma ótima ideia.

Link do repositório com o projeto utilizado: clique aqui.

Only Numbers performance test

Wellington Martins — Tue, 19 Oct 2021 02:38:31 +0000

Olá pessoal, tudo blz?

Quem nunca se deparou com a necessidade de extrair somente os números de uma string?

Hoje iremos realizar alguns testes de performance utilizando algumas abordagens diferentes para realização dessa tarefa.

Primeiro vamos criar nossa aplicação, ela será um console application em .net 5

dotnet new console --name OnlyNumbers

Feito isso já temos nossa aplicação criada. Agora vamos instalar dois pacotes nugets que irão nos ajudar.

dotnet add package Bogus
dotnet add package BenchmarkDotNet

O primeiro pacote será responsável pela criação da nossa massa de dados.

O segundo é responsável por realizar nosso teste de performance e suas métricas.

Feito isso, abra a aplicação em sua IDE de preferência, eu utilizei o Rider da JetBrains.

Com isso, teremos nossa classe Program.cs.

Iremos adicionar mais uma classe com o nome de OnlyNumberTests.cs

Dentro desse arquivo iremos criar uma segunda classe que será a User

public class User
{
    public string Login { get; set; }
    public string Password { get; set; }
}

Uma classe bem simples contendo somente Login e Password.

De volta a classe OnlyNumberTests, iremos adicionar o annotation [MemoryDiagnoser].

[MemoryDiagnoser]
public class OnlyNumberTests
{
}

Vamos criar nossa lista de usuários utilizando a biblioteca Bogus da seguinte forma:

private static readonly List<User> FakeUsers = new Faker<User>()
    .UseSeed(420)
    .RuleFor(r => r.Login, faker => faker.Person.UserName)
    .RuleFor(r => r.Password, faker => faker.Internet.Password())
    .Generate(10);

Vamos criar também o Regex abaixo:

private static readonly Regex OnlyNumberPattern =
            new(@"\d+", RegexOptions.IgnoreCase
                        | RegexOptions.Compiled,
                TimeSpan.FromMilliseconds(250));

Agora faremos nosso primeiro método de teste, conforme abaixo:

[Benchmark]
public void LinqCharIsDigitNewString()
{
    for (var i = 0; i < FakeUsers.Count; i++)
    {
        var numbers = new string(FakeUsers[i].Password.Where(char.IsDigit).ToArray());
    }
}

Estamos percorrendo nossa lista de usuários e pesquisando somente pelos caracteres que são dígitos utilizando uma função do próprio .net chamada char.IsDigit().

Feito isso, estamos retornando uma nova string somente com os dígitos.

O segundo método é bem semelhante ao primeiro, somente alteramos a forma como é salva a string ao invés de criar uma nova string utilizando o string.Join():

[Benchmark]
public void LinqCharIsDigitStringJoin()
{
    for (var i = 0; i < FakeUsers.Count; i++)
    {
        var numbers = string.Join("", FakeUsers[i].Password.Where(char.IsDigit).ToArray());
    }
}

Agora vamos para o método que utilizará o Regex:

[Benchmark]
public void RegexMatchOnlyNumberPattern()
{
    for (var i = 0; i < FakeUsers.Count; i++)
    {
        var number = OnlyNumberPattern.Match(FakeUsers[i].Password).Value;
    }
}

Nosso último método efetuará validação na "mão":

[Benchmark]
public void IfValidator()
{
    for (var i = 0; i < FakeUsers.Count; i++)
    {
        var digitsOnly = string.Empty;
        foreach (var c in FakeUsers[i].Password)
        {
            if (c is >= '0' and <= '9') 
                digitsOnly += c;
        }
    }
}

Ele verificará caractere por caractere, caso seja um número ele adiciona a nossa string.

Agora vamos executar nossa aplicação, importante ressaltar que devemos executá-la em modo Release.

Após executá-la teremos o resultado abaixo no console:

Method	Mean	Allocated
LinqCharIsDigitNewString	1,918.3 ns	2,432 B
LinqCharIsDigitStringJoin	2,327.8 ns	3,016 B
RegexMatchOnlyNumberPattern	1,497.0 ns	2,352 B
IfValidator	267.8 ns	632 B

Onde é possível verificar que a validação com IF foi mais performática que os outros cenários. Levando 267 nanossegundos tendo uma alocação de 632 Bytes.

Já nosso pior cenário foi com a utilização do linq com string join. Levando 2,3 microssegundos alocando 3KB de memória.

Abaixo link do código no github:
https://github.com/ouell/only-numbers

.Net 5 Regex Performance

Wellington Martins — Mon, 11 Oct 2021 17:54:38 +0000

Olá pessoal!

Hoje vamos fazer um teste de performance utilizando regex com .net 5.

Para esse teste criaremos um console application com a instalção de 2 pacotes nuget:

dotnet new console —name TestePerformanceRegex
dotnet add package BenchmarkDotNet
dotnet add package Bogus

BenchmarkDotNet é o pacote responsável por realizar nosso benchmark.

Bogus é o pacote responsável por gerar os dados para nossos testes.

Nosso console app será composto por duas classes:

Program.cs
TesteRegex.cs

Nossa classe Program.cs será dessa forma:

class Program
{
    static void Main(string[] args)
    {
        BenchmarkRunner.Run<TesteRegex>();
    }
}

Nossa classe TesteRegex.cs deverá ter o annotation [MemoryDiagnoser]

[MemoryDiagnoser]
public class TesteRegex
{
}

Agora vamos criar uma classe Usuário, onde teremos E-mail e Login:

public class Usuario
{
    public string Email { get; set; }
    public string Login{ get; set; }
}

Agora dentro da classe TesteRegex, vamos fazer o seguinte:

private static readonly List<Usuario> FakeUsuarios = new Faker<Usuario>()
    .UseSeed(420)
    .RuleFor(r => r.Email, faker => faker.Person.Email)
    .RuleFor(r => r.Login, faker => faker.Person.UserName)
    .Generate(10);

Estamos criando 10 usuários, utilizando o Bogus.

Agora vamos criar uma lista com e-mails validos e e-mails inválidos:

private static readonly List<string> emails = 
    FakeUsuarios.Select(x => x.Email)
        .Concat(FakeUsuarios.Select(x => x.Login)).ToList();

Com isso teremos um total de 20 itens na lista e-mails.

Agora faremos os regex abaixo:

private static readonly Regex RegexStatico =
    new(@"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase);

private static readonly Regex RegexStaticoCompilado =
    new(@"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase | RegexOptions.Compiled,
        TimeSpan.FromMilliseconds(250));

Com isso temos o primeiro Regex sendo estático e o segundo estático e compilado, também foi informado um timeout de 250 milissegundos. Esse timeout deve ser configurado conforme a necessidade da sua aplicação.

Agora iremos criar os métodos responsáveis pelos testes.

Importante ressaltar que todos os métodos tem a anotação de [Benchmark].

[Benchmark]
public void IsMatchInternal()
{
    var regex = new Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase);

    for (var i = 0; i < emails.Count; i++)
    {
        var email = emails[i];
        var isMatch = regex.IsMatch(email);
    }
}

No método acima, estamos declarando o regex internamente e fazendo a validação de todos os e-mails da nossa lista.

[Benchmark]
public void IsMatchInternalCompiled()
{
    var regex = new Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase | 
                    RegexOptions.Compiled);

    for (var i = 0; i < emails.Count; i++)
    {
        var email = emails[i];
        var isMatch = regex.IsMatch(email);
    }
}

Já no método acima, estamos declarando o regex internamente e a flag de compilado.

[Benchmark]
public void IsMatchStatic()
{
    for (var i = 0; i < emails.Count; i++)
    {
        var email = emails[i];
        var isMatch = RegexStatico.IsMatch(email);
    }
}

Nesse método estamos utilizando a declaração estática RegexStatico ao invés de declararmos internamente no método.

[Benchmark]
public void IsMatchStaticCompiled()
{
    for (var i = 0; i < emails.Count; i++)
    {
        var email = emails[i];
        var isMatch = RegexStaticoCompilado.IsMatch(email);
    }
}

Finalmente o último método, temos a utilização da declaração estática RegexStaticoCompilado com a flag de compilado.

Agora vamos executar nossa aplicação, é importante ressaltar que devemos executá-la em modo Release.

Após executarmos, teremos o resultado no console:

Podemos ver que o método mais performático de todos foi quando utilizamos a declaração estática com a flag de compilado, onde levou 4 microssegundos.

Já o nosso pior cenário foi quando utilizamos a declaração interna e copilada, onde levou 1.9 milissegundos e foi alocado 18KB de memória.

Com alguns ajustes simples podemos ter um ganho expressivo de performance quando estamos trabalhando com regex.

Abaixo link do código no github:
https://github.com/ouell/regex-performance