LINQ -  Revisitando conceitos básicos

Neste artigo estou fazendo uma revisão dos conceitos básicos sobre a LINQ : elementos, seqüência, interface IEnumerable, operadores de consulta, métodos de extensão, sintaxe lambda e a sintaxe de compreensão.

A LINQ ou Language Integrated Query, permite escrever consultas estruturadas de tipo seguro sobre coleções de objetos locais ou em fonte de dados remotas.

A LINQ permite que você consulte qualquer coleção que implemente a interface  IEnumerable <>, seja uma matriz, lista, XML DOM, ou fonte de dados remota (Como banco de dados SQL Server,Oracle, MySql,etc.). A LINQ oferece os benefícios da verificação de tipo em tempo de compilação da composição de consulta dinâmica.

Os principais tipos que suportam LINQ são definidos nos namespaces System.Linq e System.Linq.Expressions.

As unidades básicas de dados no LINQ são as sequências e os elementos.

A seqüência é qualquer objeto que implementa a Interface genérica IEnumerable, e um elemento é cada item na seqüência. No exemplo a seguir, nomes é uma seqüência, e Macoratti, Miriam,Jefferson, etc. são elementos:

string[] nomes = { "Macoratti", "Miriam", "Jefferson","Janice" };

Chamamos tal seqüência de uma seqüência local, pois representa uma coleção de objetos locais em memória.

Um operador de consulta é um método que transforma uma seqüência.  Um operador de consulta típico aceita uma seqüência de entrada e gera uma seqüência transformada de saída.

Na classe Enumerable do namespace System.Linq, há cerca de 40 operadores de consulta, todos implementados como métodos de extensão estáticos, chamados de operadores de consulta padrão.

Uma consulta é uma expressão que transforma seqüências com operadores de consulta. As consultas mais simples incluem uma seqüência de entrada e um operador.

Por exemplo, podemos aplicar o operador Where em um array simples para extrair elementos cujo comprimento maior ou igual a  7 caracteres como segue:

using System;
using System.Collections.Generic;
using System.Linq;

namespace LINQ_Ref1
{
class Program
{
   static void Main(string[] args)
   {

    Console.WriteLine("Linq - Consultas - operador Where" + Environment.NewLine);

    string[] nomes = { "Macoratti", "Miriam", "Jefferson", "Janice" };

    IEnumerable<string> nomesFiltrados = Enumerable.Where(nomes, n => n.Length >= 7 );

    foreach (string n in nomesFiltrados)
            Console.Write(n + "|");

     Console.Write("\r\n\r\nPressione algo para continuar. . . ");
     Console.ReadKey(true);
  }
 }
}
Environment.NewLine e \r\n\

São usados como caracteres de nova linha.

Como os operadores de consulta padrão são implementados como métodos de extensão, podemos chamar o operador Where diretamente na sequência nomes como se ele fosse um método de instância:

IEnumerable<string> nomesFiltrados = nomes.Where(n => n.Length >= 4);

Podemos reduzir ainda mais a nossa consulta, inferindo implicitamente a variável nomesFiltrados:

var nomesFiltrados = nomes.Where(n => n.Length >= 7);

A maioria dos operadores de consultas aceitam uma expressão lambda como um argumento. A expressão lambda ajuda a orientar e dar forma a consulta. Em nosso exemplo a expressão lambda usada é:  n.Length >= 7

O argumento de entrada corresponde ao elemento, neste caso o argumento n que representa cada nome no array e é do tipo string.

O operador Where exige que a expressão lambda retorne um valor booleano, que se for true indica que o elemento será incluído na seqüência de saída.

A linguagem C# também define uma sintaxe especial para escrever consultas chamada de sintaxe de compreensão de consulta.  A consulta anterior expressa na sintaxe de compreensão ficaria assim:

IEnumerable<string> nomesFiltrados = from n in nomes where n.Contains("M") select n;

A sintaxe lambda e a sintaxe de compreensão se complementam.

Pegue o projeto completo aqui:  LINQ_Ref1.zip

Eu sei é apenas LINQ , mas eu gosto...

"Não se turbe o vosso coração;crede em Deus, crede também em mim." (João 14:1)

Referências:

José Carlos Macoratti