C# - Cinco erros que você deve evitar

 Hoje veremos cinco erros que você deve e pode evitar ao programar na linguagem C#.

Errar é humano , e, os programadores sempre cometerão erros.. 

Geralmente uma grande parte dos desenvolvedores C#, aprendem e se aprimoram por tentativa e erro.

Embora essa "estratégia" de tentativa e erro funcione, se um desenvolvedor não detectar os erros, eles podem causar muitos problemas no software desenvolvido.

Neste artigo, veremos 5 erros mais comuns que muitos programadores C# cometem e como evitá-los.

1- Concatenação de strings sem usar StringBuilder

A maneira mais comum de concatenar strings é muito simples de entender. Mas você deve se lembrar que strings são imutáveis.

Assim, cada vez que algo é adicionado a uma string, um novo endereço é alocado na memória automaticamente. A string anterior é copiada para a nova parte com a localização alterada, e isso não é de forma alguma eficiente.

Veja o exemplo abaixo:

List<string> nomes = new List<string>() { "Maria", "Manoel", "Pedro" };
string lista = string.Empty;
foreach (var nome in nomes)
{
    lista += nome; // Cria uma cópia da string
}

A maneira de resolver isso é simples, você deve usar o objeto StringBuilder em vez da concatenação de string que manterá a mesma posição na memória sem realizar nenhuma cópia.

Isso torna o processo de concatenação de strings muito mais simples e eficiente, para que possamos anexar perfeitamente todas as operações que desejamos.

using System.Text;
List<string> nomes = new List<string>() { "Maria", "Manoel", "Pedro" };
StringBuilder lista = new StringBuilder();
foreach (var nome in nomes)
{
    lista.Append(nome);
}

2- Iterando com valores usando um laço foreach

Este erro ocorre quando você tenta iterar listas de registros com um laço foreach. E isso não é nada ideal.

foreach (Cliente cliente in listaClientes) 
{
    if (cliente.Estado == "SP") {
        taxa += cliente.Valor;
  }

A forma mais eficiente é usar LINQ que permite consultar os objetos facilmente:

 
 taxa = ListaClientes.Where(cliente => cliente.Estado.Equals("SP")).Sum(c=>c.Valor);

3- Não usar o return yield

Isso é para quando você precisa criar uma enumeração de objeto para algum outro chamador. O uso desta função melhorará muito o desempenho.

Em geral, usamos a palavra reservada yield em métodos que retornam o tipo IEnumerable ou IEnumerable<T>.

O tipo de retorno do método iterador é IEnumerable que é um tipo de interface de iterador. Quando o método iterador é chamado, ele retorna um objeto enumerável que contém o resultado.

Assim, yield return é semelhante a uma declaração return (que passa o controle do fluxo método de chamada), seguido de um "goto" para a declaração yield na próxima iteração do foreach.

Podemos então usar o yield para gerar um Enumerable de qualquer coisa como por exemplo gerar um coleção de números inteiros:

    class Program
    {
        static void Main(string[] args)
        {
            var numeros = Numeros(0, 10);
            foreach(int num in numeros)
            {
                Console.WriteLine(num);
            }
            Console.ReadKey();
        }
        public static IEnumerable<int> Numeros(int inicio, int fim)
        {
            for (int i = inicio; i <= fim; i++)
                yield return i;
        }
     }

4- Não conhecer a importância do USING para o descarte de objetos

Muitos desenvolvedores C# não estão familiarizados com o conceito de que a palavra-chave using não é apenas usada como uma diretiva para adicionar namespaces, mas também é muito benéfica para a remoção de objetos.

Se você tiver certeza de que um objeto deve ser excluído ao executar certas ações, simplesmente use a instrução using para certificar-se de que o objeto foi excluído corretamente.

Exemplo de código usando using para descartar os objetos usados:

private static void UsandoUsing()
{
     string texto = "";
     string sConnString = "Data Source=Macoratti;Initial Catalog=Northwind;Integrated Security=True";
      string sSql = "SELECT CategoryID, CategoryName FROM Categories ORDER BY CategoryName";
       try
        {
           using (SqlConnection cn = new SqlConnection(sConnString))
           {
              using (SqlCommand cmd = new SqlCommand(sSql, cn))
              {
                   cn.Open();
                   using (SqlDataReader rdr = cmd.ExecuteReader())
                    {
                        while (rdr.Read())
                         {
                              texto += rdr["CategoryName"].ToString() + Environment.NewLine;
                          }
                         Console.WriteLine(texto);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

Qualquer coisa declarada na instrução using somente pode ser acessada apenas dentro do seu bloco. Se você quiser fazer referência a variáveis ou objetos fora da instrução using (ou bloco try), tem que declará-los antes de iniciar a instrução.

Então usamos a instrução using pois ela chama o método 'dispose' internamente, sempre que qualquer exceção ocorrer.

Assim todo o tipo que implementa IDisposable em um bloco using terá os recursos liberados da memória sem precisar esperar o coletor de lixo.

7. Usar algoritmos criptográficos fracos

Este é um erro que é simplesmente baseado no fato de que muitos desenvolvedores usam algoritmos de criptografia obsoletos ou vulneráveis (o que é muito fácil de evitar).

Neste caso temos um exemplo onde estamos usando SHA1 ou RIPEMD160, que não oferecem um nível de segurança atual e muito bom.

using System.Security.Cryptography;   
...   
var cifragem = SHA1.Create();

A solução para isso é usar algoritmos de criptografia mais fortes, por exemplo:

Usar SHA256 em vez de SHA1, usar SHA512 em vez de RIPEMD160 e usar AES em vez de TripleDES.

Acompanhe o meu mini-curso de Criptografia neste link : Mini-Curso Criptografia

E estamos conversados...

"A minha porção é o Senhor, diz a minha alma; portanto esperarei nele."
Lamentações 3:24

Referências:

José Carlos Macoratti