14 maneiras de simplificar seu código C# – Insights sobre as melhores práticas de C# do vídeo de Tim Corey

1. Uso de funções estáticas para um código mais limpo

Tim começa mostrando como o acesso estático pode simplificar chamadas repetitivas. Ao declarar:

using static System.Console;

using static System.Console;

Você não precisa mais prefixar todos os membros estáticos com Console..

Isso é mais do que apenas remover palavras — trata-se de tornar o acesso estático claro. Tim destaca que, se você estiver chamando um membro estático definido em uma classe usada com frequência, como Console ou Math, essa forma abreviada melhora a legibilidade do código.

No entanto, como parte das boas práticas de programação, ele alerta que os desenvolvedores devem evitar conflitos — duas classes diferentes podem ter o mesmo nome para um membro estático. A conscientização sobre possíveis comportamentos inesperados é fundamental.

2. Inicialização de lista com

Agora, em C#, você pode inicializar listas de forma mais direta:

List<string> names = ["Tim", "Sue", "Bilbo"];

List<string> names = ["Tim", "Sue", "Bilbo"];

Tim explica que não se trata de condensar tudo em uma única instrução, mas sim de escrever um código mais fácil de ler e otimizar o desempenho, reduzindo a complexidade desnecessária.

Em vez de analisar o código repetitivo "nova Lista de Strings", o leitor vê exatamente o que importa: os nomes descritivos da coleção. Tim também observa que isso funciona para arrays e até mesmo dicionários, estando em consonância com as convenções de codificação que priorizam a clareza.

3. Novo tipo de destino

Outra forma de economizar tempo: nova digitação direcionada. Em vez de:

List<int> numbers = new List<int>();

List<int> numbers = new List<int>();

Você pode escrever:

List<int> numbers = new();

List<int> numbers = new();

Tim destaca que repetir o nome da classe é desnecessário — ele já está no lado esquerdo. Isso segue as boas práticas de programação, eliminando redundâncias e, ao mesmo tempo, facilitando a leitura do código.

4. Tipos var e anônimos

Tim aborda o conceito de var, um recurso que gera debates nos círculos de práticas de programação. Algumas pessoas não gostam porque oculta nomes e tipos de variáveis, mas Tim esclarece que seu verdadeiro poder reside nos tipos anônimos.

Ao trabalhar com fontes de dados (como SQL via Dapper), Tim mostra como o var permite criar objetos dinamicamente:

var parameters = new { FirstName = "Tim", LastName = "Corey" };

var parameters = new { FirstName = "Tim", LastName = "Corey" };

Isso é perfeito para consultas de escrita ou objetos únicos — você não precisa criar uma classe base apenas para parâmetros. Como Tim disse, isso evita poluir sua base de código com tipos desnecessários, ao mesmo tempo que fornece mensagens de erro significativas caso algo dê errado.

5. Namespaces com escopo de arquivo

Tim passa a usar namespaces com escopo de arquivo, mostrando como isso funciona:

namespace ProjectName
{
    // indented code
}

namespace ProjectName
{
    // indented code
}

torna-se isto:

namespace ProjectName;

namespace ProjectName;

Essa pequena alteração elimina a indentação desnecessária e segue as convenções de nomenclatura do C#, como o uso de PascalCase para membros públicos. Tim explica que, como a maioria dos arquivos contém apenas um namespace, isso melhora a legibilidade do código e mantém as seções lógicas alinhadas.

6. Registros para estruturas de dados de uma linha

O uso de registros permite definir objetos de dados em apenas uma instrução:

public record EmployeeRecord(int Id, string Name);

public record EmployeeRecord(int Id, string Name);

Tim observa que isso gera um tipo completo — propriedades, imutabilidade e ToString() — com o mínimo esforço. Ele deixa claro que cenários com classes derivadas ainda exigem classes, mas quando seu objeto é somente leitura, os registros seguem o princípio da responsabilidade única, executando bem uma única tarefa.

7. Reconhecimento de padrões

Tim demonstra como o casamento de padrões ajuda a lidar com exceções e a realizar comparações com segurança. Em vez de escrever verificações de tipo verbosas, você pode combiná-las:

if (emp is EmployeeRecord e)
{
    e.Id = 1;
}

if (emp is EmployeeRecord e)
{
    e.Id = 1;
}

Esta linha única verifica e lança. Tim diz que isso está de acordo com as boas práticas de programação — você evita nomes de variáveis ​​de uma única letra, como x ou y, e em vez disso, usa nomes descritivos, como e. Nomes de métodos e variáveis ​​claros facilitam a manutenção do código por outros desenvolvedores.

