LINQ - Consultas com estilo Fluent e Query Expression - II

Neste artigo vou apresentar o estilo Fluent e o estilo Query Expression para criar consultas LINQ.

Se você não conhece os conceitos básicos sobre LINQ leia meus artigos citados nas referências. Neste artigo eu vou falar um pouco sobre LINQ Queries e os estilos para escrever consultas LINQ.

Existem dois estilos para escrever consultas LINQ:

  1. Fluent style ou Fluent sintax

  2. Query Expression Style   

Continuando o artigo anterior vamos abordar o Query Expression Style.

2- Query Expression Style

A sintaxe Query Expression nas consultas LINQ é um conjunto de palavras-chave de consulta incorporadas no framework .NET (3.5 e superior) que permitem ao desenvolvedor escrever comandos ao estilo SQL na linha diretamente no editor de código, sem o uso de aspas.

As principais palavras-chaves de consultas usadas na sintaxe Query Expression são:

Em uma consulta LINQ usando Query Expression como no exemplo abaixo:

 int[] numeros = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 var resultado = from numero in numeros select numero;

observe que temos uma lógica de declaração invertida em relação a uma consulta SQL. Compare:

SQL select numero from numeros
LINQ from numero in numeros select numero;

Percebeu que no código definimos uma variável chamada numero do tipo integer? (O tipo esta sendo inferido pelo compilador pois não esta declarado no código.)

A variável resultado também esta sendo inferida como sendo do tipo Sytem.Collections.Generic.IEnumerable<int>.

Agora vamos ao nosso exemplo...

Abaixo vemos o mesmo código usado na primeira parte do artigo usando o estilo Query Expression na consulta LINQ:

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQ_Consultas
{
    class Ingrediente
    {
        public string Nome { get; set; }
        public int Calorias { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Ingrediente[] ingredientes =
            {
                new Ingrediente{Nome = "Açucar", Calorias=500},
                new Ingrediente{Nome = "Ovo", Calorias=100},
                new Ingrediente{Nome = "Leite", Calorias=150},
                new Ingrediente{Nome = "Farinha", Calorias=50},
                new Ingrediente{Nome = "Manteiga", Calorias=200},
                new Ingrediente{Nome = "Oléo", Calorias=160}
            };
                      IEnumerable<string> consultaIngredientesComMaisCalorias =
                                            from i in ingredientes
                                            where i.Calorias >= 150
                                            orderby i.Nome
                                            select i.Nome;
            foreach (var ingredienteNome in consultaIngredientesComMaisCalorias)
            {
                Console.WriteLine(ingredienteNome);
            }
           Console.ReadLine();
        }
    }
}

Vamos considerar o código da consulta LINQ abaixo e do resultado obtido ao lado :

       IEnumerable<string> consultaIngredientesComMaisCalorias =
                                            from i in ingredientes
                                            where i.Calorias >= 150
                                            orderby i.Nome
                                            select i.Nome;

 

   foreach (var ingredienteNome in consultaIngredientesComMaisCalorias)
   {
          Console.WriteLine(ingredienteNome);
   }

As etapas que são executadas são as mesmas que na versão de sintaxe fluente, com cada cláusula de consulta (from, where, orderby, select) passando uma seqüência modificada para a próxima cláusula de consulta.

A expressão de consulta começa com a cláusula from. Esta cláusula tem dois propósitos:

1- O primeiro é descrever qual é a seqüência de entrada (neste caso, ingredientes);
2- O segundo é apresentar uma variável de alcance(range)

A cláusula final é a cláusula select, que descreve o que a sequência de saída será. Assim como com a versão de sintaxe fluente, a cláusula select no código acima está projetando uma seqüência de objetos ingredientes em uma seqüência de objetos de string.
Entre as duas sintaxes a sintaxe Fluent apresenta um código mais limpo para consultas mais complexas, além do que a sintaxe Query Expression não suporta todos os operadores LINQ padrão.

Nota: Os métodos de extensão Count(), Aggregate(), Take(), Skip(), ToList(), ToArray() estão disponíveis apenas  na sintaxe Fluent.

Se você consultar a MSDN e analisar os exemplos, parece que a Microsoft prefere usar a Query Expression.

"E disse-lhes: Ide por todo omundo, pregai o evangelho a toda criatura. Quem crer e for batizado será salvo; mas quem não crer será condenado."
Marcos 16:15,16

Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti