EggMapper 1.14.19

🥚 EggMapper

The fastest .NET runtime object-to-object mapper — forked from AutoMapper's last open-source release, rebuilt for maximum performance. Drop-in replacement with the same API, 1.5–5× faster.

Sponsored by eggspot.app

📖 Full documentation →

Overview

EggMapper started as a fork of AutoMapper's last open-source release and was completely rewritten for performance. It keeps the same familiar API — MapperConfiguration, CreateMap, ForMember, Profile, IMapper — so you can switch from AutoMapper with minimal code changes. Under the hood, it compiles expression-tree delegates with inlined nested maps, typed collection loops, and static generic caching, achieving zero reflection at map-time, zero extra allocations, and near-manual mapping speed.

Migrating from AutoMapper?

EggMapper is a drop-in replacement. In most cases, you only need to:

1. Replace using AutoMapper; with using EggMapper;
2. Replace services.AddAutoMapper(...) with services.AddEggMapper(...)

The same CreateMap<>(), ForMember(), ReverseMap(), Profile, and IMapper APIs work identically.

Why EggMapper?

• 🚀 Faster than Mapster on flat, flattening, deep, and complex mappings
• 🔥 1.5–5× faster than AutoMapper across all scenarios
• 🎯 Zero extra allocations — matches hand-written code exactly
• 🔁 Drop-in AutoMapper replacement — same fluent API, same patterns
• 🧩 Full feature set — profiles, ForMember, ReverseMap, nested types, collections, DI, and more
• 🪶 Lightweight — no runtime reflection, no unnecessary allocations
• 📖 MIT licensed — free for commercial use, forever

Installation

dotnet add package EggMapper

DI support (AddEggMapper) is included in the main package — no separate package needed.

Quick Start

using EggMapper;

var config = new MapperConfiguration(cfg => {
    cfg.CreateMap<Source, Destination>();
});

var mapper = config.CreateMapper();
var dest = mapper.Map<Destination>(source);

With Profiles

public class MyProfile : Profile
{
    public MyProfile()
    {
        CreateMap<Customer, CustomerDto>()
            .ForMember(d => d.FullName, opt => opt.MapFrom(s => $"{s.FirstName} {s.LastName}"))
            .ForMember(d => d.AddressLine, opt => opt.MapFrom(s => s.Address.Street));
    }
}

var config = new MapperConfiguration(cfg => cfg.AddProfile<MyProfile>());
var mapper = config.CreateMapper();

Dependency Injection

// In Program.cs
builder.Services.AddEggMapper(typeof(MyProfile).Assembly);

// In your service
public class MyService(IMapper mapper) { ... }

Performance

⏱ Last updated: 2026-03-20 15:25 UTC

All benchmarks run on BenchmarkDotNet with .NET 10. Ratio = time vs hand-written manual code (lower is better).

* Mapperly is a compile-time source generator — it produces code equivalent to hand-written mapping. EggMapper is the fastest runtime mapper.

Allocations: EggMapper matches manual allocation exactly in every scenario (zero extra bytes).

Run the benchmarks yourself:

cd src/EggMapper.Benchmarks
dotnet run --configuration Release -f net10.0 -- --filter * --exporters json markdown

Competitors tested: EggMapper, AutoMapper, Mapster, Mapperly (source-gen), AgileMapper

Column guide: Mean = avg time · Error = ½ CI · StdDev = std dev · Min/Median/Max = range · Ratio = vs Manual baseline · Rank = 1 is fastest · Allocated = heap / op

🔵 Flat Mapping (10 properties)

🟡 Flattening

🟣 Deep Mapping (2 nested objects)

🟢 Complex Mapping (nested + collection)

🟠 Collection (100 items)

🔴 Deep Collection (100 items, nested)

⚫ Large Collection (1,000 items)

⚪ Startup / Config

Note: These numbers measure config construction only and are not comparable across libraries. EggMapper compiles all expression tree delegates eagerly at construction time (pays upfront). AutoMapper and Mapster defer compilation to the first Map() call (pays on first use). See Cold Start below for the fair end-to-end comparison.

⚪ Cold Start (Config + First Map per Type Pair)

Measures total time from zero to having mapped one instance of each registered type pair — the real-world cost of bringing a mapper online. AutoMapper and Mapster pay their deferred compilation cost here; EggMapper's Map() calls are instant (already compiled above).

Cold Start results will be populated by the next benchmark CI run.

Benchmarks run automatically on every push to main with .NET 10. See workflow

Features

• ✅ Compiled expression tree delegates (zero runtime reflection)
• ✅ ForMember / MapFrom custom mappings
• ✅ Ignore() members
• ✅ ReverseMap() bidirectional mapping
• ✅ Nested object mapping (inlined into parent expression tree)
• ✅ Collection mapping (List<T>, arrays, HashSet<T>, etc.)
• ✅ Flattening (src.Address.Street → dest.AddressStreet)
• ✅ Constructor mapping (auto-detects best-matching constructor for records)
• ✅ Profile-based configuration
• ✅ Assembly scanning
• ✅ Before/After map hooks
• ✅ Conditional mapping
• ✅ Null substitution
• ✅ MaxDepth for self-referencing types
• ✅ Inheritance mapping
• ✅ Enum mapping (int ↔ enum and string ↔ enum auto-conversion)
• ✅ ForPath for nested destination properties
• ✅ .NET Dependency Injection integration (transient IMapper, scoped service support)
• ✅ EF Core proxy / derived type resolution (base-type + interface walk)
• ✅ Constructor-based type conversion in MapFrom(s => s) patterns
• ✅ Configuration validation
• ✅ CreateMap(Type, Type) runtime type mapping
• ✅ ITypeConverter<S,D> / ConvertUsing custom converters
• ✅ ShouldMapProperty global property filter
• ✅ Patch / partial mapping via mapper.Patch<S,D>(src, dest)
• ✅ Inline validation rules via .Validate() (collects all failures before throwing)
• ✅ IQueryable projection via ProjectTo<S,D>(config) for EF Core / LINQ providers

Mapping Tiers

EggMapper supports three complementary mapping approaches. Choose based on your use case:

See Migration Guide to move from runtime to compile-time APIs.

Documentation

Sponsor

EggMapper is built and maintained by Eggspot. If this library saves you time or money, consider supporting its development:

<a href="https://github.com/sponsors/eggspot"> <img src="https://img.shields.io/badge/Sponsor_EggMapper-❤️-ea4aaa?style=for-the-badge&logo=github" alt="Sponsor EggMapper" /> </a>

Sponsorships help fund:

• Continuous performance optimization and benchmarking
• New feature development
• Bug fixes and maintenance
• Documentation and community support

Contributing

We welcome contributions from the community! Here's how you can help:

• Report bugs — Open an issue
• Request features — Start a discussion
• Submit code — Fork, branch, and open a pull request
• Improve docs — Edit files in the docs/ folder (auto-synced to the wiki)
• Share benchmarks — Run on your hardware and share results

Development Setup

git clone https://github.com/eggspot/EggMapper.git
cd EggMapper
dotnet build --configuration Release
dotnet test --configuration Release

Contribution Guidelines

1. Fork the repository and create a branch from main
2. Write tests for any new functionality
3. Run all tests — dotnet test --configuration Release must pass on all TFMs
4. Run benchmarks if changing core mapping code — cd src/EggMapper.Benchmarks && dotnet run -c Release -f net10.0 -- --filter *
5. Open a PR with a clear description of the change

All contributors are recognized in the GitHub Release notes automatically.

Powered by Eggspot