Custom LINQ Operators — Extending the Query Pipeline

// Before — repeated in every paginated query
var patients = await db.Patients
    .Where(p => !p.IsDeleted)  // soft delete — every query
    .Skip((page - 1) * pageSize)
    .Take(pageSize)
    .ToListAsync();

// After — expressive, centralized
var patients = await db.Patients
    .NotDeleted()
    .Paginate(page, pageSize)
    .ToListAsync();

// Extension methods on IQueryable<T>
public static class QueryableExtensions
{
    // Must be in a static class
    // First parameter: this IQueryable<T>
    public static IQueryable<T> Paginate<T>(
        this IQueryable<T> query,
        int page,
        int pageSize)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(pageSize);
        ArgumentOutOfRangeException.ThrowIfNegative(page);

        return query
            .Skip(page * pageSize)
            .Take(pageSize);
    }
}

// Usage — looks like a built-in LINQ operator
var page2 = await db.Patients.Paginate(page: 2, pageSize: 20).ToListAsync();

// Domain interface for soft-deletable entities
public interface ISoftDeletable
{
    bool IsDeleted   { get; }
    DateTime? DeletedAt { get; }
}

// Extension method works for any soft-deletable entity
public static class SoftDeleteExtensions
{
    public static IQueryable<T> NotDeleted<T>(this IQueryable<T> query)
        where T : ISoftDeletable
    {
        return query.Where(e => !e.IsDeleted);
    }

    public static IQueryable<T> DeletedOnly<T>(this IQueryable<T> query)
        where T : ISoftDeletable
    {
        return query.Where(e => e.IsDeleted);
    }

    public static IQueryable<T> DeletedAfter<T>(
        this IQueryable<T> query, DateTime cutoff)
        where T : ISoftDeletable
    {
        return query.Where(e => e.IsDeleted && e.DeletedAt > cutoff);
    }
}

// Usage
var patients = await db.Patients.NotDeleted().ToListAsync();
var recently = await db.Patients.DeletedAfter(DateTime.UtcNow.AddDays(-7)).ToListAsync();

public interface IHasTenantId
{
    Guid TenantId { get; }
}

public static IQueryable<T> ForTenant<T>(
    this IQueryable<T> query, Guid tenantId)
    where T : IHasTenantId
{
    return query.Where(e => e.TenantId == tenantId);
}

// All queries automatically scoped to the tenant
var tenantPatients = await db.Patients
    .NotDeleted()
    .ForTenant(currentUser.TenantId)
    .ToListAsync();

public static IQueryable<T> OrderByField<T>(
    this IQueryable<T> query,
    string field,
    bool descending = false)
{
    var parameter  = Expression.Parameter(typeof(T), "x");
    var property   = Expression.Property(parameter, field);
    var lambda     = Expression.Lambda(property, parameter);
    var methodName = descending ? "OrderByDescending" : "OrderBy";

    var method = typeof(Queryable)
        .GetMethods()
        .First(m => m.Name == methodName && m.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(T), property.Type);

    return (IQueryable<T>)method.Invoke(null, [query, lambda])!;
}

// Usage — sort column comes from the UI
var sorted = await db.Patients
    .OrderByField(filter.SortBy ?? "LastName", filter.Descending)
    .Paginate(filter.Page, filter.PageSize)
    .ToListAsync();

// Generic search on string properties
public static IQueryable<Patient> Search(
    this IQueryable<Patient> query, string? term)
{
    if (string.IsNullOrWhiteSpace(term))
        return query;

    return query.Where(p =>
        p.FullName.Contains(term) ||
        p.MRN.Contains(term) ||
        p.Email!.Contains(term));
}

// OR — use EF.Functions for full-text search on SQL Server
public static IQueryable<Patient> FullTextSearch(
    this IQueryable<Patient> query, string? term)
{
    if (string.IsNullOrWhiteSpace(term))
        return query;

    return query.Where(p =>
        EF.Functions.Contains(EF.Property<string>(p, "SearchVector"), term));
}

// All operators chain naturally — reads like a sentence
var results = await db.Patients
    .NotDeleted()                              // soft-delete filter
    .ForTenant(currentUser.TenantId)           // multi-tenant
    .Search(filter.Term)                       // full-text search
    .Where(p => p.Department == filter.Dept)  // additional filter
    .OrderByField(filter.SortBy, filter.Desc) // dynamic sort
    .Paginate(filter.Page, filter.PageSize)   // pagination
    .Select(p => new PatientDto(p.Id, p.FullName, p.MRN))
    .ToListAsync(ct);

// All of this generates ONE SQL query with WHERE, ORDER BY, OFFSET/FETCH NEXT

// Chunk — split a list into batches (useful for bulk operations)
public static IEnumerable<IEnumerable<T>> Chunk<T>(
    this IEnumerable<T> source, int size)
{
    // Note: .NET 6+ has Chunk() built in — use that instead
    return source
        .Select((item, index) => (item, index))
        .GroupBy(x => x.index / size)
        .Select(g => g.Select(x => x.item));
}

// Usage — send prescriptions to pharmacy in batches of 100
foreach (var batch in prescriptions.Chunk(100))
    await pharmacyService.SendBatchAsync(batch, ct);