• author: Nick Chapsas

The Three Biggest Mistakes of Object Mapping in C


In this article, we will discuss the three biggest mistakes that developers make when it comes to object mapping in C#. Whether you are using a library like AutoMapper or implementing object mapping without a library, these mistakes apply in both scenarios.

Note: For more content and training, don't forget to subscribe to our channel and check out our courses on domtrain.com.

Mistake 1: Injecting Business Logic into the Mapper

One of the most dangerous mistakes developers make is injecting business logic into the mapper. This is especially problematic because it is easy to do and can create issues in your application. Let's take a look at an example to understand this better.

Example Scenario

Imagine we have an "Account" object that represents a user account. It has properties like salutation, first name, middle name, last name, email, password, and opt-in for communication. Now, let's assume we have a "NewAccountRequest" object coming from an API or web UI that needs to be mapped to the "Account" object.

Mapping Profile

In the example, we have a mapping profile that maps the properties of the "NewAccountRequest" object to the "Account" object. However, it includes a few problematic mappings. For instance, the mapper assigns a default password to the "Account" object by using the text "password1!" concatenated with the current datetime. This is not only dangerous but also an example of hiding business logic within the mapper.

Furthermore, some developers might inject services, like an account service, into the mapper to generate the default password. While this might seem like a solution, it is still injecting business logic into the mapper, which is not recommended.

The Pitfalls of Mocking Mappers in Unit Testing

In the world of unit testing, there is an ongoing debate about the value of mocking mappers. Some argue that by removing the actual mapper implementation and replacing it with a mock, you can achieve more value in your tests. However, this approach often leads to bad tests and can hinder the effectiveness of your testing strategy.

Creating Bad Tests

When you mock a mapper, you are essentially creating a test that does not accurately reflect the behavior of the real system. This can result in false positives or false negatives and can lead to incorrect assumptions about the functionality of your code.

Trusting the Experts

To shed some light on this topic, let's consider the opinion of Jimmy Bogert, the creator of AutoMapper. Being the mastermind behind such a popular mapping tool, his insights carry weight. While it's up to you to decide whether to trust him, it is worth noting that he strongly advises against mocking mappers.

The Mapper's Role

The primary purpose of a mapper is to perform the task it was designed for: mapping objects from one type to another. Anything beyond this core functionality should be handled by another component. By keeping the responsibilities of the mapper clear and focused, you can ensure its effectiveness.

Dependency Injection Challenges

Some developers argue that they need to mock a mapper in scenarios where they are injecting services into the mapper. However, this is a code smell that indicates a deeper architectural problem. By mocking the mapper instead of addressing the root issue, you are not only masking the problem but also exposing it in your tests.

Manual Mapping Challenges

Another common pitfall that developers fall into is attempting manual mapping in an incorrect way. Let's look at a case study involving Spotify albums to better understand this issue.

Typically, the Spotify API returns album data in a DTO (data transfer object) format, which resides in the UI layer. On the other hand, the domain layer holds the Spotify album object. While these two objects live in separate layers, some developers attempt to create a Spotify album DTO by manually mapping from the domain object.

There are two popular incorrect approaches for manual mapping. One involves creating a constructor in the DTO that takes in the domain object and initializes the properties accordingly. The second approach involves using implicit or explicit operators to cast one type to another and writing mapping logic within these operators.

The Problems with Manual Mapping

Both of these incorrect approaches suffer from various issues. Firstly, the constructor-based approach creates a circular dependency problem, as you cannot have a circular reference between projects. Therefore, this approach requires rearchitecting your solution, which is an undesirable outcome.

Secondly, why should DTOs or domain objects have knowledge of how to be constructed from different objects? This blurs the lines between domain concerns and architectural concerns, which can lead to an overly complex and tightly coupled codebase.

A Better Approach: Extension Methods

To address the challenges of manual mapping, I recommend using extension methods. By creating a "map to domain" or "map to DTO" extension method on the object itself, you can keep the mapping logic encapsulated within the respective layer. This approach allows for modularity, flexibility, and better separation of concerns.

Share Your Thoughts

Now that we've explored these points, it's time to hear from you. How do you feel about mocking mappers? Do you have any pet peeves or common mistakes when it comes to object mapping? Share your thoughts and experiences in the comments section below. Let's continue the discussion and learn from each other.

Thank you for watching, and until next time, keep coding!Of mistake 1 the first rule to follow in object mapping is to avoid injecting any form of business logic into the mapper. the mapper's responsibility is to perform object mapping, not to handle business-related tasks. additional information: it is crucial to separate concerns properly and keep business logic within the appropriate layers of your application.

mistake 2: mocking the imapper interface

another common mistake is mocking the imapper interface when testing the code that depends on the mapper. let's explore this mistake in detail.

example scenario

suppose we have an "accountservice" class that depends on the imapper interface for object mapping. in our unit tests for the "accountservice", developers are often tempted to mock the imapper interface. they may then manually write the mapping logic for the specific test case. this defeats the purpose of using a mapping library like automapper in the first place.

correct approach for unit testing

instead of mocking the imapper interface, it is recommended to use the actual mapping library within the unit tests. this ensures that the mapping process is tested as well. therefore, in the unit test, create an instance of the mapper with the necessary mapping profiles, such as the "accountmappingprofile." this way, the real mapping logic is used, providing more accurate and valuable testing.

conclusion of mistake 2

mocking the imapper interface in unit tests is not the proper approach for testing code that relies on object mapping. it is better to use the mapping library within the tests and ensure that the mapping process functions correctly. additional information: unit tests should reflect the actual functionality and behavior of the code, including the object mapping process.

mistake 3: lack of proper error handling and logging

the third mistake that developers often make when dealing with object mapping in c# is neglecting proper error handling and logging.

error handling

during the object mapping process, there might be scenarios where exceptions occur, such as invalid data or mapping failures. it is essential to handle these exceptions gracefully and provide meaningful error messages to the user or log them appropriately.


logging is a crucial aspect of any application. it allows developers to track the flow of execution, diagnose issues, and monitor the application's performance. when it comes to object mapping, logging can be particularly useful to identify mapping failures, debug issues, and monitor the overall efficiency of the mapping process.

conclusion of mistake 3

to ensure robust and maintainable code, developers should incorporate proper error handling and logging when dealing with object mapping in c#. this includes handling exceptions during the mapping process and implementing logging mechanisms to track mapping issues and performance. additional information: logging frameworks like serilog can facilitate effective logging in c# applications.


in this article, we discussed the three biggest mistakes developers make in object mapping in c#. by avoiding these mistakes, you can enhance the quality, maintainability, and performance of your codebase. remember to separate business logic from the mapper, use the actual mapping library in tests, and implement proper error handling and logging. object mapping is a crucial aspect of many applications, so it is essential to handle it correctly to optimize its potential.

note: don't forget to check out our course "from zero to hero logging.net" on domtrain.com, where we delve deeper into logging and cover advanced features and performance optimizations.

Previous Post

Dotnet 8: Solving the Issue with Immutable Arrays in C

Next Post

How Microsoft Addressed Feedback and Improved the Time Provider in .NET 8

About The auther

New Posts

Popular Post