ZeroAlloc.Net

About

Design Philosophy

Packages

ZeroAlloc.Analyzers

ZeroAlloc.AsyncEvents

// Manual — declare backing field, expose event, invoke
private AsyncEventHandler<OrderPlacedArgs> _orderPlaced = new(InvokeMode.Parallel);
public event AsyncEvent<OrderPlacedArgs> OrderPlaced
{
 add => _orderPlaced.Register(value);
 remove => _orderPlaced.Unregister(value);
}
await _orderPlaced.InvokeAsync(new OrderPlacedArgs(orderId), cancellationToken);
// Source generator — [AsyncEvent] generates the event property automatically
public partial class OrderService
{
 [AsyncEvent(InvokeMode.Parallel)]
 private AsyncEventHandler<OrderPlacedArgs> _orderPlaced = new(InvokeMode.Parallel);
 // Generated: public event AsyncEvent<OrderPlacedArgs> OrderPlaced { add => ...; remove => ...; }
}

ZeroAlloc.Authorization

[AuthorizationPolicy("AdminOnly")]
public sealed class AdminOnlyPolicy : IAuthorizationPolicy
{
 public bool IsAuthorized(ISecurityContext ctx) => ctx.Roles.Contains("Admin");
}
public sealed class UserService
{
 [Authorize("AdminOnly")]
 public Task DeleteUserAsync(string userId) { /* ... */ }
}

ZeroAlloc.Cache

[Cache(TtlMs = 60_000)]
public interface IProductRepository
{
 ValueTask<Product?> GetByIdAsync(int id, CancellationToken ct);
 [Cache(TtlMs = 300_000, MaxEntries = 1_000)]
 ValueTask<IReadOnlyList<Product>> SearchAsync(string query, CancellationToken ct);
}
// One line wires proxy + backing implementation
builder.Services.AddIProductRepositoryCache<ProductRepositoryImpl>();

ZeroAlloc.Collections

using ZeroAlloc.Collections;
// PooledList — growable, ArrayPool-backed; zero heap allocation for the backing array
using var list = new PooledList<int>(capacity: 64);
list.Add(1);
list.Add(2);
list.Add(3);
foreach (var item in list)
 Console.WriteLine(item);
// RingBuffer — fixed-capacity circular buffer for producer/consumer queues
using var ring = new RingBuffer<string>(capacity: 4);
ring.TryWrite("alpha");
ring.TryWrite("beta");
ring.TryWrite("gamma");
while (ring.TryRead(out var item))
 Console.WriteLine(item); // alpha, beta, gamma

ZeroAlloc.EventSourcing

// Define aggregate state as a struct — zero heap allocation on read
public readonly record struct OrderState(string OrderId, decimal Total, bool Placed);
public sealed class OrderAggregate : Aggregate<OrderState>
{
 public Result<Unit, string> Place(string orderId, decimal total)
 {
 if (State.Placed) return "already placed";
 Raise(new OrderPlacedEvent(orderId, total));
 return Unit.Value;
 }
 protected override OrderState Apply(OrderState state, object @event) => @event switch
 {
 OrderPlacedEvent e => state with { OrderId = e.OrderId, Total = e.Total, Placed = true },
 _ => state,
 };
}
// Wire up DI
services
 .AddEventSourcing()
 .UseInMemoryEventStore(); // swap for .UsePostgreSqlEventStore(cs) in production
// Use
var repo = sp.GetRequiredService<IAggregateRepository<OrderAggregate, string>>();
var order = new OrderAggregate();
order.Place("order-1", 99.99m);
await repo.SaveAsync("order-1", order, CancellationToken.None);

ZeroAlloc.Inject

[assembly: ZeroAllocInject("AddMyServices")]
[Transient(As = typeof(IOrderService))]
public class OrderService : IOrderService { ... }
[Singleton(As = typeof(ICache))]
public class RedisCache : ICache { ... }

// Generated at compile time — resolved without any reflection
services.AddMyServices();
var provider = services.BuildZeroAllocInjectServiceProvider();

ZeroAlloc.Mediator

public readonly record struct Ping(string Message) : IRequest<string>;
public class PingHandler : IRequestHandler<Ping, string>
{
 public ValueTask<string> Handle(Ping request, CancellationToken ct)
 => ValueTask.FromResult($"Pong: {request.Message}");
}
// Generated mediator with strongly-typed Send/Publish/CreateStream overloads
var result = await Mediator.Send(new Ping("Hello"), ct); // ~2 ns, 0 bytes

ZeroAlloc.Notify

[NotifyPropertyChangedAsync]
public partial class UserViewModel
{
 [ObservableProperty] private string _name = "";
 [ObservableProperty] private int _age;
}
var vm = new UserViewModel();
vm.PropertyChangedAsync += async (args, ct) =>
{
 Console.WriteLine($"'{args.PropertyName}' changed: {args.OldValue} → {args.NewValue}");
 await SaveAuditLogAsync(args, ct);
};
await vm.SetNameAsync("Alice");
await vm.SetAgeAsync(30);

