C# -  Os erros mais comuns cometidos pelos iniciantes - II


Hoje veremos alguns dos erros mais comuns cometidos pelos iniciantes e não iniciantes na linguagem C#.

Continuando a primeira parte do artigo continuo apresentando alguns dos erros mais comuns cometidos por iniciantes na linguagem C#.

Recursos usados:

4 - Iterando através de uma coleção ao invés de usar a LINQ

A LINQ foi introduzia na versão 3.0 da linguagem C# mudando para sempre a forma como consultar e manipular coleções.

Então se você ainda usa instruções iterativas, como um laço foreach para manipular coleções, pode estar gerando um código ineficiente.

Imagine ter uma coleção com 100.000 clientes e percorrer cada um deles para encontrar um conjunto de dados específicos. Isso não é eficiente.

Assim, ao invés de usar laços para iterar sobre a coleção, use os recursos da LINQ (Language-Integrated Query), que é um recurso da plataforma .NET integrado e projetado para facilitar a consulta de objetos, como coleções e listas.

Veja este exemplo:

Usando laço foreach Usando LINQ
using System;
namespace CSharp_Erros1
{
    class Program
    {
        static void Main(string[] args)
        {
            var listaClientes = ClienteService.GetClientes();
            decimal? taxa = null;

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

            Console.ReadLine();
        }
    }
}

using System;
namespace CSharp_Erros1
{
    class Program
    {
        static void Main(string[] args)
        {
            var listaClientes = ClienteService.GetClientes();
            var clientes = (from cliente in listaClientes  
                                    where cliente.Estado == "SP"  
                                    select cliente.Saldo).Sum();
            Console.ReadLine();
        }
    }
}

Com uma única linha de código LINQ você retorna os clientes desejados sem ter que percorrer a coleção inteira para fazer isso.

Você só tem que ter cautela para cenários onde o desempenho é crítico e, neste caso , comparar o desempenho da consulta LINQ para ver se ela não impacta demais o desempenho.

5 - Usando variáveis de classe pública ao invés de propriedades

Propriedades são um lugar comum para a programação orientada a objetos (OOP), mas por que usá-las quando você pode apenas tornar públicas todas as suas variáveis ​​de classe ?

Resposta:  Você pode controlar quem pode definir uma propriedade com propriedades da OOP, mas não pode fazer isso com uma variável pública.

      static void Main(string[] args)
       {
            Teste teste = new Teste();
            //Temos acesso a variável publica e podemos atribuir qualquer valor a ela
            teste.numeroConta = "ZZZZZZZZZ";
            Console.ReadKey();
        }
        public class Teste
        {
            public string numeroConta;
            public Teste()
            {
                numeroConta = "XXXXX";
            }
        }

Observe que foi definida uma variável pública(numeroConta) que é usada no construtor da classe Teste().

Esse descuido fere o encapsulamento visto que qualquer pode criar uma instância da classe e acessar a variável publica alterando o seu valor.

O correto é usar uma propriedade para definir a variável pública numeroConta conforme o código a seguir:

        public class Teste()
        {
            private string _numeroConta;
            public string NumeroConta
            {
                 get { return _numeroConta} ;
            }

            public Teste()
            {
                _numeroConta = "XXXXX";
            }
        }

Agora temos uma propriedade NumeroConta() que permite somente acessar o valor da variável, alterações não são permitidas.

A classe Teste agora tem controle sobre NumeroConta.

Quando precisar de uma variável global faça isso usando uma propriedade.

Sentiu o drama ???

6 - Não liberar os objetos usados

Vazamentos de memória (também chamados vazamentos de recursos) são um problema real para qualquer aplicativo.

A linguagem  C# fornece uma maneira conveniente de chamar o método Dispose depois que você terminar de usar um objeto. Assim, você nem precisa se lembrar de usá-lo.

A instrução "using" eliminará um objeto e evitará vazamentos de memória problemáticos.

Veja esse código ineficiente :


   arquivo.Read (buffer, 0, 100);
 

No código acima, se você não descartar o objeto arquivo, viar criar um vazamento de memória no aplicativo. Você pode evitar essa situação com a instrução using.

Este código é mais eficiente :

using (FileStream arquivo = File.OpenRead ("numeros.txt"))
{
     arquivo.Read (buffer, 0, 100);
}

Agora o aplicativo lê um arquivo e descarta o objeto quando ele for concluído.

A instrução using chama o método Dispose no objeto da maneira correta, e também faz com que o próprio objeto saia do escopo assim que Dispose for chamado.

Dentro do bloco using, o objeto é somente leitura e não pode ser modificado ou reatribuído.

A instrução using garante que Dispose seja chamado mesmo se ocorrer uma exceção enquanto você estiver chamando métodos no objeto.

Na terceira parte do artigo vou continuar a falar sobre os erros mais comuns.

Aguarde...

'Agora é o juízo deste mundo; agora será expulso o príncipe deste mundo.
E eu, quando for levantado da terra, todos atrairei a mim.
E dizia isto, significando de que morte havia de morrer.'

João 12:31-33

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:


José Carlos Macoratti