LINQ - Consultas com estilo Fluent e Query Expression - I

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   

Vejamos cada um deles em detalhes.

1- Fluent Style

A sintaxe Fluent usa métodos de extensão do operador da consulta conforme definido na classe estática System.Linq.Enumerable.

Esses métodos de extensão adicionam métodos adicionais para instâncias de IEnumerable<TSource>, e , isso significa que qualquer instância de uma classe que implementa essa interface pode usar esses métodos de extensão.

Os operadores de consulta podem ser usados ​​de forma singular ou encadeados para criar consultas mais complexas. Vamos a um exemplo:

Operadores de consulta encadeados

Crie um projeto do tipo Console Application e inclua o código abaixo no arquivo Program.cs :

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 =
                                            ingredientes.Where(x => x.Calorias >= 150)
                                            .OrderBy(x => x.Nome)
                                            .Select(x => x.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 =
                               ingredientes.Where(x => x.Calorias >= 150)
                               .OrderBy(x => x.Nome)
                               .Select(x => x.Nome);

 

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


Nesta consulta temos uma cadeia de operadores de consulta. Cada operador funciona na sequência fornecida pelo operador de consulta anterior.

Os operadores de consulta Where, OrderBy e Select são operadores de consulta padrão que resolvem para os métodos de extensão na classe classe Enumerable(namespace System.Linq).

  1. O operador Where emite uma versão filtrada da sequencia de entrada;

  2. O operador OrderBy emite uma versão ordenada de sua seqüência de entrada;

  3. O método Select emite uma seqüência onde cada elemento de entrada é transformado com uma dada expressão lambda (x.Nome(), neste caso).

Observe que a entrada inicial, representada pela variável ingredientes, é do tipo IEnumerable<Ingrediente>,  enquanto a seqüência de saída (representada pela variável consultaIngredientesComMaisCalorias) , é um tipo diferente; é um IEnumerable <string>.

Neste exemplo, a cadeia de operadores está trabalhando com uma seqüência de elementos ingredientes até o operador Select transformar cada elemento na sequência; cada objeto de ingrediente é transformado em uma string simples.

Essa transformação é chamada de projeção: Os elementos de entrada são projetados em elementos de saída transformados.

A expressão lambda fornecida ao operador de consulta Select decide o  'formato' dos elementos na sequência de saída necessário.

A expressão lambda x => x.Nome está dizendo para o operador Select que "para cada elemento ingrediente, emita um elemento de string com o valor do Nome da propriedade do Ingrediente de entrada."

Na segunda parte do artigo abordaremos o estilo de consulta LINQ Query Expression.

'E Jesus lhe disse: Vai, a tua fé te salvou. E logo viu, e seguiu a Jesus pelo caminho. '
 Marcos 10:52

Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti