Visão geral operadores de consulta padrão

Artigo
08/01/2011

O operadores de consulta padrão são os métodos que formam o LINQ (consulta integrada à linguagem) padrão. A maioria desses métodos operam em seqüências, onde uma seqüência é um objeto cujo tipo implementa o IEnumerable<T> interface ou o IQueryable<T> interface. Os operadores de consulta padrão fornecem recursos de consulta, incluindo a filtragem, projeção, agregação, classificação e muito mais.

Há dois conjuntos de LINQ os operadores de consulta padrão, um que opera em objetos do tipo IEnumerable<T> e outros que opera em objetos do tipo IQueryable<T>. Os métodos que compõem cada conjunto são membros estáticos da Enumerable e Queryable classes, respectivamente. Eles são definidos como métodos de extensão do tipo que eles operam em. Isso significa que eles podem ser chamados usando a sintaxe do método estático ou sintaxe do método de instância.

Além disso, vários métodos de operador de consulta padrão operam em tipos diferentes daqueles com base em IEnumerable<T> ou IQueryable<T>. O Enumerable tipo define dois desses métodos que ambas operam nos objetos do tipo IEnumerable. Esses métodos, Cast<TResult>(IEnumerable) e OfType<TResult>(IEnumerable), permita que você ativar uma coleção sem parâmetros ou não-genéricas, sejam consultados da LINQ padrão. Eles fazem isso criando uma coleção fortemente tipada de objetos. O Queryable classe define dois métodos semelhantes, Cast<TResult>(IQueryable) e OfType<TResult>(IQueryable), que operam nos objetos do tipo Queryable.

Os operadores de consulta padrão diferem na temporização da sua execução, dependendo se elas retornam um valor singleton ou uma seqüência de valores. Esses métodos que retornam um valor singleton (por exemplo, Average e Sum) executado imediatamente. Métodos que retornam uma seqüência adiar a execução da consulta e retornam um objeto enumerável.

No caso dos métodos que operam em coleções na memória, ou seja, os métodos que estendem IEnumerable<T>, o objeto enumerável retornado captura os argumentos que foram passados para o método. Quando esse objeto é enumerado, a lógica do operador de consulta é empregada e os resultados da consulta são retornados.

Em contraste, métodos que ampliam a IQueryable<T> não implementam qualquer comportamento de consultando, mas criar uma árvore de expressão que representa a consulta para ser executada. O processamento de consulta é manipulado pela fonte de IQueryable<T> objeto.

Chamadas para métodos de consulta podem ser encadeadas em uma consulta, que permite consultas para ser arbitrariamente complexos.

O exemplo de código a seguir demonstra como os operadores de consulta padrão podem ser usados para obter informações sobre uma seqüência.

        Dim sentence = "the quick brown fox jumps over the lazy dog"
        ' Split the string into individual words to create a collection.
        Dim words = sentence.Split(" "c)

        Dim query = From word In words 
                    Group word.ToUpper() By word.Length Into gr = Group 
                    Order By Length _
                    Select Length, GroupedWords = gr

        Dim output As New System.Text.StringBuilder
        For Each obj In query
            output.AppendLine(String.Format("Words of length {0}:", obj.Length))
            For Each word As String In obj.GroupedWords
                output.AppendLine(word)
            Next
        Next

        'Display the output
        MsgBox(output.ToString())

        ' This code example produces the following output:
        '
        ' Words of length 3:
        ' THE
        ' FOX
        ' THE
        ' DOG
        ' Words of length 4:
        ' OVER
        ' LAZY
        ' Words of length 5:
        ' QUICK
        ' BROWN
        ' JUMPS

           string sentence = "the quick brown fox jumps over the lazy dog";
           // Split the string into individual words to create a collection.
           string[] words = sentence.Split(' ');

           // Using query expression syntax.
           var query = from word in words
                       group word.ToUpper() by word.Length into gr
                       orderby gr.Key
                       select new { Length = gr.Key, Words = gr };

           // Using method-based query syntax.
           var query2 = words.
               GroupBy(w => w.Length, w => w.ToUpper()).
               Select(g => new { Length = g.Key, Words = g }).
               OrderBy(o => o.Length);

           foreach (var obj in query)
           {
               Console.WriteLine("Words of length {0}:", obj.Length);
               foreach (string word in obj.Words)
                   Console.WriteLine(word);
           }

           // This code example produces the following output:
           //
           // Words of length 3:
           // THE
           // FOX
           // THE
           // DOG
           // Words of length 4:
           // OVER
           // LAZY
           // Words of length 5:
           // QUICK
           // BROWN
           // JUMPS

Sintaxe de expressão de consulta

Alguns dos operadores de consulta padrão usados com mais freqüência têm dedicados a C# e Visual Basic sintaxe de palavra-chave linguagem que permite que eles sejam chamados como parte de um consulta expressão. Para obter mais informações sobre os operadores de consulta padrão têm dedicados palavras-chave e suas sintaxes correspondentes, consulte Sintaxe de expressão de consulta para operadores de consulta padrão.

Estendendo os operadores de consulta padrão

Você pode aumentar o conjunto de operadores de consulta padrão por criar métodos específicos do domínio que são apropriados para o domínio de destino ou a tecnologia. Você também pode substituir os operadores de consulta padrão com suas próprias implementações que fornecem serviços adicionais como, por exemplo, avaliação remota, a tradução da consulta e a otimização. Consulte AsEnumerable<TSource> para um exemplo.