ZeroAlloc.Outbox

[OutboxMessage]
public sealed record OrderPlaced(Guid OrderId, decimal Total);
// Inside a transaction — write the row in the same DbContext as your domain change
await _outbox.WriteAsync(new OrderPlaced(orderId, total), ct);
await _db.SaveChangesAsync(ct);
// Polling worker dispatches in the background — at-least-once delivery, retry + DLQ baked in
services.AddZeroAllocOutbox().UseEfCore<MyDbContext>();

ZeroAlloc.Pipeline

using ZeroAlloc.Pipeline;
[PipelineBehavior(Order = 1)]
public class LoggingBehavior : IPipelineBehavior
{
 public static async ValueTask<TResponse> Handle<TRequest, TResponse>(
 TRequest request,
 CancellationToken ct,
 Func<TRequest, CancellationToken, ValueTask<TResponse>> next)
 {
 Console.WriteLine($"Handling {typeof(TRequest).Name}");
 var response = await next(request, ct);
 Console.WriteLine($"Handled {typeof(TRequest).Name}");
 return response;
 }
}
// Picked up at compile time by ZeroAlloc.Mediator or ZeroAlloc.Validation
// No registration, no reflection — wired into the generated pipeline automatically

ZeroAlloc.Resilience

[Retry(MaxAttempts = 3, BackoffMs = 200, Jitter = true, PerAttemptTimeoutMs = 1_000)]
[Timeout(Ms = 5_000)]
[RateLimit(MaxPerSecond = 100, BurstSize = 10)]
[CircuitBreaker(MaxFailures = 5, ResetMs = 1_000, HalfOpenProbes = 1, Fallback = nameof(FetchFallback))]
public interface IExternalService
{
 ValueTask<string> FetchAsync(string id, CancellationToken ct);
 ValueTask<string> FetchFallback(string id, CancellationToken ct);
}

ZeroAlloc.Rest

[ZeroAllocRestClient]
public interface IUserApi
{
 [Get("/users/{id}")]
 Task<UserDto> GetUserAsync(int id, CancellationToken ct = default);
 [Get("/users")]
 Task<List<UserDto>> ListUsersAsync([Query] string? name = null, CancellationToken ct = default);
 [Post("/users")]
 Task<UserDto> CreateUserAsync([Body] CreateUserRequest request, CancellationToken ct = default);
 [Delete("/users/{id}")]
 Task DeleteUserAsync(int id, CancellationToken ct = default);
}
// DI registration — AddIUserApi extension generated by the source generator
builder.Services.AddIUserApi(options =>
{
 options.BaseAddress = new Uri("https://api.example.com");
 options.UseSerializer<SystemTextJsonSerializer>();
});
// Inject and use — no reflection, no proxies at runtime
public class UserService(IUserApi api)
{
 public Task<UserDto> GetAsync(int id) => api.GetUserAsync(id);
}

ZeroAlloc.Results

using ZeroAlloc.Results;
using ZeroAlloc.Results.Extensions;
// Chain combinators
var result = GetUser(id)
 .Ensure(u => u.IsActive, "user is inactive")
 .Map(u => u.Email)
 .Bind(email => SendWelcome(email));
// Extract with Match
string message = result.Match(
 onSuccess: email => $"Sent to {email}",
 onFailure: err => $"Failed: {err}");
// LINQ query syntax
var greeting =
 from user in GetUser(id)
 from profile in GetProfile(user)
 select $"Hello, {profile.Name}";
// Async pipelines
var response = await GetUser(id)
 .MapAsync(async u => await LoadPermissions(u))
 .BindAsync(async p => await BuildToken(p));

ZeroAlloc.Saga

[Saga]
public partial class OrderFulfillmentSaga
{
 public OrderId OrderId { get; private set; }
 [StartedBy] public ValueTask Handle(OrderPlaced evt, ISagaContext ctx) { /* ... */ }
 [Step] public ValueTask Handle(PaymentReceived evt, ISagaContext ctx) { /* ... */ }
 [Compensate(nameof(Handle))] public ValueTask CompensatePayment(ISagaContext ctx) { /* ... */ }
}
// Default in-memory; swap to durable EF Core with one call
services.AddZeroAllocSaga().UseEfCore<MyDbContext>();

ZeroAlloc.Scheduling

[Job(Every = Every.Hour)]
public sealed class CleanupExpiredSessionsJob : IJob
{
 public ValueTask ExecuteAsync(JobContext ctx, CancellationToken ct)
 => /* work */ ValueTask.CompletedTask;
}
// Generated DI extension wires executor + recurring schedule
builder.Services.AddZeroAllocScheduling().UseInMemory();

