我可以在分配属性时使用执行 lambda 表达式的结果吗？

Question

I'm writing a mapper for models, and when I need to assign values to properties of type string from any other types I'd like to call the ToString() method in them, get the value, and assign it to the target property. My code looks something like this:

public class Foo
{
    public Guid Id { get; set; }
}

public class Bar
{
    public string Id { get; set; }
}

Mapping lambda expression should looks like:

...
var $1 = new Bar();
$1.Id = parameter.Id.ToString();
...

Answer 1

A working version of how to do this:

private Expression<Func<TSource, TDestination>> GenerateMapperFunc<TSource, TDestination>()
    {
        var sourceProperties = typeof(TSource)
                                .GetProperties()
                                .Where(x => x.CanRead);
        var targetProperties = typeof(TDestination)
                                .GetProperties()
                                .Where(x => x.CanWrite)
                                .ToDictionary(x => x.Name, x => x, StringComparer.OrdinalIgnoreCase);

        var source = Expression.Parameter(typeof(TSource), "source");
        var target = Expression.Variable(typeof(TDestination));
        var allocate = Expression.New(typeof(TDestination));
        var assignTarget = Expression.Assign(target, allocate);

        var statements = new List<Expression>
        {
            assignTarget
        };

        foreach (var sourceProperty in sourceProperties)
        {

            if (targetProperties.TryGetValue(sourceProperty.Name, out PropertyInfo targetProperty))
            {
                Expression sourcePropertyAssign;

                if (sourceProperty.PropertyType != targetProperty.PropertyType &&
                    sourceProperty.PropertyType == typeof(string))
                {
                    var property = Expression.Property(source, sourceProperty);

                    sourcePropertyAssign = Expression.Call(Expression.Convert(property, typeof(object)),
                                                            typeof(object).GetMethod("ToString"));
                }
                else
                {
                    sourcePropertyAssign = Expression.Property(source, sourceProperty);
                }


                var assignProperty = Expression.Assign(
                    Expression.Property(target, targetProperty),
                    sourcePropertyAssign);

                statements.Add(assignProperty);
            }
        }

        statements.Add(target);

        var body = Expression.Block(new[] { target }, statements);

        return Expression.Lambda<Func<TSource, TDestination>>(body, source);
    }