ZeroAlloc.AsyncEvents 1.1.8

ZeroAlloc.AsyncEvents

Zero-allocation async event handler structs for .NET. Lock-free registration, ValueTask invocation, ArrayPool parallel dispatch.

Key Characteristics

• Lock-free registration — CAS-loop register/unregister, no locks
• ValueTask throughout — no Task allocations on hot paths
• ArrayPool parallel dispatch — handlers that complete synchronously cost nothing; only unfinished or failed ones go to a rented array and WhenAll
• Multi-target — netstandard2.0, netstandard2.1, net8.0, net10.0
• AOT compatible

Performance

10 handlers registered, invoked once, each returning a completed task. Compared against EventHandler<T> (sync multicast, baseline) and naive async (Func<string, Task> + Task.WhenAll). BenchmarkDotNet v0.15.8, X64 RyuJIT, Intel Core i9-12900HK, in-process toolchain.

net8.0

net10.0

Both ZeroAlloc modes allocate nothing on either target when handlers complete synchronously, and both are faster than a sync multicast delegate. Parallel mode is more than 10× faster than naive async, which allocates 280–288 B per call.

Installation

dotnet add package ZeroAlloc.AsyncEvents

Quick Start

// Declare the backing field
private AsyncEventHandler<OrderPlacedArgs> _orderPlaced = new(InvokeMode.Parallel);

// Expose as a C# event — or use [AsyncEvent] to let the source generator do this
public event AsyncEvent<OrderPlacedArgs> OrderPlaced
{
    add    => _orderPlaced.Register(value);
    remove => _orderPlaced.Unregister(value);
}

// Invoke
await _orderPlaced.InvokeAsync(new OrderPlacedArgs(orderId), cancellationToken);

Source Generator

Annotate fields with [AsyncEvent] on a partial class and the generator writes the event property for you:

public partial class OrderService
{
    [AsyncEvent(InvokeMode.Parallel)]
    private AsyncEventHandler<OrderPlacedArgs> _orderPlaced = new(InvokeMode.Parallel);
}

Generates:

public event AsyncEvent<OrderPlacedArgs> OrderPlaced
{
    add    => _orderPlaced.Register(value);
    remove => _orderPlaced.Unregister(value);
}

Apply [AsyncEvent] to the class instead to cover all AsyncEventHandler<TArgs> fields at once. See Source Generator for details.

Async INotify* Interfaces

Async INotify* interfaces and event args are provided by ZeroAlloc.Notify, which builds on this package.

Design Philosophy

AsyncEventHandler<TArgs> is a struct wrapping a State reference — copy semantics are intentional and match how event fields work in C#. Use it as a private field and expose Register/Unregister methods, or use the +=/-= operators directly.

CancellationToken is threaded through every call site — handlers opt into cooperative cancellation at the delegate boundary. Sequential mode respects cancellation between handler invocations; parallel mode checks before dispatch.

See docs/ for full documentation.