ZeroAlloc.Mapping 1.6.10

ZeroAlloc.Mapping

ZeroAlloc.Mapping is a Roslyn source generator that emits strongly-typed Command→Domain→DTO mappers at compile time. No reflection. No expression trees. No runtime configuration. The success path runs with zero allocation beyond the destination instance itself, and the generated code is fully Native AOT compatible.

Install

dotnet add package ZeroAlloc.Mapping

The generator runs automatically as part of dotnet build — there is no DI registration or runtime configuration.

Example

using ZeroAlloc.Mapping;

// 3. Use it
var order = AppMappings.Map(new OrderRequest(42, "rush"));

// 1. Define source and destination
public sealed record OrderRequest(int Id, string Notes);
public sealed record Order(int Id, string Notes);

// 2. Declare the mapper — generator fills in the partial
[Map<OrderRequest, Order>]
public static partial class AppMappings { }

What the generator emits is a null check and a single direct constructor call — no intermediate buffer, no boxing, no closure:

public static Order Map(OrderRequest src)
{
    global::System.ArgumentNullException.ThrowIfNull(src);
    var __dst = new Order(
        Id: src.Id,
        Notes: src.Notes
    );
    return __dst;
}

Performance

ZeroAlloc.Mapping matches Mapperly (the other source-generator mapper) on hot paths and is 1.8–14× faster than AutoMapper on single-object mappings with allocation parity. On the 1000-item collection benchmark AutoMapper is faster but allocates 11% more. Benchmarks below run on .NET 10.0.7, i9-12900HK, BenchmarkDotNet v0.15.8.

Allocation: identical across mappers except Collection where AutoMapper allocates 11% more (86.5 KB vs 78.2 KB).

See docs/performance.md for the full BenchmarkDotNet output, methodology, and the enforced per-call allocation budgets (CI fails on regression).

Features

• [Map<TSrc, TDst>] — direct property/constructor mapping with case-sensitive matching and compile-time diagnostics on mismatch
• [TryMap<TSrc, TDst>] — fallible mapping returning Result<TDst, MappingError> (integrates with ZeroAlloc.Results smart constructors)
• [MapProperty] flattening — "Customer.Address.City" → City via dotted paths
• [BeforeMap] / [AfterMap] hooks — zero overhead when bodies are empty
• [PolymorphicMap] — type-switch dispatch generated at compile time
• [ReverseMap] — symmetric Domain↔DTO with a single declaration
• Update-in-place — declare static partial void Map(TSrc src, TDst existingDst) next to [Map<,>] and the generator writes into the existing instance; the whole call allocates nothing, enforced by an AllocationGate test
• Collection overloads — List<T>, T[], IEnumerable<T>, IReadOnlyList<T> auto-emitted (opt-out via [SkipCollectionOverloads])
• [MappingCulture] — culture-aware decimal.Parse / DateTime.Parse per-mapper
• ValueObjects integration — a smart constructor that throws comes back from TryMap as a failed Result whose MappingError.Code is "mapping.constructor.threw"
• Native AOT — no reflection, no MakeGenericType, no expression compilation; trim/AOT warnings treated as errors in the AOT smoke gate

Documentation

License

MIT. See LICENSE.