From DTO to ViewModel: Mapping Strategies Between Layers in C#

Introduction to DTO and ViewModel Concepts

In application development, especially in layered architecture, two fundamental concepts arise: Data Transfer Object (DTO) and ViewModel. Both play crucial roles in separation of concerns and maintaining data integrity. A DTO is used to transfer data between processes, while a ViewModel encapsulates the data needed for the presentation layer, often including display-specific logic.

The Role of DTO

DTOs are essential for optimizing communication between the persistence layer and the presentation layer (VIEIRA et al., 2024). They allow you to transfer only the necessary data, minimizing network overhead and improving application performance. A simple example of a DTO in C# can be seen below:

public class UserDTO
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

In this example, the UserDTO contains only the properties we want to transfer, without including business logic or other details that are not necessary for the presentation layer. This facilitates data deserialization and serialization between the client and the server, ensuring that only the necessary information is transmitted.

The Role of ViewModel

The ViewModel, on the other hand, is designed to meet the specific needs of the user interface. It may include properties that are not directly related to the model data but are necessary for display. For example:

using System.ComponentModel.DataAnnotations;
public class UserViewModel
{
    public int Id { get; set; }

    [Required(ErrorMessage = "Name is required.")]
    [StringLength(100, ErrorMessage = "Name must be a maximum of 100 characters.")]
    public string Name { get; set; }

    [Required(ErrorMessage = "Email is required.")]
    [EmailAddress(ErrorMessage = "Invalid email format.")]
    public string Email { get; set; }

    [Display(Name = "Registration Date")]
    [DataType(DataType.Date)]
    public DateTime RegisteredAt { get; set; }

    [Display(Name = "Email Verified")]
    public bool IsEmailVerified { get; set; }
}

The property IsEmailVerified can be calculated from the DTO, but it is not part of the data transferred from the database. This demonstrates how the ViewModel can be tailored to meet the specific needs of the interface, including additional information not present in the data model.

Mapping Strategies between DTO and ViewModel

The mapping between DTOs and ViewModels can be done in various ways. Below, we will explore some of the most common strategies, including the use of mapping libraries and manual implementations.

Using AutoMapper for Mapping

One of the most popular libraries for mapping in C# is AutoMapper. It allows you to define mappings between types in a simple and straightforward manner (BOGARD, 2025). Here’s how to set up and use AutoMapper:

using AutoMapper;
public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<UserDTO, UserViewModel>()
            .ForMember(dest => dest.IsEmailVerified, opt => opt.MapFrom(src => 
            !string.IsNullOrEmpty(src.Email)));
    }
}

// AutoMapper configuration
var config = new MapperConfiguration(cfg => cfg.AddProfile<MappingProfile>());
var mapper = config.CreateMapper();

// Using AutoMapper
UserDTO userDto = new UserDTO { Id = 1, Name = "John Doe", Email = "john@example.com" };
UserViewModel userViewModel = mapper.Map<UserViewModel>(userDto);

It is important to note that the latest versions of AutoMapper will adopt a licensing model that includes paid plans (BOGARD, 2025). While this does not affect the core functionality of the library, it may pose a limitation for teams or projects with budget constraints. In such situations, it may be necessary to opt for earlier versions that are still free or consider alternatives such as manual mapping or other open-source libraries.

Even so, AutoMapper remains an extremely efficient and productive solution for scenarios where object mapping is frequent, helping to reduce repetitive code and human errors when transferring data between layers.

Manual Mapping

While using libraries like AutoMapper is beneficial, in some cases, manual mapping may be preferable, especially when you need full control over the mapping process. Here’s an example of manual mapping:

public UserViewModel MapToViewModel(UserDTO userDto)
{
    return new UserViewModel
    {
        Id = userDto.Id,
        Name = userDto.Name,
        Email = userDto.Email,
        IsEmailVerified = !string.IsNullOrEmpty(userDto.Email)
    };
}

// Using manual mapping
UserDTO userDto = new UserDTO { Id = 1, Name = "Jane Smith", Email = "jane@example.com" };
UserViewModel userViewModel = MapToViewModel(userDto);

Manual mapping offers clarity and flexibility, allowing you to implement custom logic as needed. This is especially useful in scenarios where the mapping logic may change frequently or where complex transformations on the data are required.

Adoption and Unit Testing

When choosing a mapping strategy, it is important to consider performance and code maintainability. AutoMapper is efficient for simple and repetitive mappings but can introduce complexity in more advanced scenarios and also incur additional costs with its licensing. Manual mapping, on the other hand, may be more verbose but offers total control over what is being mapped and how. It is crucial to evaluate the application context and the frequency of changes in the models to decide which approach to adopt.

Testing the Mapping

Below is a code example to ensure that the mapping is functioning as expected. Here’s an example using xUnit:

using Xunit;

public class MappingTests
{
    private readonly IMapper _mapper;

    public MappingTests()
    {
        var config = new MapperConfiguration(cfg => cfg.AddProfile<MappingProfile>());
        _mapper = config.CreateMapper();
    }

    [Fact]
    public void Should_Map_UserDTO_To_UserViewModel()
    {
        // Arrange
        UserDTO userDto = new UserDTO { Id = 1, Name = "Alice", Email = "alice@example.com" };

        // Act
        UserViewModel userViewModel = _mapper.Map<UserViewModel>(userDto);

        // Assert
        Assert.Equal(userDto.Id, userViewModel.Id);
        Assert.Equal(userDto.Name, userViewModel.Name);
        Assert.Equal(userDto.Email, userViewModel.Email);
        Assert.True(userViewModel.IsEmailVerified);
    }
}

Tests ensure that changes in mapping do not break existing functionality, providing security and confidence in code changes. Including unit tests is a best practice that should be an integral part of the development cycle, especially in complex applications (MICROSOFT, 2025).

Conclusion

The mapping between DTOs and ViewModels is an important aspect of C# application development. Understanding the differences between these concepts and the available mapping strategies can help developers create more efficient and maintainable applications. Whether using a library like AutoMapper or opting for manual mapping, the key is to always ensure that data is transferred effectively and that presentation needs are met. By implementing appropriate tests, you can ensure that your implementations remain robust over time.