DEV Community: João Batista Costa Oliveira

Como usar o cherry-pick no GIT

João Batista Costa Oliveira — Thu, 09 Jun 2022 13:59:03 +0000

Olá pessoal, tudo bem?

Recentemente tive a necessidade de publicar no ambiente de produção algumas alterações, já aprovadas, que estavam em uma branch, porém outras alterações de outros desenvolvedores ainda estavam aguardando aprovação. Para ajudar a visualizar o cenário, temos as branches:

master
homolog
branch_joao
branch_outro_dev

Como podem perceber, a aprovação ocorre em cima da branch homolog.

Enfim, outro desenvolvedor e eu criamos Pull Requests para homolog.

Até então, somente a minha alteração foi aprovada e por conta do Pull Request do colega, eu não poderia criar a Pull Request de homolog para master, pois a alteração dele iria para produção.

Pois bem, o git tem o comando cherry-pick, que aplica alterações de acordo com commits já existentes. Ou seja, cherry picking é o ato de escolher um commit de uma branch e aplicá-la em outra.

Os comandos abaixo foram realizados no Git Bash.

Obtem-se o commit id desejado de branch_joao

git log

commit 0b90d263bd15107c09955d735e8a671f537b4e4e
Author: João Oliveira 
Date:   Wed Jun 8 12:11:46 2022 -0300

Substituição de EmailHelper por MailKitHelper

Obtem-se o código mais recente de todas as branches

git fetch --all

Cria-se uma nova branch baseada na master.

git checkout -b branch_joao_nova master

Aplica-se a alteração desejada na branch. No meu caso, seria o id abaixo.

git cherry-pick 0b90d263bd15107c09955d735e8a671f537b4e4e

Executa-se o pushcom as alterações para a branch remota.

git push -u origin branch_joao_nova

Para exemplificar, as branches ficaram assim. Suprimi homolog e branch_outro_dev para facilitar a leitura.

Depois disso, cria-se um Pull Request para a master e a situação foi contornada.

Claro, neste exemplo não foi abordado nenhum conflito entre commits ou outro tipo de situação que envolveria uma maior intervenção.

Espero ter ajudado.

Referências:
https://git-scm.com/docs/git-cherry-pick
https://www.atlassian.com/git/tutorials/cherry-pick

Dicas para melhorar a performance em C# - parte 1

João Batista Costa Oliveira — Tue, 07 Jun 2022 18:11:25 +0000

Neste post, vamos comentar sobre algumas melhorias que podemos fazer para obter uma melhor performance do código produzido.

Algumas dicas podem se tornar irrelevantes se a quantidade de dados processada for pequena. Então, não precisa sair alterando seus códigos somente para obter uma melhora que é impercepível para o usuário.

Muitos desenvolvedores tem a preocupação de otimizar seus códigos, obtendo uma melhor performance em tempo de execução. Isso melhora a experiência de usuário, pois ele não ficará esperando tempo desnecessário aguardando uma resposta da aplicação. Além disso, economiza recursos de sistema.

Alguns exemplos foram encontrados em revisões de código que fiz e sugeri ou eu mesmo apliquei as melhorias.

Como medir?

Para a medição da performance de código utilizaremos uma classe chamada StopWatch, pois é muito mais precisa do que a classe DateTime.

using System.Diagnostics;

var stopWatch = new Stopwatch();
stopWatch.Start();

//Código para teste

stopWatch.Stop();

Console.WriteLine("Tempo utilizado: {0}ms", stopWatch.ElapsedMilliseconds);

Ordem de condições no IF

Muitas vezes, não prestamos atenção na ordem de condições no IF. No exemplo abaixo (não é dos melhores, eu sei), temos duas condições AcessaBanco() e isActive.

Não sabemos quanto tempo AcessaBanco() vai demorar para ser executado e qual será sua resposta: true ou false, mas temos isActive já fornecido.

public static void Exemplo1(int id, bool isActive)
{
    if (AcessaBanco(id) || isActive)
    {
        Console.WriteLine("entrou");
    }
}

