EggMapper 1.16.1

🥚 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-27 04:16 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

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

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