C# - IQueryable, Queryable e AsQueryable

 Hoje vamos examinar a interface IQueryable, o método AsQueryable e a classe estática Queryable.

Para que usamos a interface IQuerayble ? E para que serve o método AsQueryable e a classe estática Queryable ?

A interface IQueryable fornece a funcionalidade para avaliar as consultas em uma fonte de dados específica no qual o tipo de dado não foi definido e destina-se à implementação por provedores de consulta.

A interface IQueryable herda da interface IEnumerable de forma que, se ela representar uma consulta, os resultados dessa consulta possam ser enumerados. A enumeração faz com que a árvore de expressão associada a um objeto IQueryable seja executada.

A classe Queryable fornece um conjunto de métodos estáticos para consultar estruturas de dados que implementam IQueryable<T>. A maioria dos métodos são métodos de extensão podendo ser chamados como um método de instância em qualquer objeto que implementa IQueryable<T>.

O método AsQueryable converte um IEnumerable em um IQueryable.

A seguir temos um exemplo onde temos um array de inteiros onde usamos o método AsQueryable para converter para um IQueryable e nos fornecer uma referência deste tipo.

A seguir usamos alguns métodos estáticos da classe Queryable para esta referência para realizar alguns cálculos com números inteiros.

using System;
using System.Linq;
namespace CShp_Queryable1
{
    class Program
    {
        static void Main(string[] args)
        {
            var numeros = new int[] { 5, 10, 20 , 60, 72, 90, 102, 114, 122, 130 };

            // Podemos converter um array de inteiros usando AsQueryable
            // e passar a referência para a classe Queryable e usar os métodos estáticos
            double media = Queryable.Average(numeros.AsQueryable());

            int soma = Queryable.Sum(numeros.AsQueryable());
            int conta = Queryable.Count(numeros.AsQueryable());
            int maximo = Queryable.Max(numeros.AsQueryable());
            int minimo= Queryable.Min(numeros.AsQueryable());

            //----------------------
            Console.WriteLine($"quantidade : {conta}");
            Console.WriteLine($"soma : {soma}");
            Console.WriteLine($"média : {media}");
            Console.WriteLine($"mínimo : {minimo}");
            Console.WriteLine($"máximo : {maximo}");
            Console.ReadLine();
        }
    }
}

Abaixo temos o resultado obtido:

Como  a interface IQueryable herda de IEnumerable, podemos usar IQueryable de maneira semelhante a IEnumerable para atuar em coleções de elementos com um tipo unificado.

No exemplo a seguir convertemos uma lista e um array para IQueryable onde aplicamos os métodos de extensão da classe Queryable:

using System;
using System.Collections.Generic;
using System.Linq;
namespace CShp_Queryable1
{
    class Program
    {
        static void Main(string[] args)
        {
            // List e array podem ser convertidos para IQueryable.
            List<int> lista = new List<int>();
            lista.Add(209);
            lista.Add(105);
            int[] array = new int[2];
            array[0] = 230;
            array[1] = 186;
            // Podemos usar IQueryable para tratar as 
            // coleções como um tipo unico
            Teste(lista.AsQueryable());
            Teste(array.AsQueryable());
            Console.ReadLine();
        }
        static void Teste(IQueryable<int> items)
        {
            Console.WriteLine($"Média: {items.Average()}");
            Console.WriteLine($"Soma: {items.Sum()}");
        }
}

Assim, podemos usar IQueryable para implementar provedores LINQ para os componentes internos do .NET Framework e para permitir que

Podemos usar AsQueryable para simular uma fonte de dados consultável usando uma fonte de dados na memória, para que você possa testar com mais facilidade os métodos que eventualmente serão usados ​​em um IQueryable com base em um não enumerável. Também podemos escrever métodos auxiliares para manipular coleções que podem ser aplicadas a seqüências na memória ou fontes de dados externas.

A utilização do IQueryable<T> permite a construção de árvores de expressões de consulta. É mais indicado para utilizar com banco de dados (LINQ TO SQL) e outras fontes remotas, principalmente quando precisa de paginação de resultados.

Estas expressões podem ser obtidas e executadas com os métodos IQueryProvider.CreateQuery() e IQueryProvider.Execute().

Nota: Você pode converter um resultado IQueryable<T> para um List<T> mas normalmente a conversão é feita para um IEnumerable<T>;

E estamos conversados...

Pegue o projeto aqui :   CShp_Queryable1.zip

"O entendimento para aqueles que o possuem, é uma fonte de vida, mas a instrução dos tolos é a sua estultícia."
Provérbios 16:22

Referências:

José Carlos Macoratti