C#  -  Cinco conceitos básicos que você tem que conhecer


 Neste artigo vou mostrar cinco conceitos básicos que todo o desenvolvedor C# tem a obrigação de conhecer e usar.

Existem alguns recursos na linguagem C# que todo o desenvolvedor precisa conhecer e usar. Eles são como a tabuada, devem ser incorporados e usados de forma sistemática no dia a dia.

Neste artigo eu apresento esses cinco conceitos básicos que você tem que conhecer.

Recursos Usados

Criando o projeto Console Application

Abra o VS 2015 Community e crie um novo projeto (File-> New Project) usando a linguagem C# e o template Console Applicaiton.

Informe um nome a seu gosto. Eu vou usar o nome CSharp_CincoConceitosBasicos;

1- Usando o método de Extensão Any

O método Any recebe um Predicate e determina se qualquer elemento em uma coleção corresponde a uma determinada condição.

Você pode fazer isso de forma imperativa usando um laço foreach, mas, o método de extensão Any fornece uma maneira que otimiza o seu código reduzindo o seu tamanho.

Nota: O Delegate Predicate representa o método que define um conjunto de critérios e determina se o objeto especificado atende os critérios. ( C# - Apresentando o delegate Predicate )

Exemplo:

 private static void UsandoListComAny()
        {
            int[] array = { 1, 2, 3 };
            // Verifica se qualquer elemento é divisível por 2         
            bool t1 = array.Any(item => item % 2 == 0);
            // Verifica se qualquer elemento é maior que 3
            bool t2 = array.Any(item => item > 3);
            // Verifica se qualquer elemento é igual a 2
            bool t3 = array.Any(item => item == 2);
            // Exibe o resultado no console
            Console.WriteLine(t1);
            Console.WriteLine(t2);
            Console.WriteLine(t3);
        }

Agora veja esse código :

        private static void UsandoListComAnyException()
        {
            var lista = new List<String> { };
            Console.WriteLine(lista.Any());    //retorna False  (Não lança Exception)      

            lista = null;
            Console.WriteLine(lista.Any());   //lança Exception      
        }

Observe que quando a lista esta vazia (Empty) Any retorna False e não lança uma Exception. E se eu usar o método Count() ele retorna o valor zero.

Se a lista for inicializada com null então temos uma Exception. Para contornar esse problema verifique antes se a lista é null antes de chamar Any:

        private static void UsandoListComAnyException()
        {
            var lista = new List<String> { };
            Console.WriteLine(lista.Any());    //retorna False  (Não lança Exception)      

            lista = null;

            if( lista != null )
                Console.WriteLine(lista.Any());   
        }

Agora evitamos a Exception.

2- Usando o foreach em um List<T>

Com um laço foreach, avaliamos cada elemento individualmente. Não é necessário um índice. Sem índices, os loops são mais fáceis de escrever e os programas são mais simples.

Exemplo:

     private static void UsandoForeach()
        {
            string[] animais = { "cachorro", "gato", "papagaio" };
            // ... Laço usando foreach
            foreach (string valor in animais)
            {
                Console.WriteLine(valor);
            }
        }

Mas e se a lista a ser percorrida esta vazia (Empty) ? E se a lista estiver inicializada com null ?

Exemplo:

        private static void UsandoForeachEmList()
        {
            var lista = new List<string> { };
            foreach(var item in lista)
            {
                Console.WriteLine(item);    // Sem Exception
            }
            lista = null;
            foreach (var item in lista)      // Com Exception
            {
                Console.WriteLine(item);
            }
        }

Se a lista estiver vazia(Empty) o laço foreach será executado sem lançar uma Exception.

Se a lista for null então ao entrar no laço será lançada uma NullReferenceException.

Para contornar o problema verifique antes se a lista é null:

        private static void UsandoForeachEmList()
        {
            var lista = new List<string> { };
            foreach(var item in lista)
            {
                Console.WriteLine(item);    // Sem Exception
            }
            lista = null;
            if (lista != null)
         {
                foreach (var item in lista)
                {
                    Console.WriteLine(item);
                }
        }
        }

Agora verificamos se a lista é null antes de executar o laço foreach.

3- Usando o método Replace da classe String

Usamos o método Replace() da classe String para procurar e substituir um padrão por outro na string. A alteração é feita e uma nova string é retornada.

Para obter a nova string precisamos receber o resultado retornado pela aplicação do método Replace() a uma variável. Observe que a string original não é alterada.

Exemplo:

      private static void UsandoStringReplace()
        {
            const string origem = "Macoratti .Net Quase tudo para a plataforma .Net";
            Console.WriteLine(origem);
            // Precisamos atribuir o resultado a uma variável
            // ... Cada instãncia da substring é substituida.
            string resultado = origem.Replace("Net", "Teste");
            Console.WriteLine(resultado);
        }

O que acontece se usarmos o método Replace para substituir uma substring que não existe na String ?

Exemplo :

        private static void UsandoStringReplace2()
        {
            const string origem = "Macoratti .Net Quase tudo para a plataforma .Net";
            Console.WriteLine(origem);
            // Precisamos atribuir o resultado a uma variável
            // ... Cada instãncia da substring é substituida.
            string resultado = origem.Replace("microsoft", "Teste");
            Console.WriteLine(resultado);
        }

Nenhuma Exception é lançada. Portanto você não precisa verificar antes se a string contém a substring [ origem.Contains("microsoft") ] que deseja alterar.

Lembre-se sempre:

4- Usando a classe Stopwatch para verificar o tempo decorrido

A classe Stopwatch pode ser usada para medir o tempo decorrido de uma transação ou tarefa. Ela é útil para realizar micros-benchmarks na otimização de código podendo executar o monitoramento de desempenho.

Para medir o tempo decorrido de uma operação C# basta criar uma instância da classe Stopwatch e usar os métodos Start para iniciar a contagem e Stop para encerrar a contagem do tempo decorrido. O método Elapsed() retorna o tempo decorrido total medido pela instância atual. ( ElapsedMilliseconds o tempo decorrido total medido pela instância atual, em milisegundos. )

Exemplo :

       using System.Diagnostics;
       private static void UsandoStopwatch()
        {
            var sw = new Stopwatch();
            sw.Start();
            for(int i=0;i< 1000000; i++)
            {
                //não faz nada
            }
            sw.Stop();
            Console.WriteLine("Tempo gasto : " + sw.ElapsedMilliseconds.ToString() + " milisegundos");
        }
 

Exemplo 2:  Apresentando o resultado usando uma formtação com Elapsed():

       using System.Diagnostics;
       private static void UsandoStopwatch2()
       {
            var sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < 100; i++)
            {
                System.Threading.Thread.Sleep(20);
            }
            sw.Stop();
            Console.WriteLine("Tempo gasto : " + sw.ElapsedMilliseconds.ToString() + " milisegundos");
            Console.WriteLine("Tempo decorrido: {0:hh\\:mm\\:ss}", sw.Elapsed);
      }

