using System;

using System.Linq.Expressions;

using AutoMapper;

using AutoMapper.Extensions.ExpressionMapping;

​

public class Program

{

    public static void Main()

    {

        // create new AutoMapper

        var mapperConfiguration = new MapperConfiguration(

            cfg =>

            {

                cfg.CreateMap<UserId, string>().ConvertUsing(u => u.ToString());

                cfg.CreateMap<string, UserId>().ConvertUsing(u => UserId.FromString(u));

                cfg.CreateMap<User, DbUser>()

                    .ForMember(dbu => dbu.Id, opt => opt.MapFrom(u => u.Id.ToString()));

                cfg.CreateMap<DbUser, User>()

                    .ForMember(u => u.Id, opt => opt.MapFrom(dbu => UserId.FromString(dbu.Id)));

​

                cfg.AddExpressionMapping();

            }

        );

​

        mapperConfiguration.AssertConfigurationIsValid();

        IMapper mapper = mapperConfiguration.CreateMapper();

​

        // map some expression

        var idToFind = new UserId(Guid.NewGuid());

        Expression<Func<User, bool>> bllExpression = x => x.Id == idToFind;

​

        var dbExpression = mapper.MapExpression<Expression<Func<DbUser, bool>>>(bllExpression);

        Console.WriteLine(dbExpression.ToString());

    }

}

​

public class User

{

    public UserId Id { get; set; }

    public string Name { get; set; }

}

​

public class DbUser

{

    public string Id { get; set; }

    public string Name { get; set; }

}

​

public class UserId

{

    public Guid Id { get; }

​

    public UserId(Guid id) => Id = id;

​

    public override string ToString()

    {

        return Id.ToString();

    }

​

    public static UserId FromString(string value)

    {

        return new UserId(Guid.Parse(value));

    }

​

    public static bool operator ==(UserId a, UserId b)

    {

        return a?.Id == b?.Id;

    }

​

    public static bool operator !=(UserId a, UserId b)

    {

        return a?.Id != b?.Id;

    }

}