Back-End

18 abr, 2018

LINQ – Consultas com estilo Fluent e Query Expression – Parte 01

Publicidade

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.

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 Enumerable(namespaceSystem.Linq).

  1. O operador Where emite uma versão filtrada da sequência de entrada;
  2. O operador OrderBy emite uma versão ordenada de sua sequê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.