SqlToObjectify 10.0.4

SqlToObjectify

Execute raw SQL queries or stored procedures directly from your DbContext and map results to strongly-typed objects — faster and lighter than Dapper.

Install

dotnet add package SqlToObjectify

Why SqlToObjectify?

• Zero reflection on the hot path — expression-tree-compiled row factories, built once, reused forever
• Command + parameter caching — repeated calls reuse the same DbCommand; only .Value is updated
• Typed SqlParameter fast-path — no boxing for int, string, Guid, DateTime, etc.
• Adaptive List<T> pre-sizing — capacity hint from the previous call eliminates mid-iteration reallocations
• Dual reader optimization — SqlDataReader-specific compiled factory when running on SQL Server
• Streaming support — IAsyncEnumerable<T> for large result sets without buffering
• Pre-compiled queries — CompiledSqlQuery<T> for maximum throughput on hot queries

Quick Start

// 1. Raw SQL → List<T>
var books = await dbContext.SelectSqlQueryListAsync<BookDto>(
    "SELECT Title, Author, Price FROM Books WHERE Tag = @tag AND Price < @limit",
    new Dictionary<string, object>
    {
        ["tag"] = "Science",
        ["limit"] = 25
    });

// 2. Stored Procedure → List<T>
var employees = await dbContext.SelectStoredProcedureListAsync<EmployeeDto>(
    "GetEmployeesByDepartment",
    new Dictionary<string, object> { ["DepartmentId"] = 5 });

// 3. Single row
var book = await dbContext.SelectSqlQueryFirstOrDefaultAsync<BookDto>(
    "SELECT TOP 1 Title, Author FROM Books WHERE Id = @id",
    new Dictionary<string, object> { ["id"] = 42 });

// 4. Streaming (IAsyncEnumerable — no buffering)
await foreach (var row in dbContext.SelectSqlQueryStreamAsync<BookDto>(
    "SELECT Title, Author, Price FROM Books"))
{
    Process(row);
}

// 5. Pre-compiled query (fastest repeated path)
await using var compiled = dbContext.CompileSqlQuery<BookDto>(
    "SELECT Title, Author, Price FROM Books WHERE Tag = @tag", "tag");

compiled.SetParameter(0, "Science");
var result = await compiled.ToListAsync();

API Reference

SQL Queries

Stored Procedures

All methods are extension methods on DbContext. Parameters are passed as Dictionary<string, object> — keys can include or omit the @ prefix.

Supported Type Mappings

Extra columns in the result set are ignored. Missing columns leave the DTO property at its default value.

Performance Model

First call (per query + connection + DTO type):

• Creates DbCommand with typed SqlParameter objects
• Compiles an expression-tree row factory (one for DbDataReader, one for SqlDataReader)
• Caches everything in a ConcurrentDictionary

Every subsequent call (hot path):

• Reuses cached DbCommand — only updates .Value on existing parameters (ordinal-indexed, zero string ops)
• Skips factory lookup entirely — factory stored in the cache entry
• Pre-sizes List<T> from the previous call's row count

The hot path allocates only the List<T>, the T instances, and the async state machine. No reflection, no parameter creation, no dictionary lookups.

Parameters

// Both forms work — the library normalizes automatically:
new Dictionary<string, object> { ["tag"] = "Science" }      // without @
new Dictionary<string, object> { ["@tag"] = "Science" }     // with @

// Null parameters:
new Dictionary<string, object> { ["tag"] = DBNull.Value }   // explicit DBNull
// or simply omit the parameter dictionary for queries without parameters

Requirements

• .NET 10.0+
• Entity Framework Core 10.0+ (Relational)
• Microsoft.Data.SqlClient 6.0+ (for SQL Server fast-path; general DbDataReader path works with any provider)

License

MIT

Links

• GitHub
• NuGet