C# -  Criando um código mais limpo   

 Neste artigo vamos recordar o uso de 3 dicas práticas para ter um código C# mais claro e fácil de entender e manter.

Como você sabe se está seguindo as boas práticas ao programar em C# ?

E como você pode evitar as más práticas que podem tornar seu código confuso e mais difícil de gerenciar ?

Neste artigo, veremos 3 práticas ruins comuns e explicaremos como evitá-las usando recursos já existentes na linguagem C#.

1- Pare de verificar null usando a instrução if 

A instrução if pode ter um número enorme de utilidades e usos, um deles é fazer a verificação de valores null.

Embora usar if para fazer isso não esteja errado podemos usar uma maneira melhor e que esta disponível desde a versão 6.0 do C#. Vamos recordar...

O operador condicional nulo (?.) também chamado de "operador Elvis" por causa de sua semelhança com um par de olhos escuros sob um grande topete de cabelo. Este operador é uma forma de um operador de acesso de membro(.).

Dada a expressão :

     x?.y

Comportamentos do operador:

- O tipo da expressão x?.y é o tipo de y, nos casos em que y é um tipo de referência. Se y for um tipo de valor, a expressão x?.y será o tipo anulável que envolve o tipo de valor subjacente representado por y.
- A especificação para o recurso exige que x seja avaliado não mais de uma vez.
- O operador condicional nulo causa curto-circuito, o que significa que você pode encadear vários operadores ?. ,  sabendo que o primeiro nulo encontrado impede que os componentes restantes (mais à direita) da expressão sejam avaliados.

Exemplo prático:

Considere a classe Pessoa :

public class Pessoa
{
  public string? Nome { get; set; }
  public string? Sobrenome { get; set; }
  public int? Idade { get; set; }
}

Agora vamos assumir que temos uma instância da classe Pessoa chamada de p.

Com isso em mente considere as instruções  a seguir:

var nome = p?.Nome;
var idade = p?.Idade;

A variável nome é uma string.
O valor de nome depende do valor de p.
Se p for nulo, nome será nulo.
Se p não for nulo, nome será o valor de p.Nome.
Observe que p.Nome pode ser nulo mesmo quando p não for.

A variável idade é um int? (que é outra maneira de especificar um Nullable<int>).
Tal como acontece com o nome, o valor da idade depende do valor de p.
Se p é nulo, a idade é um int? sem valor.
Se p não for nulo, idade é o valor encapsulado de p.Idade.

Agora suponha que temos uma lista de pessoas representadas por IList<Pessoa>.

IList<Pessoa> pessoas = new List<Pessoa>();

Agora, temos alguns níveis de acesso de membros para navegar, e um desses níveis usa a sintaxe do indexador ([ ]).

Usando a operador null condicional podemos escrever:

var nome = pessoas?[3]?.Nome;

A sintaxe ?[] tem a mesma semântica que a sintaxe ?. , é como você acessa o indexador em um array, ou uma classe que implementa um indexador.

As regras para o seu comportamento são as mesmas :

- Se pessoas for null, nome receberá o valor null.
- Se pessoas[3] for null, nome receberá o valor null.
- Caso contrário, a nome é atribuído o valor de pessoas[3].Nome.
- No entanto, se pessoas não for null, mas tiver menos de quatro elementos, acessar pessoas[3] ainda gerará uma OutOfRangeException.

2- Utilize tuplas para retornar mais de um valor  

Se você quiser retornar mais de um resultado, a primeira coisa que provavelmente virá à mente é criar uma classe e usar parâmetros out ou usar tipos anônimos. Esta pode ser a forma padrão de agir mas a melhor é usar uma tupla.

A classe Tuple() fornece métodos estáticos para criar objetos de coleção de itens e é uma estrutura de dados que tem um número específico e sequencial de elementos, e o C# 7.0  introduziu o suporte de linguagem para tuplas, que permite nomes semânticos para os campos de uma tupla, usando tipos de tupla novos e mais eficientes.

Exemplo:

int a = 30;
int b = 30;

(int soma, int multiplicacao) = Calcula(a, b);

Console.WriteLine($" 30 + 30 = {soma} e 30 x 30 = {multiplicacao} ");

Console.ReadKey();

static (int, int) Calcula(int a, int b)
{ 
   return (a + b, a * b);
}

Aqui estamos retornando mais de um resultado usando tuplas de forma simples e direta.

3- Use o operador condicional em vez de if-else

Muitas vezes, por hábito, nos acostumamos a usar o clássico if-else e pronto; mesmo já existindo recursos na linguagem que nos oferecem um melhor resultado.

O operador condicional (:?) avalia uma expressão booleana e retorna um dentre dois valores e pode substituir o uso do if-else.

O formato do operador (:?) é o seguinte:


condição ? primeira_expressão : segunda_expressão
 

Se a condição for verdadeira, a primeira expressão é avaliada e se torna o resultado, se falsa, a segunda expressão é avaliada e se torna o resultado. Apenas uma das duas expressões é sempre avaliada.

Abaixo temos um exemplo mostra como podemos usar o operador para reduzir a quantidade de código escrita:

int x = 10;
int y = 20;
int maximo;

if (x > y)
   maximo = x;
else
   maximo = y;

Console.WriteLine(" Máximo = " + maximo);

Console.ReadKey();

Usando o operador condicional temos:

int x = 10;
int y = 20;
int maximo;

maximo = (x > y) ? x : y;

Console.WriteLine(" Máximo = " + maximo);

Console.ReadKey();

Com isso usamos recursos da linguagem C# disponíveis já a um bom tempo para obter um código mais limpo.

E estamos conversados...

"Dando graças ao Pai que nos fez idôneos para participar da herança dos santos na luz;
O qual nos tirou da potestade das trevas, e nos transportou para o reino do Filho do seu amor;"
Colossenses 1:12,13

Referências:

José Carlos Macoratti