C# - Dicas valiosas

C# - Cinco dicas valiosas

Neste artigo vou apresentar cinco dicas valiosas para a linguagem C# que você pode aplicar no seu código.

Este é mais um artigo sobre dicas sobre a linguagem C#.

1- Número anulável

Essa dica se baseia em saber que os números PODEM aceitar nulos. Essa dica é estranha para muitos desenvolvedores de outras linguagens pois usaremos o símbolo ? após o tipo de dados.

Neste caso usaremos int mas primeiro vamos ver como ficaria sem o símbolo ?

Ao executar o código acima teremos um erro indicado em Error List.

Agora vamos incluir o simbolo ? na definição do tipo do numero :

O int? é uma forma abreviada para Nullable<int>, o que significa que a variável pode armazenar valores inteiros normais ou pode ser null. O null indica a ausência de valor.

A linha int? numero = null; está inicializando a variável numero com o valor null, indicando que inicialmente não há um valor inteiro atribuído a essa variável.

2- Valor somente leitura

Em uma instrução de campo, readonly indica que a atribuição a um campo só pode ocorrer como parte da declaração ou em um construtor da mesma classe. Ou seja, SOMENTE LEITURA.


 public static readonly string Url = "macoratti.net";

A palavra-chave readonly indica que o valor da constante é atribuído apenas uma vez e não pode ser alterado depois de ser atribuído.

Essa constante, "macoratti.net", pode ser acessada a partir de qualquer lugar que tenha visibilidade para a classe que a contém.

Um exemplo de uso de readonly está na string de conexão com um banco de dados, pois ela é sempre a mesmo e não nos interessa que alguém possa alterá-la.

O Readonly é curioso porque : se é para ser uma variável que só pode ser lida e não modificada…

Poderia a definição de constante ser aplicada a ela ?

O uso de readonly em C# e a definição de constantes (const) são distintos, mas ambos têm a propriedade de tornar uma variável imutável após sua atribuição inicial. No entanto, existem diferenças importantes entre readonly e const.

readonly

Uma variável readonly é atribuída em tempo de execução ou no construtor da classe.
Pode ser atribuída um valor diferente em diferentes instâncias da classe.
O valor é determinado em tempo de execução e pode ser diferente para cada instância da classe.

const

Uma constante (const) é atribuída em tempo de compilação e é considerada uma verdadeira constante.
O valor é determinado em tempo de compilação e é o mesmo para todas as instâncias da classe ou para todas as ocorrências no escopo.
Deve ser atribuída um valor constante literal, como números ou strings literalmente definidas, e não pode ser atribuída a partir de uma expressão em tempo de execução.

O readonly é mais flexível, pois permite atribuição em tempo de execução e pode ter valores diferentes em diferentes instâncias, enquanto const é mais rígido, garantindo um valor constante durante a compilação e sendo o mesmo para todas as instâncias

3- Usando tuplas

As Tuplas são uma estrutura de dados em C# que permitem agrupar elementos de diferentes tipos em uma única unidade. Elas são introduzidas no C# 7.0 e fornecem uma maneira mais flexível e conveniente de trabalhar com conjuntos de valores relacionados.

Antes do uso de tuplas, a alternativa seria criar uma classe ou uma estrutura para armazenar esses valores, o que poderia ser um pouco verboso para casos simples.

Sintaxe básica : var minhaTupla = (valor1, valor2, valor3);

Às vezes é melhor usar uma tupla contendo valores digitados do que usar classes, especialmente quando a estrutura de dados criada só será usada em um momento específico.

4- Usando yield

O recurso yield é usado em métodos para criar iteradores personalizados. Ele permite que você retorne uma sequência de valores de um método sem ter que criar uma coleção completa em memória.

O yield é especialmente útil quando você está trabalhando com grandes conjuntos de dados ou quando deseja criar sequências de dados sob demanda.

Vamos considerar um exemplo onde queremos gerar uma sequência de números pares até um determinado limite sem criar uma coleção temporária:

foreach (var numero in ExemploYield.GerarNumerosPares(10))
{
Console.WriteLine(numero);
}

Console.ReadLine();

public class ExemploYield
{
public static IEnumerable<int> GerarNumerosPares(int limite)
{
    for (int i = 0; i < limite; i += 2)
    {
        yield return i;
    }
}
}

Neste exemplo, não estamos criando uma coleção temporária para armazenar todos os números pares até o limite. Em vez disso, estamos usando yield para gerar os números sob demanda enquanto iteramos pela sequência.

Quando Usar o yield:

Quando você precisa gerar uma sequência de dados sob demanda.
Quando lidar com grandes conjuntos de dados e deseja evitar o armazenamento em memória de toda a coleção.
Quando a criação de uma coleção temporária não é eficiente ou necessária para a lógica do seu programa.

Quando Não Usar o yield:

Quando você precisa acessar os elementos da sequência várias vezes.
Quando a sequência é pequena e não há preocupação significativa com o uso de memória.
Quando a lógica do seu programa é mais clara ao usar uma coleção completa.

O yield é poderoso em situações onde a eficiência no uso de memória é crucial e onde você pode trabalhar com a sequência de maneira incremental. No entanto, em alguns casos, a criação de uma coleção temporária pode ser mais apropriada para facilitar o acesso repetido aos dados.

5- As Consultas LINQ são adiadas

Na LINQ (Language Integrated Query), a execução de uma consulta LINQ é adiada até que seja realmente necessária. Isso significa que a avaliação da consulta não ocorre no momento em que ela é definida, mas sim quando é necessária, muitas vezes durante o acesso aos resultados.

Assim, quando uma consulta é feita na LINQ ela só é executada quando os resultados são acessados. Isso é chamado de execução adiada. Para que a consulta seja executada apenas uma vez, devemos utilizar o método ToList.

Essa característica de adiamento é chamada de "adiamento de execução" (deferred execution) e é um conceito chave em LINQ. O adiamento de execução proporciona benefícios em termos de eficiência e permite que o código seja mais flexível.

Aqui está um exemplo para ilustrar o adiamento de execução em LINQ:

A consulta LINQ é definida usando o método Where, que filtra os números pares da lista. No entanto, observe que a execução real da consulta ainda não ocorreu neste ponto.

A execução da consulta ocorre quando iteramos sobre os resultados usando um loop foreach. Neste ponto, a expressão Where é avaliada e os resultados são retornados.

A saída do programa mostra que a mensagem "Consulta definida, mas ainda não executada" é exibida antes da iteração sobre os resultados, indicando que a execução da consulta foi adiada até ser realmente necessária.

Esse adiamento de execução permite que você defina consultas LINQ complexas sem que elas sejam executadas imediatamente, economizando recursos computacionais e permitindo que você construa consultas de maneira mais flexível.

E estamos conversados...

"Os dias da nossa vida chegam a setenta anos, e se alguns, pela sua robustez, chegam a oitenta anos, o orgulho deles é canseira e enfado, pois cedo se corta e vamos voando."
Salmos 90:10

Referências:

José Carlos Macoratti