C# - LINQ : Prefira usar a sintaxe de consulta a loops

 Neste dica de utilização de LINQ usando a linguagem C# veremos que é preferível usar a sintaxe de consulta a usar laços.

A linguagem C# possui diversos recursos para controlar estruturas usando laços como : for, while, do/while, e foreach.  Mas apesar disso existe uma forma melhor de realizar essa tarefa usando a sintaxe de consulta.

A sintaxe de consulta permite que você mova a lógica do seu programa de um modelo mais imperativo para o modelo declaratório. Ela define a questão e difere a decisão sobre como criar a resposta para uma implementação particular.

Você pode obter os mesmos benefícios da sintaxe de chamada de método usando a sintaxe de consulta. O ponto importante é que a sintaxe de consulta e por extensão a sintaxe de método que implementa o padrão de expressão da consulta fornece uma expressão mais clara da sua intenção do que usar a construção com loops imperativos.

Recursos Usados:

LINQ - Usando a sintaxe de consulta

Abra o VS 2017 Community e crie um projeto do tipo Console Application com o nome CShp_QuerySyntax.

Vamos começar com uma tarefa bem simples: preencher um array e imprimir o seu contéudo no console.

1 - Primeiro veremos o código de como fazer isso usando a abordagem tradicional usando estruturas de controle : for e foreach:

using static System.Console;
namespace CShp_QuerySintax
{
    class Program
    {
        static void Main(string[] args)
        {
            var vetor = new int[100];
            for (var num = 0; num < vetor.Length; num++)
                  vetor[num] = num * num;
            foreach (int i in vetor)
                WriteLine(i.ToString());
            ReadLine();
        }
    }
}
  

Este pequeno exemplo mostra uma abordagem que foca demais sobre como as ações são realizadas ao invés de quais ações são realizadas.

Vamos alterar o código do exemplo usando a sintaxe de consulta para criar um código mais legível e permitir sua reutilização em diferentes blocos de consulta.

1 - Alterando a geração do array usando a sintaxe de consulta

   var vetor = new int[100];
  for (var num = 0; num < vetor.Length; num++)
        vetor[num] = num * num;
    var vetor = (from n in Enumerable.Range(0, 100)
                     select n * n).ToArray();
usando laços for e foreach usando a sintaxe de consulta

2 - Alterando a exibição dos valores no console

   foreach (int i in vetor)
                WriteLine(i.ToString());
    vetor.AsParallel().ForAll((n) => WriteLine(n.ToString()));
usando laços for e foreach usando a sintaxe de consulta

Resumindo o código final substituído ficaria assim:

using System.Linq;
using static System.Console;
namespace CShp_QuerySintax
{
    class Program
    {
        static void Main(string[] args)
        {
            var vetor = (from n in Enumerable.Range(0, 100)
                              select n * n).ToArray();

            vetor.AsParallel().ForAll((n) => WriteLine(n.ToString()));
            ReadLine();
        }
    }
}

Mais simples e mais elegante.

Vejamos outra tarefa um pouco mais complexa. Suponha que você precise gerar pares (X,Y) para todos os numeros inteiros de 0 a 99 onde a soma de X com Y seja menor que 100.

1 - Veja a abordagem tradicional usando loops:

        private static IEnumerable<Tuple<int, int>> ProduzirIndices()
        {
            for (var x = 0; x < 100; x++)
                for (var y = 0; y < 100; y++)
                    if (x + y < 100)
                        yield return Tuple.Create(x, y);
        }

 

2 - Agora o mesmo código usando a sintaxe de consulta:

        private static IEnumerable<Tuple<int, int>> ProduzirIndices2()
        {
            return from x in Enumerable.Range(0, 100)
                      from y in Enumerable.Range(0, 100)
                      where x + y < 100
                      select Tuple.Create(x, y);
        }

A sintaxe de consulta é mais clara quanto a intenção do código e leva a construção de algoritmos como pequenos blocos de código que executam uma operação em uma seqüência. Além disso o modelo de execução diferida para as consultas permite ao programador compor operações simples em várias operações que podem ser realizadas em uma enumeração da sequência. Junte a isso a possibilidade de de você executar a consulta em paralelo usando o método AsParallel().

É claro que não para todo o código que você pode usar a sintaxe de consulta. Métodos como Take, TakeWhile, Skip, SkipWhile, Min e Max não possuem equivalente na sintaxe de consulta.

Cabe o bom senso em saber usar o recurso da sintaxe de consulta para tornar o código mais legível e aproveitar os seus recursos.

Antes, como ministros de Deus, tornando-nos recomendáveis em tudo; na muita paciência, nas aflições, nas necessidades, nas angústias,Como contristados, mas sempre alegres; como pobres, mas enriquecendo a muitos; como nada tendo, e possuindo tudo. 
 2 Coríntios 6:4,10

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