Chd.Mapping.Fody 8.0.8

🚩 Important Note:
When using Chd.Mapping.Fody, your IDE (Visual Studio, Rider, etc.) may show red squiggly lines or error messages (such as "no implicit conversion" or "method not found") for generated mapping methods or operators.
This is expected: the mapping code is injected at the IL level after compilation, so it is not visible to IntelliSense or the C# compiler during editing.
You will not get a build error if Fody is configured correctly and the build completes successfully.
However, if the weaver is not run or misconfigured, you may encounter runtime errors.
Always ensure your project is built with Fody and check the build output for Fody logs.

Library.Mapping

What is Library.Mapping?

Library.Mapping is a high-performance, compile-time object mapper for .NET applications. It generates mapping code during your build, eliminating both the runtime reflection overhead and common type-safety pitfalls of traditional mappers.

Why Compile-time Mapping?

• Performance: Mapping logic is generated and inlined during compilation. No reflection or emitted code at runtime.
• Type Safety: Catches potential mapping errors during build instead of at runtime.
• IDE Support: Full access to code analysis, refactoring tools, and intellisense.
• Debuggability: Trace actual mapping logic in code, set breakpoints, and step through mappings.

Compile-time vs Runtime Mapping

.NET Benchmark Results

Benchmark code in /benchmarks/Mapping.Benchmark.

Installation

1. Install NuGet package:

Install-Package Library.Mapping.Fody

2. Add FodyWeavers.xml: In the root of your project, add or update:

<Weavers>
  <Library.Mapping/>
</Weavers>

3. Build project:

• The weaver will generate mapper implementations during build.

Code Samples: Modern DTO-Entity Mapping

Define DTO and Entity:

using Library.Mapping;

public class UserDto {
    [MapTo(typeof(UserEntity))]
    public int Id { get; set; }
    public string Name { get; set; }
}

public class UserEntity {
    [MapFrom(typeof(UserDto))]
    public int Id { get; set; }
    public string Name { get; set; }
}

Operator Injection

Both source and target can define implicit/explicit conversion operators, or use provided extension methods:

var entity = userDto.MapTo<UserEntity>(); // Extension method
UserEntity entity2 = userDto; // Operator overload (if injected by mapping)

Usage

After building, mapping methods and conversions are generated. Example usage:

var dto = new UserDto { Id = 1, Name = "Alice" };
UserEntity entity = dto; // Implicitly mapped
var dto2 = entity.MapTo<UserDto>(); // Back to DTO

• All mappings are validated at compile-time.
• Customization via mapping attributes available (see wiki).

Build & Integration Tips

• Confirm Fody packages are installed and correct FodyWeavers.xml exists.
• Clean & rebuild if generated code isn't appearing.
• Compatible with .NET Core, .NET Framework, and SDK-style projects.
• No runtime dependency except standard BCL.

Test & Benchmark

• See /benchmarks/Mapping.Benchmark project for reproducible performance data.
• CI runs mapping integration tests on PRs.

Authors

• Mehmet Yoldaş (mehmet-yoldas)

Acknowledgements

• Inspired by Fody community and .NET performance advocates.
• Thanks to users reporting issues and requesting features.

Note:
When using Chd.Mapping.Fody, you may see red squiggly lines or error messages in your IDE (such as "no implicit conversion" or "method not found") for generated mapping methods or operators.
This is expected: the mapping code is injected at the IL level after compilation, so it is not visible to IntelliSense or the C# compiler during editing.
You will not get a build error if Fody is configured correctly and the build completes successfully.
However, if the weaver is not run or misconfigured, you may encounter runtime errors.
Always ensure your project is built with Fody and check the build output for Fody logs.