Como temos uma condição OU ||, o código será executado quando uma das condições for verdadeira. Se o lado esquerdo for verdadeiro, logo, o lado não é executado.

Podemos mudar, então, para:

public static void Exemplo1(int id, bool isActive)
{
    if (isActive || AcessaBanco(id))
    {
        Console.WriteLine("entrou");
    }

}

Operadores && e || vs & e |

Os operadores & e | avaliarão os dois lados do operando independente do resultado de cada um.

Para começarmos, vamos definir os métodos:

public static bool ValidacaoA()
{
    Console.WriteLine("Validacao A");
    return true;
}

public static bool ValidacaoB()
{
    Console.WriteLine("Validacao B");
    return true;
}

Agora vamos ao teste.
No exemplo abaixo, os dois métodos abaixo serão executados.

if(ValidacaoA() | ValidacaoB())
{
    Console.WriteLine("Testou os dois");
}

//Saída
//Validacao A
//Validacao B
//Testou os dois

Já os operadores && e ||

bool a = false & PerformanceTeste.ValidacaoB();
Console.WriteLine(a);

//Saída
//Validacao B
//False

bool b = true & PerformanceTeste.ValidacaoB();
Console.WriteLine(b);

//Saída
//Validacao B
//True

Logo, se for possível, utilize os operandos && e ||.

Comparar Strings

Para este teste, foi criada uma lista de 500.000 objetos. Cada objeto da lista contém duas propriedades do tipo string (chamei de MyProperty1 e MyProperty2). Foram geradas para cada propriedade uma string aleatória de 50 posições.

No primeiro teste, foi utilizada a comparação PALAVRA1 == PALAVRA2.

Ao executar o teste conforme o código abaixo, obteve-se o resultado de 80ms.

public static bool Exemplo3(string str1, string str2)
{
    return str1.ToLower() == str2.ToLower();
}

Ao utilizar string.Compare, obteve o resultado de 15ms

public static bool Exemplo3Alterado(string str1, string str2)
{
    return string.Compare(str1,str2,true) == 0;
}

Ou seja, apenas com essa mudança obteve-se um melhora de 90%. Nada mal.

List e ArrayList

O exemplo a seguir trata das diferenças de performance entre List e ArrayList.

Vamos deixar bem simples e utilizar apenas List e ArrayList com inteiros.

const int _tamanho = 100000;
public static void Exemplo4()
{
    ArrayList arrayList = new ArrayList();
    for (int i = 0; i < _tamanho; i++)
    {
        arrayList.Add(i);
    }

}

Obteve-se um resultado de 31ms.

Ao utilizarmos o List com um tamanho predefinido (uma forma de obter maior performance) teremos o seguinte: 0ms (!!)

const int _tamanho = 100000;
public static void Exemplo4Alterado()
{
    List<int> intlist = new List<int>(_tamanho);
    for (int i = 0; i < _tamanho; i++)
    {
        intlist.Add(i);
    }

}

Por enquanto é isso, em breve teremos a parte 2.
Abraços.

Como "fatiar" ("chunk") Lists ou Enumerable em pedaços menores em C#

João Batista Costa Oliveira — Tue, 07 Jun 2022 13:48:36 +0000

Hoje vou compartilhar um pequeno trecho de código em C# que permite que você "fatie" ou (crie um "chunk" de) uma lista em n listas menores utilizando Linq.

O código "fatia" um Enumerable em C# em um tamanho especificado, se a lista dada não puder ser dividida uniformemente, o pedaço final conterá os elementos restantes.

using System.Collections.Generic;
using System.Linq;

public static class ListHelper{
  public static List<List<T>> ChunkList<T>(IEnumerable<T> data, int size)
  {
    return data
      .Select((x, i) => new { Index = i, Value = x })
      .GroupBy(x => x.Index / size)
      .Select(x => x.Select(v => v.Value).ToList())
      .ToList();
  }
}

//Exemplo
List<int> numList = new List<int> { 1, 2, 3, 4, 5 }; 
ListHelper.ChunkList(numList, 3); // { {1, 2, 3}, {4, 5} }