Categoria: Dicas

Olá, Devs!!! Vamos falar de algo que pode parecer simples, mas que tem um impacto enorme na legibilidade e manutenção do nosso código: Estilo de Codificação Vertical. Você pode pensar: “Por que a orientação do meu código importa?”, mas acredite, faz toda a diferença e é uma das práticas recomendadas em muitos guias de estilo de código, incluindo os relacionados ao .NET.

1. Por que escrever código verticalmente?

Já se deparou com uma linha de código tão longa que você tinha que rolar a tela para ler tudo? Ou então com funções gigantescas que parecem nunca terminar? Então, essa é a razão pela qual devemos prestar atenção em como estruturamos nosso código.

2. Mantenha seus métodos curtos

Eu sempre recomendo: faça seus métodos serem curtos e focados em uma única tarefa. Não apenas eles se tornam mais fáceis de ler, mas também de testar e reutilizar. E, ao fazê-los curtos, você naturalmente estará escrevendo mais “verticalmente”.

3. A sequência importa

Quando você organiza seu código de forma vertical, tem uma oportunidade de ouro de colocar seus métodos na ordem em que são chamados. Isso facilita enormemente para qualquer pessoa (inclusive você, no futuro) que esteja tentando entender o fluxo do programa.

4. Evite linhas longas

Lembra daquela linha que você teve que rolar para ler? Vamos evitar isso! Mantenha suas linhas dentro de um limite razoável. Algo entre 80 a 120 caracteres costuma ser um bom padrão. Você não apenas evita a rolagem, como também torna tudo mais agradável visualmente.

5. Indentação e espaçamento

Indentar seu código corretamente destaca sua estrutura. Isso sem falar no espaço em branco entre blocos de código, métodos e classes. Pode parecer bobo, mas esses “respiros” visuais ajudam nosso cérebro a processar a informação de maneira mais eficiente.

Por exemplo:

 

O estilo de codificação vertical não é apenas uma moda ou uma preferência estilística. É uma abordagem que pode melhorar significativamente a legibilidade e manutenção do seu código .NET. E, ao final do dia, um código mais limpo e organizado significa menos bugs e uma manutenção mais tranquila. Portanto, da próxima vez que você estiver codificando, lembre-se de pensar verticalmente!

 

Até a próxima!!!

Olá, Devs! No universo do C#, frequentemente debatemos sobre quantos parâmetros um método deve ter. Embora pareça um detalhe pequeno, essa decisão afeta diretamente a legibilidade, manutenção e testabilidade do nosso código.

1. Por que usar muitos parâmetros

• Especificidade: Em algumas situações específicas, ter vários parâmetros é uma necessidade absoluta. Primeiramente, quando estamos lidando com funções que precisam de múltiplos dados de entrada para processar uma lógica complexa, a especificidade fornecida por vários parâmetros é insubstituível. Além disso, eles garantem que cada pedaço de informação necessário seja passado ao método, o que por sua vez facilita sua execução.
• Flexibilidade: Inicialmente, outra razão para optar por múltiplos parâmetros é a versatilidade que eles trazem. Por exemplo, com diversos argumentos, um único método pode atender a múltiplos casos de uso, o que, consequentemente, torna o código mais reutilizável e modular.

2. Por que evitar muitos de parâmetros

• Legibilidade: Primeiramente, você deve sempre priorizar manter o código claro e legível. Entretanto, quando você usa muitos parâmetros, os métodos podem se tornar confusos, o que por sua vez dificulta sua capacidade de compreender rapidamente o que um método faz e como ele opera.
• Manutenção: Cada parâmetro adicional introduz complexidade. Por isso, alterar, adicionar ou remover um parâmetro pode ter efeitos cascata em várias partes do código, consequentemente, aumentando o risco de bugs.
• Testabilidade: Mais parâmetros significam mais combinações a serem testadas. Isso pode complicar a escrita de testes abrangentes e tornar o processo de testes muito mais demorado.

💡 Solução Estratégica: Se encontrar-se regularmente projetando métodos com muitos parâmetros, reflita. Uma abordagem popular é encapsular dados relacionados em uma classe ou estrutura e passar essa entidade como um único parâmetro. Não só simplifica a assinatura do método, mas também torna o código mais organizado.

No mundo da programação, você deve buscar equilíbrio. Embora você possa se beneficiar de múltiplos parâmetros em certos cenários, você deve conhecer as complicações que eles introduzem. Como sempre, você dança entre simplicidade e funcionalidade. Mantenha-se alerta e continue a codificar com sabedoria!

Até a próxima!!!

O universo da programação em C# é amplo e fascinante. Nele, um dos operadores que talvez não seja tão mencionado quanto deveria, mas que é extremamente útil, é o operador de coalescência. Então, vamos mergulhar nesse tópico e entender como usar os operadores ?? e ??= de maneira eficiente.

