IQueryable<T> - .NET API | Microsoft Docs

IQueryable<T> Interface

Assembly: System.Core.dll

Summary

Represents a queryable collection of entities of type T.

The IQueryable<T> interface is used to describe a LINQ query that will be executed against a data source. It extends the IEnumerable<T> interface, allowing LINQ queries to be built on top of it.

Syntax

public interface IQueryable<out T> : IEnumerable<T>, IQueryable

Remarks

IQueryable<T> is the core interface for LINQ queries that are executed against external data sources, such as databases. It provides the ability to translate LINQ query expressions into a format that the data source can understand and execute, such as SQL.

When you use LINQ to Objects, you are working with an IEnumerable<T>. When you use LINQ to SQL or LINQ to Entities, you are working with an IQueryable<T>.

The out keyword in the generic type parameter <out T> indicates that T is contravariant. This means that if you have a queryable collection of a base type, you can treat it as a queryable collection of a derived type.

Example

Here's a simple example of how IQueryable<T> might be used with a hypothetical data context:

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

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

public class MyDataContext
{
    // This property would typically be populated by a database provider
    public IQueryable<Product> Products { get; } = new List<Product>
    {
        new Product { Id = 1, Name = "Laptop", Price = 1200.00m },
        new Product { Id = 2, Name = "Keyboard", Price = 75.50m },
        new Product { Id = 3, Name = "Mouse", Price = 25.00m },
        new Product { Id = 4, Name = "Monitor", Price = 300.00m }
    }.AsQueryable(); // Use AsQueryable() to simulate an IQueryable source
}

public class Program
{
    public static void Main(string[] args)
    {
        var context = new MyDataContext();

        // A LINQ query against IQueryable<Product>
        IQueryable<Product> expensiveProducts = context.Products
                                                    .Where(p => p.Price > 100.00m)
                                                    .OrderBy(p => p.Name);

        Console.WriteLine("Expensive Products:");
        foreach (var product in expensiveProducts)
        {
            Console.WriteLine($"- {product.Name} (${product.Price:N2})");
        }

        // The query provider associated with expensiveProducts
        // would translate the above LINQ expression into a query
        // for the underlying data source.
        Console.WriteLine($"\nQuery Provider Type: {expensiveProducts.Provider.GetType().Name}");
    }
}

Members

Provider Gets the element or object to which this query provider is associated.
Expression Gets the expression tree that is associated with the data source.

`Provider` Property

IQueryProvider Provider { get; }

Gets the element or object to which this query provider is associated.

This property returns an object that implements the IQueryProvider interface. This object is responsible for translating LINQ query expressions into a format that the underlying data source can understand and execute. For example, if the data source is a relational database, the IQueryProvider might translate the LINQ query into SQL.

`Expression` Property

Expression Expression { get; }

Gets the expression tree that is associated with the data source.

This property returns an Expression object that represents the query. This expression tree can be inspected and manipulated by the IQueryProvider to optimize the query execution. The expression tree captures the entire LINQ query from the initial data source to the final result.