A classe Stopwatch esta presente no namespace System.Diagnostics.

5- Chamando um método Async a partir de um método não Async

Para criar código assíncrono usamos as palavras chaves async e await, onde por padrão, um método modificado por uma palavra-chave async contém pelo menos uma expressão await.

O método é executado de forma síncrona até que ele alcance a primeira expressão await, e, neste ponto, o método é suspenso até que a tarefa seja completada. Enquanto isso , o controle retorna para o chamador do método.

Se um método que esta sendo modificado por uma palavra-chave async não contiver uma expressão ou uma instrução await, o método é executado de forma síncrona. Um alerta do compilador o avisa sobre qualquer método assíncrono que não contiver um await porque essa situação pode indicar um erro.

Quando async modifica um método, uma expressão lambda ou um método anônimo, async é uma palavra-chave. Em todos os outros contextos, async é interpretado como um identificador. Esta distinção faz async uma palavra-chave contextual.

Um método async (assíncrono) pode ter um tipo de retorno Task, Task(Of TResult) ou void. O método não pode declarar qualquer parâmetro ref ou out, embora ele pode chamar métodos que tenham esses parâmetros.

Exemplo:

Observe que estou tentando chamar o método Async : MetodoAsycn() usando a palavra chave await, mas temos um aviso do compilador que alerta que este método so pode ser usado com um método async.

Para resolver o problema eu teria que declarar a palavra async no método Main().

Mas ao tentar fazer isso obtenho o erro mostrado abaixo:

Como resolver este problema ???

       static void Main(string[] args)
        {
            MetodoAsync().Wait();
            Console.ReadLine();
        }
        private static async Task MetodoAsync()
        {
            Console.WriteLine("Inicio da execução :: MetodoAsync");
            await Task.Delay(5000);
            Console.WriteLine("Fim da execução :: MetodoAsync");
        }

 

Usando o método Wait() resolvemos o problema.

Podemos também usar outra abordagem conforme mostrada no código abaixo:

       static void Main(string[] args)
        {
          //MetodoAsync().Wait();
            Task.Run(async () => { await MetodoAsync(); }).Wait();
            Console.ReadLine();
        }
        private static async Task MetodoAsync()
        {
            Console.WriteLine("Inicio da execução :: MetodoAsync");
            await Task.Delay(5000);
            Console.WriteLine("Fim da execução :: MetodoAsync");
        }

 

Agora estamos executando o método MetodoAsync() a partir do método assíncrono Main().

Espero que essas dicas te ajudem no estudo da linguagem C#.

Pegue o projeto completo aqui :  CSharp_CincoConceitosBasicos.zip

Se dissermos que temos comunhão com ele (Jesus), e andarmos em trevas, mentimos, e não praticamos a verdade.
Mas, se andarmos na luz, como ele na luz está, temos comunhão uns com os outros, e o sangue de Jesus Cristo, seu Filho, nos purifica de todo o pecado.

1 João 1:6,7

 

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 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

 

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

 

Referências:


José Carlos Macoratti