Mapo 1.1.1

Mapo

High-performance, compile-time object mapping for .NET.

Mapo is a Roslyn source generator that writes your mapping code at build time. You get the fluent API of AutoMapper with the runtime speed of hand-written C# — zero reflection, zero allocation overhead, NativeAOT-ready out of the box.

using Mapo.Attributes;

[Mapper]
public partial class UserMapper
{
    public partial UserDto Map(User user);

    static void Configure(IMapConfig<User, UserDto> config)
    {
        config.Map(d => d.FullName, s => s.FirstName + " " + s.LastName);
        // AddressCity is auto-resolved from Address.City via intelligent flattening
    }
}

That's it. Mapo generates a complete, null-safe, inlineable implementation at compile time.

Why Mapo?

• Zero overhead. Generated code allocates identically to hand-written code. No reflection. No expression tree compilation. No hidden dictionaries.
• Compile-time safety. Unmapped properties are caught as warnings (or errors in strict mode) before your code ever runs.
• Refactoring-safe. Lambda-based configuration means IDE renames propagate automatically — no magic strings.
• NativeAOT-ready. No System.Reflection.Emit, no dynamic code generation. Works with dotnet publish -r linux-x64 --self-contained /p:PublishAot=true.
• Familiar API. If you've used AutoMapper, you already know Map(), Ignore(), and AddConverter().

Benchmarks

Measured with BenchmarkDotNet on .NET 10 mapping 10,000 complex orders with nested objects, collections, computed fields, and enum conversions:

Mapo generates code that is indistinguishable from hand-written C# — identical allocations and identical speed. See Benchmark Details.

Installation

dotnet add package Mapo

Requirements: .NET 6+ (or any runtime supporting netstandard2.0) with Roslyn 4.8+ (ships with .NET SDK 8+).

The NuGet package includes both the public API (Mapo.Attributes) and the source generator (Mapo.Generator). No extra configuration needed.

Quick Start

Step 1: Define your types

public class Product
{
    public string SKU { get; set; } = "";
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
    public Category? Category { get; set; }
}

public record ProductDto(string SKU, string Name, string PriceDisplay, string CategoryName);

Step 2: Create a mapper

using Mapo.Attributes;

[Mapper(StrictMode = true)]
public partial class ProductMapper
{
    public partial ProductDto Map(Product product);

    static void Configure(IMapConfig<Product, ProductDto> config)
    {
        config.Map(d => d.PriceDisplay, s => s.Price.ToString("C"))
              .Map(d => d.CategoryName, s => s.Category.Name);
    }
}

Step 3: Use it

var mapper = new ProductMapper();
var dto = mapper.Map(product);

The generated code handles null-safety (Category?.Name ?? default), selects the best constructor, and uses [MethodImpl(AggressiveInlining)] for optimal JIT behavior.

Features

Documentation

CLI Tool

For use outside the normal build pipeline (scripts, non-MSBuild toolchains, code inspection):

dotnet tool install --global Mapo.Cli

mapo gen src/ Generated/

This scans C# files for [Mapper] classes and writes generated .g.cs files. The output is identical to what the source generator produces during dotnet build. See CLI Documentation for details.

Repository Structure

src/
  Mapo.Attributes/          Public API: [Mapper], [MapFrom], IMapConfig<S,T>, [MapDerived]
  Mapo.Generator/           Roslyn incremental source generator
  Mapo.Generator.CodeFixes/ IDE code fix provider for MAPO001 + MAPO003
tests/
  Mapo.Generator.Tests/     Unit tests (Roslyn compilation testing)
  Mapo.IntegrationTests/    Integration tests (runtime verification)
samples/
  Mapo.Sample/              Full e-commerce scenario
  Mapo.Benchmarks/          Performance comparison vs AutoMapper, Mapperly, Mapster
  Mapo.Circular/            Circular reference tracking demo
  Mapo.Polymorphic/         Polymorphic dispatch demo
  Mapo.Aot/                 NativeAOT compilation verification

Contributing

1. Fork the repository
2. Create a feature branch from dev
3. Make your changes
4. Run the full test suite:

   dotnet test tests/Mapo.Generator.Tests/ --configuration Release
   dotnet test tests/Mapo.IntegrationTests/ --configuration Release
   

5. Open a pull request against main

Please ensure all existing tests pass and add tests for new functionality.

License

MIT