Primeiramente, você já se deparou com situações onde é necessário verificar se uma variável é nula (ou null, como diríamos em C#) e, em caso afirmativo, atribuir um valor padrão a ela? Antigamente, isso exigia um bloco de código if-else. No entanto, graças ao operador de coalescência, esse processo se tornou mais elegante e conciso.

1. Utilidade principal

A utilidade principal do operador de coalescência é reduzir a quantidade de código necessária para verificar se um valor é null e fornecer um valor padrão se for.

2. Vamos entender

Vamos considerar o operador ?? inicialmente. Essencialmente, ele verifica se o valor à sua esquerda é null. Se for, ele retorna o valor à direita. Se não, ele simplesmente retorna o valor à esquerda. Por exemplo:

int? valorNulo = null;
int valorPadrao = 10;
int resultado = valorNulo ?? valorPadrao;

Neste caso, como valorNulo é, de fato, nulo, resultado receberá o valor de valorPadrao, que é 10. Contudo, se valorNulo tivesse algum valor, digamos, 5, então resultado seria 5. Isso elimina a necessidade de uma verificação explícita usando if-else.

Além disso, o operador ?? é incrivelmente versátil. Ele não se limita a tipos primitivos. Imagine que você tenha objetos ou até mesmo listas. O operador funciona da mesma maneira, garantindo que você sempre tenha um valor padrão caso a variável verificada seja nula.

Por outro lado, e se quiséssemos não apenas verificar se uma variável é nula, mas também atribuir um valor padrão a ela, caso seja? Bem, a partir do C# 8.0, temos o operador ??=, que combina a verificação e a atribuição em uma única operação.

string texto = null;
texto ??= “Texto padrão”;

Neste exemplo, como a string texto é inicialmente nula, o operador ??= irá atribuir “Texto padrão” a ela. No entanto, se texto já contivesse algum valor, ele permaneceria inalterado. Esse operador, então, simplifica nosso código, tornando-o mais limpo e legível.

3. E sobre a eficiência?

A boa notícia é que eles são tão eficientes quanto os blocos if-else tradicionais, mas com a vantagem de serem mais elegantes e concisos.

Além disso, é crucial mencionar que esses operadores de coalescência são compatíveis com outros operadores em C#. Por exemplo, é perfeitamente válido combinar o operador ?? com o operador ternário ?: para criar expressões ainda mais concisas.

4. Exemplo

5. Conclusão

A linguagem C# oferece uma série de ferramentas que facilitam a vida do desenvolvedor. Os operadores de coalescência ?? e ??= são apenas dois exemplos de como a linguagem evoluiu ao longo dos anos para tornar o código mais limpo, legível e eficiente. Assim, ao trabalhar com variáveis que podem ser nulas, lembre-se desses operadores. Eles certamente ajudarão a melhorar a qualidade do seu código e a tornar sua programação diária mais agradável. E como qualquer ferramenta, a prática leva à perfeição. Portanto, sempre que possível, tente incorporar esses operadores em seu fluxo de trabalho e veja a mágica acontecer!

 

Até a próxima!!!

Olá, Devs! Primeiramente, quero dizer que hoje vou compartilhar uma dica daquelas e trata-se dos atributos especiais do C#!!!

Pois bem, você sabia que no C# temos alguns atributos especiais que são poderosos quando queremos obter informações sobre quem chamou determinado método? Isso mesmo! Estou falando dos atributos CallerMemberName, CallerFilePath e CallerLineNumber.

Além disso, eles são muito úteis para cenários de rastreamento, depuração e geração de logs.

1. Então, vamos lá! Vem comigo que eu te explico:

– CallerMemberName
Primeiramente, sabe quando você quer saber o nome daquele método que chamou o seu? Pois é, esse atributo te dá essa resposta!

– CallerFilePath
Por outro lado, esse aqui é para os detalhistas! Ele te diz o caminho exato, a localização precisa do arquivo de origem que fez a chamada.

– CallerLineNumber
Agora, imagine se eu te dissesse que há um jeito de saber a linha específica no arquivo onde o chamador fez aquela ligação para o método? É isso que esse atributo faz!

O exemplo abaixo mostra isso, ou seja, o nome do chamador, o path do arquivo e o número da linha sendo gerados, pois passamos como parâmetros do método TraceMessage os atributos CallerMemberName, CallerFilePath e CallerLineNumber.

2. Seguindo em frente, vamos decifrar o código juntos?

1. Temos dois métodos: DoProcessing e TraceMessage.

2. O primeiro, DoProcessing, liga para o TraceMessage só para dizer: “An error happened“.

3. O TraceMessage é o nosso detetive. Via parâmetros ele está preparado não só para ouvir a mensagem, mas também para pegar três informações muito importantes que são: CallerMemberName, CallerFilePath e CallerLineNumber que pega o nome do método ou propriedade chamador, obtém o caminho completo do arquivo de origem do chamador e o número da linha do ponto onde o método foi chamado respectivamente.

E sabe o melhor? O C# faz isso automaticamente pra gente!

4. Finalmente, TraceMessage conta tudo o que descobriu usando o bom e velho Console.WriteLine.

Agora, um segredo entre nós: Não precisa se preocupar em fornecer esses detalhes ao chamar o método. É mágico! O próprio compilador cuida disso pra você. E fique tranquilo quanto à performance, porque isso acontece no momento da compilação, não quando seu código está rodando.

Portanto, meu conselho? Use e abuse desses atributos, especialmente quando estiver registrando informações. Eles te ajudam a saber exatamente de onde veio aquela mensagem ou erro, sem ter que fazer malabarismo pra descobrir.

 

E aí, o que acharam? Estão prontos para mergulhar ainda mais fundo no universo do C#?