TypedQuery.Abstractions 1.0.3

TypedQuery

A high-performant .NET library for batching multiple database queries into a single roundtrip with type-safe, reusable query definitions.

The Problem

1. EF Core can't run queries concurrently

// 3 sequential roundtrips, no concurrency allowed
var user = await db.Users.FirstOrDefaultAsync(u => u.Id == userId);
var orders = await db.Orders.Where(o => o.UserId == userId).ToListAsync();
var addresses = await db.Addresses.Where(a => a.UserId == userId).ToListAsync();
// Each query waits for the previous one. Database executes them one by one.

2. Dapper's QueryMultipleAsync gets messy

// hard to read, maintain, and reuse
var sql = @"
    SELECT * FROM Users WHERE Id = @userId;
    SELECT * FROM Orders WHERE UserId = @userId;
    SELECT * FROM Addresses WHERE UserId = @userId;";

using var multi = await connection.QueryMultipleAsync(sql, new { userId = 5 });
var user = await multi.ReadFirstOrDefaultAsync<User>();
var orders = (await multi.ReadAsync<Order>()).ToList();
var addresses = (await multi.ReadAsync<Address>()).ToList();

The Solution

TypedQuery batches your queries into a single SQL script.

var result = await db
    .ToTypedQuery()
    .Add(new GetUserById(userId))
    .Add(new GetOrdersByUserId(userId))
    .Add(new GetAddressesByUserId(userId))
    .ExecuteAsync();

var user = result.Get<UserDto>();
var orders = result.GetList<OrderDto>();
var addresses = result.GetList<AddressDto>();
// One roundtrip.

This drives developers toward cleaner code while improving performance when multiple independent queries are needed together and database roundtrips are expensive.

Installation

dotnet add package TypedQuery

or for EF Core integration ⇒

dotnet add package TypedQuery.EntityFrameworkCore

Quick Start

Define Queries

Raw SQL Query

public class GetUserById(int id) : ITypedQuery<UserDto>
{
    public QueryDefinition Build(QueryBuildContext context)
    {
        return new QueryDefinition(
            "SELECT Id, Name, Email FROM Users WHERE Id = @id",
            new { id });
    }
}

EF Core Query

public class GetOrdersByUserId(int userId) : ITypedQuery<AppDbContext, OrderDto>
{
    public IQueryable<OrderDto> Query(AppDbContext db)
    {
        return db.Orders
            .Where(o => o.UserId == userId)
            .Select(o => new OrderDto { Id = o.Id, Total = o.Total });
    }
}

⚠️ Important: To use EF Core queries, you must register the TypedQuery interceptor:

services.AddDbContext<AppDbContext>(options => 
{
    options.UseSqlServer(connectionString);
    options.UseTypedQuery();  // Required for EF Core mode!
});

Execute Queries

With EF Core DbContext

var result = await dbContext
    .ToTypedQuery()
    .Add(new GetUserById(5))
    .Add(new GetOrdersByUserId(5))
    .ExecuteAsync();

var user = result.Get<UserDto>();
var orders = result.GetList<OrderDto>();

With Raw DbConnection

var result = await connection
    .ToTypedQuery()
    .Add(new GetUserById(5))
    .Add(new GetActiveProducts())
    .ExecuteAsync();

var user = result.Get<UserDto>();
var products = result.GetList<ProductDto>();

Why TypedQuery?

Performance Overview

Local Benchmarks (SQLite in-memory, .NET 8)

Execution Model

TypedQuery uses a dual-mode execution strategy:

1. Cold execution (first use)

   • EF Core translates LINQ to SQL
   • SQL template and parameter metadata are cached

2. Warm execution (subsequent uses)

   • EF Core is skipped
   • Cached SQL is executed via Dapper

Implications:

• Cold cost is paid once per query type
• Warm execution is significantly faster and allocates less memory

Packages

Contributing

Contributions are welcome! This library is in active development.

Acknowledgments

• Built on top of Dapper for query execution
• Inspired by the need for cleaner batch query patterns in .NET