8. Interpolação de strings

Para construir strings legíveis, Tim demonstra a interpolação de strings:

$"The employee with ID {e.Id} is {e.Name}"

$"The employee with ID {e.Id} is {e.Name}"

Ele destaca que isso facilita a criação de mensagens de erro significativas e a escrita de comentários. Em vez de concatenações complexas, você pode literalmente escrever código que se lê como inglês — melhorando a qualidade do código e simplificando os futuros testes unitários que verificam a saída.

9. nameof() para Refatoração Segura

Tim mostra como nameof() protege você ao refatorar o código. Nomes de variáveis ​​codificados diretamente em strings podem levar a comportamentos inesperados se forem renomeados. Mas escrevendo:

nameof(emp)

nameof(emp)

O compilador atualiza automaticamente cada uso. Essa é uma das melhores práticas que mantém sua base de código saudável: escrever um código limpo e reorganizado.

10. Tuplas para múltiplos valores de retorno

Em vez de criar uma classe base apenas para retornar dois valores, Tim usa tuplas:

(string FirstName, string LastName) SplitName(string fullName)

(string FirstName, string LastName) SplitName(string fullName)

Isso evita dependências externas desnecessárias e adere ao princípio da responsabilidade única — o método apenas divide um nome, nada mais. Como diz Tim, a prática aprimora o código quando se evita o excesso de engenharia.

11. Desconstrução

Partindo do princípio das tuplas, Tim mostra como decompor os resultados em variáveis ​​locais:

var (firstName, lastName) = SplitName("Tim Corey");

var (firstName, lastName) = SplitName("Tim Corey");

Isso mantém os nomes das variáveis ​​descritivos e evita a sintaxe críptica de tuplas posteriormente. Tim chega a mencionar o descarte de valores não utilizados (usando _), o que sinaliza a intenção — nenhum nome de variável de uma única letra fica sem explicação.

12. Descartar valores desnecessários

Se você não precisa de todas as partes da tupla, Tim recomenda o descarte:

var (firstName, _) = SplitName("Tim Corey");

var (firstName, _) = SplitName("Tim Corey");

Isso mostra a outros desenvolvedores que você está ignorando um valor intencionalmente — o que é útil para testar frameworks ou testes unitários onde nem todas as saídas importam.

13. Usando instruções sem blocos

Tim passa a atuar na gestão de recursos e no tratamento de erros. Antes, você escreveria:

using (var connection = new SqlConnection(connString))
{
    // work
}

using (var connection = new SqlConnection(connString))
{
    // work
}

Agora você pode usar:

using var connection = new SqlConnection(connString);

using var connection = new SqlConnection(connString);

Isso está em consonância com os princípios SOLID — especificamente o princípio da responsabilidade única e o princípio da inversão de dependência. Tim observa que essa sintaxe funciona bem para dependências externas, como bancos de dados, garantindo que o tratamento de exceções seja mais eficiente e que as conexões sejam sempre fechadas, evitando problemas de desempenho ou até mesmo cenários de injeção de SQL quando as conexões não são descartadas.

14. Declarações de variáveis ​​em linha

Por fim, Tim aborda a declaração de variáveis ​​inline para tarefas como análise sintática:

if (int.TryParse(numberText, out int numberValue))

if (int.TryParse(numberText, out int numberValue))

Aqui, você cria a variável local na mesma linha. Isso mantém as convenções de codificação consistentes e os nomes dos métodos descritivos. Ao manter o código devidamente agrupado, você reduz comportamentos inesperados e torna os esforços futuros de refatoração do código mais seguros.

Concluindo

Tim encerra seu vídeo lembrando aos espectadores: essas simplificações não se tratam de escrever frases enigmáticas — elas têm a ver com boas práticas de programação. Recursos como o uso de static, registros, correspondência de padrões, tuplas e descartes permitem escrever código C# limpo e moderno.

Ele incentiva os desenvolvedores a pensarem em convenções de nomenclatura, tratamento de erros e nomes significativos ao adotarem esses recursos. "O código foi feito para ser lido por humanos", diz Tim — e quando você escreve um código fácil de entender, você torna a vida melhor para si mesmo e para outros desenvolvedores.

Resumindo: adote essas boas práticas de C#, siga os princípios SOLID, como o princípio da responsabilidade única, o princípio da segregação de interfaces e o princípio da inversão de dependências, e seu código não apenas compilará — ele também melhorará o desempenho, reduzirá comportamentos inesperados e manterá sua equipe satisfeita com a programação.