ZeroAlloc.ORM.Abstractions 2.4.0

ZeroAlloc.ORM

Source-generated raw-SQL data access for .NET: you write the SQL, the generator writes the ADO.NET, with no runtime reflection and NativeAOT-ready.

Why ZeroAlloc.ORM

• Close to hand-written ADO.NET. A 1,000-row read allocates 88,592 B, 0.4% more than hand-written ADO.NET's 88,200 B, where Dapper.AOT allocates 130,000 B in the same run.
• Ahead of Dapper.AOT on most SQLite workloads. A single-row read takes 1.10× the time of hand-written ADO.NET; Dapper.AOT takes 1.26× in the same run.
• Works under NativeAOT and trimming. CI publishes and runs AOT consumers on every PR, including ones that share the build with other source generators, where EF Core's precompiled queries collide.
• Compile-time diagnostics instead of runtime surprises. A non-partial method, a tuple that does not match the SQL's statement count or a parameter with no binding is a build error, ZAO001 to ZAO082.

Install

dotnet add package ZeroAlloc.ORM
dotnet add package ZeroAlloc.ORM.Generator

Then add your ADO.NET provider, such as Microsoft.Data.Sqlite, Npgsql or Microsoft.Data.SqlClient.

Quick start

using Microsoft.Data.Sqlite;
using System.Data.Async;
using System.Data.Async.Adapters;
using ZeroAlloc.ORM;

await using var db = new SqliteConnection("Data Source=:memory:").AsAsync();
await db.OpenAsync();

var customers = new CustomerRepository(db);
await customers.CreateTableAsync();
int id = await customers.AddAsync("Ada");
Console.WriteLine(await customers.FindAsync(id)); // Customer { Id = 1, Name = Ada }

public sealed record Customer(int Id, string Name);

public sealed partial class CustomerRepository(IAsyncDbConnection connection)
{
    [Command("CREATE TABLE Customers (Id INTEGER PRIMARY KEY, Name TEXT NOT NULL)")]
    public partial Task<int> CreateTableAsync(CancellationToken ct = default);

    [Command("INSERT INTO Customers (Name) VALUES (@name) RETURNING Id", Kind = CommandKind.Identity)]
    public partial Task<int> AddAsync(string name, CancellationToken ct = default);

    [Query("SELECT Id, Name FROM Customers WHERE Id = @id")]
    public partial Task<Customer?> FindAsync(int id, CancellationToken ct = default);
}

The generator fills in each partial method with typed parameter binding and row materialization against AdoNet.Async's IAsyncDbConnection. There is no LINQ provider, no expression compilation and no runtime reflection.

What you get

• Every common result shape: scalars, single rows, lists, IAsyncEnumerable<T> streams and multi-result-set tuples such as (Order Head, IReadOnlyList<OrderLine> Lines).
• Commands: rows affected, scalars, inserted identities and chunked multi-row bulk inserts.
• Stored procedures with output, input-output and return-value parameters.
• Rich types: enums as integers or names, value objects, multi-column composites such as Money, and custom row factories.
• Transactions by declaring an IAsyncDbTransaction parameter.
• Provider-aware checks for SQLite, PostgreSQL, SQL Server and MySQL.
• Migrations: MigrationRunner applies embedded .sql files, with locking for safe concurrent startup on PostgreSQL and SQL Server.
• Observability through ZeroAlloc.Telemetry's [Instrument]; see the observability recipe.

Every shape, option and diagnostic is in the reference.

Performance

SQLite, BenchmarkDotNet, captured at 2.3.1. Time is the same-run ratio against hand-written ADO.NET; allocations are exact bytes per call.

Full tables, the insert workload, PostgreSQL and methodology: SQLite and PostgreSQL.

Learn more

• Documentation site: orm.zeroalloc.net
• Documentation source: the reference, cookbook, diagnostics and migrating to v2.
• Related packages: AdoNet.Async, ZeroAlloc.ValueObjects, ZeroAlloc.Telemetry and ZeroAlloc.Templates.
• Contributing: issues and pull requests are welcome on GitHub.
• CHANGELOG.

License

MIT. See LICENSE.