ZeroAlloc.Serialisation

[MemoryPackable]
[ZeroAllocSerializable(SerializationFormat.MemoryPack)]
public partial class OrderPlacedEvent
{
 public Guid OrderId { get; set; }
 public decimal Total { get; set; }
}
// Generated: OrderPlacedEventSerializer + AddOrderPlacedEventSerializer()
services.AddSerializerDispatcher(); // covers all [ZeroAllocSerializable] types in the assembly
public class OrderStore(ISerializer<OrderPlacedEvent> serializer)
{
 public void Write(IBufferWriter<byte> writer, OrderPlacedEvent evt)
 => serializer.Serialize(writer, evt); // writes directly to IBufferWriter<byte> — zero intermediate byte[]
 public OrderPlacedEvent? Read(ReadOnlySpan<byte> bytes)
 => serializer.Deserialize(bytes);
}

ZeroAlloc.Specification

dotnet add package ZeroAlloc.Specification
dotnet add package ZeroAlloc.Specification.Generator

[Specification]
public readonly partial struct ActiveUserSpec : ISpecification<User>
{
 public bool IsSatisfiedBy(User user) => user.IsActive;
 public Expression<Func<User, bool>> ToExpression() => u => u.IsActive;
}
[Specification]
public readonly partial struct PremiumUserSpec : ISpecification<User>
{
 private readonly decimal _minSpend;
 public PremiumUserSpec(decimal minSpend) => _minSpend = minSpend;
 public bool IsSatisfiedBy(User user) => user.TotalSpend >= _minSpend;
 public Expression<Func<User, bool>> ToExpression()
 {
 var min = _minSpend;
 return u => u.TotalSpend >= min;
 }
}
// Fluent composition — zero allocation, composed type is still a readonly struct
var spec = new ActiveUserSpec().And(new PremiumUserSpec(1000m));
// In-memory
bool qualifies = spec.IsSatisfiedBy(user);
// EF Core — translates to SQL
var users = await dbContext.Users.Where(spec.ToExpression()).ToListAsync();

ZeroAlloc.StateMachine

public enum State { Idle, Pending, Done }
public enum Trigger { Submit, Pay }
[StateMachine(InitialState = nameof(State.Idle))]
[Transition<State, Trigger>(From = State.Idle, On = Trigger.Submit, To = State.Pending)]
[Transition<State, Trigger>(From = State.Pending, On = Trigger.Pay, To = State.Done)]
[Terminal<State>(State = State.Done)]
public partial class OrderMachine { }
var machine = new OrderMachine();
machine.TryFire(Trigger.Submit); // → State.Pending
machine.TryFire(Trigger.Pay); // → State.Done (terminal)

ZeroAlloc.Telemetry

[Instrument("MyApp.Orders")]
public interface IOrderService
{
 [Trace("order.create")]
 [Count("orders.created")]
 ValueTask<OrderId> CreateOrderAsync(CreateOrderCommand cmd, CancellationToken ct);
 [Trace("order.get")]
 [Histogram("order.get_ms")]
 ValueTask<Order> GetOrderAsync(OrderId id, CancellationToken ct);
}
// Generated: OrderServiceInstrumented — wire up as a DI decorator
services.AddSingleton<IOrderService>(sp =>
 new OrderServiceInstrumented(sp.GetRequiredService<OrderServiceImpl>()));
// Add any exporter — the library emits standard BCL ActivitySource and Meter
builder.Services.AddOpenTelemetry()
 .WithTracing(t => t.AddSource("MyApp.Orders").AddOtlpExporter())
 .WithMetrics(m => m.AddMeter("MyApp.Orders").AddOtlpExporter());

ZeroAlloc.Validation

using ZeroAlloc.Validation;
[Validate]
public class CreateOrderRequest
{
 [NotEmpty][MaxLength(50)] public string Reference { get; set; } = "";
 [GreaterThan(0)] public decimal Amount { get; set; }
 [NotEmpty][EmailAddress] public string Email { get; set; } = "";
}
// Source generator emits CreateOrderRequestValidator at build time
var validator = new CreateOrderRequestValidator();
var result = validator.Validate(new CreateOrderRequest
{
 Reference = "ORD-2026-001",
 Amount = 99.99m,
 Email = "customer@example.com"
});
if (!result.IsValid)
 foreach (ref readonly var f in result.Failures)
 Console.WriteLine($"{f.PropertyName}: {f.ErrorMessage}");

ZeroAlloc.ValueObjects

// Drop onto any existing partial class — no keyword changes required
[ValueObject]
public partial class Money
{
 public decimal Amount { get; }
 public string Currency { get; }
}
[ValueObject]
public partial struct CustomerId
{
 public Guid Value { get; }
}
// Generated: Equals, GetHashCode (HashCode.Combine), ==, !=, ToString — zero alloc

Sponsor