Soenneker.Gen.Adapt 4.0.81

Soenneker.Gen.Adapt

A modern, high-performance C# source generator for compile-time object mapping; a zero-overhead replacement for AutoMapper, Mapperly, Mapster, etc.

• Zero runtime cost - All code is generated at compile time
• Type-safe - Compiler errors instead of runtime failures
• Highly optimized - Aggressive inlining, cached delegates, safe parsing
• Works with Blazor - Runs before Blazor souce generators.
• Super easy to use - Just call Adapt<T>() on your objects

Installation

dotnet add package Soenneker.Gen.Adapt

Usage

Once installed, the generator automatically detects usage of Adapt() and generates extension methods for your types:

public class UserDto
{
    public string Name { get; set; }
    public int Age { get; set; }
    public int Id { get; set; } // This property will be ignored since it doesn't exist in UserModel
}

public class UserModel
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Map objects with a simple extension method
var dto = new UserDto { Name = "John", Age = 30 };
UserModel model = dto.Adapt<UserModel>(); // just one line!

If the properties match by name and can be converted, it maps them. If for some reason the source generator cannot build the extension method, an Adapt() extension method will not be generated.

What's being generated?

The generator creates extension methods with direct property assignments:

public static partial class GenAdapt
{
    public static UserModel Adapt(this UserDto source)
    {
        var target = new UserModel();
        target.Name = source.Name;
        target.Age = source.Age;
        return target;
    }
}

Supported Conversions

• Same-type assignments - Direct property copying
• Collections - List<T>, IEnumerable<T>, arrays with element conversion
• Dictionaries - Dictionary<TKey, TValue> with key/value conversion
• Enums - Bidirectional conversion between enum ? string, enum ? int
• Nested objects - Recursive mapping of complex object graphs
• Nullables - Automatic nullable handling

Performance

Compile-Time Mapping (Adapt<T>())

TL;DR: The generated code is generally faster than hand-written mapping code due to advanced object cloning.

• No reflection. Nor expression trees at runtime.
• Direct assignments. The generator emits straight property copies and optimized conversion.
• Aggressive inlining and compiler optimization. Hot paths are tiny and JIT-friendly.
• Allocation aware. Pre-sized collections, zero boxing, and no hidden intermediate lists.
• Fast collection paths. Direct span copying when possible; dictionary cloning uses efficient insertion patterns.
• Reflection caching. Code compilation is fast due to cached Reflection use during generation.

Reflection Mapping (AdaptViaReflection<TDest>())

For generic type parameters or abstract base classes where concrete types are only known at runtime:

• Recursively adapts nested objects - Automatically maps complex object graphs
• Handles generic collections - Adapts List<SourceItem> to List<DestItem> by recursively converting each item
• Supports nested collections - Works with List<T>, IEnumerable<T>, ICollection<T>, IList<T>
• Mappers are cached per type pair (first call overhead, then subsequent calls are fast)
• Use regular Adapt<T>() for better performance when types are known at compile time

Benchmarking

TL;DR: Soenneker.Gen.Adapt is the fastest mapping library.

Simple

Nested

Complex List

Complex List (No nested conversions)

Large Lists

Nested Lists

Troubleshooting

The generator creates multiple files per source type (e.g., Adapt.BasicSource.g.cs, Adapt.UserDto.g.cs). To inspect the generated code, add this to your .csproj:

<PropertyGroup>
  <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
  <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)Generated</CompilerGeneratedFilesOutputPath>
</PropertyGroup>

Generated files will appear in Project -> Dependencies -> Analyzers -> Soenneker.Gen.Adapt

?? Note: Source Generators don�t work transitively across project references. Any project that calls Adapt() must include its own direct package reference.