How to call awaitable method on AutoMapper Profile

I’m currently working on a project where I’m using AutoMapper to map objects between different layers of my application. In one of my AutoMapper profiles, I need to call an async method to retrieve some additional data before performing the mapping. However, it seems that AutoMapper profiles don’t directly support asynchronous methods.

Here’s a simplified example of what I’m trying to achieve:

public class Profile : AutoMapper.Profile
{
    public Profile(ISequence sequence)
    {
        CreateMap<UserDto, User>()
            .ForMember(dest => dest.UserId, options => options.MapFrom(async src => await sequence.GetNext()));
    }
}

I called async method just to demonstrate what exactly I want to acheive

AutoMapper profiles don’t support async methods in the MapFrom expression. This is because AutoMapper is designed to be a synchronous library that performs mapping operations in memory. If you need to call an async method to get some additional data, you have a few options:

• You can use the AfterMap method to perform an async operation after the mapping is done. This method accepts an Action<TSource, TDestination> delegate that can be marked as async. For example:

public class Profile : AutoMapper.Profile
{
 public Profile(ISequence sequence)
  {
   CreateMap<UserDto, User>().ForMember(dest => dest.UserId, options => options.Ignore())
.AfterMap(async (src, dest) => dest.UserId = await sequence.GetNext());
  }
}

• You can use the ProjectTo method to create a LINQ projection that can be executed asynchronously by the underlying data provider. This method allows you to use async methods in the Select expression. For example:

var users = await context.UserDtos
.ProjectTo<User>(configuration, src => sequence.GetNext())
.ToListAsync();

• You can use a custom value resolver that implements the IValueResolver<TSource, TDestination, TDestMember> interface and has an async Resolve method. For example:

public class UserIdResolver : IValueResolver<UserDto, User, int>
{
private readonly ISequence _sequence;

public UserIdResolver(ISequence sequence)
{
   _sequence = sequence;
}

public async Task<int> Resolve(UserDto source, User destination, int destMember, ResolutionContext context)
 {
   return await _sequence.GetNext();
 }
}

public class Profile : AutoMapper.Profile
{
 public Profile(ISequence sequence)
  {
   CreateMap<UserDto, User>().ForMember(dest => dest.UserId, options => options.MapFrom(new UserIdResolver(sequence)));
  }
}