LinqBuilder 4.1.0

LinqBuilder

The specification pattern for LINQ. LinqBuilder lets you write a filter once, as a specification, combine it with other specifications, add ordering and paging, and run it on any IQueryable<T> or IEnumerable<T>. Specifications are expression trees, so Entity Framework Core, Entity Framework 6 and other LINQ providers translate them to SQL.

var spec = new IsAdult()
    .And(new LastNameIs("Smith"))
    .OrderBy(OrderSpec<Person, string>.New(p => p.FirstName))
    .Paginate(pageNo: 1, pageSize: 20);

List<Person> page = await db.People.ExeSpec(spec).ToListAsync();

Full documentation: github.com/Baune8D/LinqBuilder

Features

• Reusable filters: write a specification as a class (Specification<T>) or inline from a lambda (Spec<T>.New(...)).
• Parameters: DynamicSpecification<T, TValue> passes up to four values into the filter, e.g. new LastNameIs("Smith").
• Composition: And, Or and Not, plus Spec<T>.All(...), Spec<T>.Any(...) and Spec<T>.None(...).
• Ordering and paging: OrderBy, ThenBy, Skip, Take and Paginate are stored in the specification and applied by ExeSpec.
• IQueryable<T> and IEnumerable<T>: a query gets the filter as an expression tree, an in-memory collection as a compiled delegate.
• LINQ overloads: Where, Any, All, Count, First, FirstOrDefault, Single and SingleOrDefault take a specification.
• In-memory checks: spec.IsSatisfiedBy(entity).
• One specification for several entity types: MultiSpecification<T1, T2>, up to four types.
• Targets .NET Standard 2.0 and .NET 8, 9 and 10.

For async Entity Framework methods that take a specification (AnyAsync, CountAsync, FirstOrDefaultAsync, ...), install LinqBuilder.EFCore or LinqBuilder.EF6 instead. Both depend on this package.

Getting started

1. Install

dotnet add package LinqBuilder

2. Write specifications

The examples use this entity:

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; } = "";
    public string LastName { get; set; } = "";
    public int Age { get; set; }
    public bool IsActive { get; set; }
}

A specification returns its filter from AsExpression():

using System;
using System.Linq.Expressions;
using LinqBuilder;

public class IsAdult : Specification<Person>
{
    public override Expression<Func<Person, bool>> AsExpression()
    {
        return person => person.Age >= 18;
    }
}

public class LastNameIs : DynamicSpecification<Person, string>
{
    public LastNameIs(string lastName)
        : base(lastName)
    {
    }

    public override Expression<Func<Person, bool>> AsExpression()
    {
        return person => person.LastName == Value;
    }
}

For a one-off filter you don't need a class: Spec<Person>.New(p => p.IsActive).

3. Combine and run them

using LinqBuilder;
using LinqBuilder.OrderBy;

ISpecification<Person> spec = new IsAdult()
    .And(new LastNameIs("Smith"))
    .OrderBy(OrderSpec<Person, string>.New(p => p.FirstName))
    .Paginate(pageNo: 2, pageSize: 10);

List<Person> page = people.ExeSpec(spec).ToList(); // filter, sort, skip 10, take 10
int total = people.Count(spec);                    // filter only: all adults named Smith

people can be any IEnumerable<Person> or IQueryable<Person>, such as a List<Person> or an EF Core DbSet<Person>.

Methods

Creating and combining specifications

Namespace LinqBuilder.

All, Any and None keep only the filters of their arguments. See Specifications for dynamic (DynamicSpecification) and multi-entity (MultiSpecification) specifications.

Ordering and paging

Namespace LinqBuilder.OrderBy.

Running specifications

Namespace LinqBuilder.

License

MIT