ClassAdapter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Mapster.Models;
using Mapster.Utils;

namespace Mapster.Adapters
{
    /// <summary>
    /// Maps one class to another.
    /// </summary>
    /// <remarks>The operations in this class must be extremely fast.  Make sure to benchmark before making **any** changes in here.
    /// The core Adapt method is critically important to performance.
    /// </remarks>
    internal class ClassAdapter : BaseClassAdapter
    {
        protected override int Score => -200;

        protected override bool CanMap(PreCompileArgument arg)
        {
            return arg.ExplicitMapping || arg.DestinationType.IsPoco();
        }

        protected override bool CanInline(Expression source, Expression? destination, CompileArgument arg)
        {
            if (!base.CanInline(source, destination, arg))
                return false;

            if (arg.MapType == MapType.MapToTarget)
                return false;
            var constructUsing = arg.GetConstructUsing();
            if (constructUsing != null &&
                constructUsing.Body.NodeType != ExpressionType.New &&
                constructUsing.Body.NodeType != ExpressionType.MemberInit)
            {
                if (arg.MapType == MapType.Projection)
                    throw new InvalidOperationException("ConstructUsing for projection is support only New and MemberInit expression.");
                return false;
            }

            //Ignore, IgnoreNullValue isn't supported by projection
            if (arg.MapType == MapType.Projection)
                return true;
            if (arg.Settings.IgnoreNullValues == true)
                return false;
            if (arg.Settings.Ignore.Any(item => item.Value.Condition != null))
                return false;
            return true;
        }

        protected override Expression CreateInstantiationExpression(Expression source, Expression? destination, CompileArgument arg)
        {
            //new TDestination(src.Prop1, src.Prop2)

            if (arg.DestinationType.isDefaultCtor() || arg.GetConstructUsing() != null)
                if (arg.Settings.MapToConstructor == null)
                    return base.CreateInstantiationExpression(source, destination, arg);

            ClassMapping? classConverter;
            var ctor = arg.Settings.MapToConstructor as ConstructorInfo;
            if (ctor == null)
            {
                var destType = arg.DestinationType.GetTypeInfo().IsInterface
                    ? DynamicTypeGenerator.GetTypeForInterface(arg.DestinationType, arg.Settings.Includes.Count > 0)
                    : arg.DestinationType;
                if (destType == null)
                    return base.CreateInstantiationExpression(source, destination, arg);
                
                var constructors = destType.GetConstructors();
                classConverter = constructors
                    .OrderByDescending(it => it.GetParameters().Length)
                    .Select(it => GetConstructorModel(it, true))
                    .Select(it => CreateClassConverter(source, it, arg, ctorMapping: true))
                    .FirstOrDefault(it => it != null);

                if (classConverter == null && constructors.Length > 0)
                    classConverter = CreateClassConverter(source, GetConstructorModel(constructors[0], false), arg, ctorMapping: true);
            }
            else
            {
                var model = GetConstructorModel(ctor, false);
                classConverter = CreateClassConverter(source, model, arg, ctorMapping:true);
            }

            if (classConverter == null)
                return base.CreateInstantiationExpression(source, destination, arg);

            return CreateInstantiationExpression(source, classConverter, arg, destination);
        }

        protected override Expression CreateBlockExpression(Expression source, Expression destination, CompileArgument arg)
        {
            //### !IgnoreNullValues
            //dest.Prop1 = convert(src.Prop1);
            //dest.Prop2 = convert(src.Prop2);

            //### IgnoreNullValues
            //if (src.Prop1 != null)
            //  dest.Prop1 = convert(src.Prop1);
            //if (src.Prop2 != null)
            //  dest.Prop2 = convert(src.Prop2);

            var classModel = GetSetterModel(arg);
            var classConverter = CreateClassConverter(source, classModel, arg, destination);
            var members = classConverter.Members;

            var lines = new List<Expression>();
            Dictionary<LambdaExpression, Tuple<List<Expression>, Expression>>? conditions = null;
            foreach (var member in members)
            {
                var destMember = arg.MapType == MapType.MapToTarget || member.UseDestinationValue
                    ? member.DestinationMember.GetExpression(destination)
                    : null;

                Expression adapt;

                // convert ApplyNullable Propagation for NotPrimitive Nullable types
                if (member.Getter is ConditionalExpression cond && member.Getter.Type.IsNotPrimitiveNullableType()
                    && !member.DestinationMember.Type.IsNullable())
                {
                    var value = CreateAdaptExpression(cond.IfTrue.GetNotPrimitiveNullableValue(), member.DestinationMember.Type, arg, member, destMember);
                   adapt = Expression.Condition(cond.Test, value, member.DestinationMember.Type.CreateDefault());
                }
                else
                    adapt = CreateAdaptExpression(member.Getter, member.DestinationMember.Type, arg, member, destMember);

                if (member.UseDestinationValue
                    && member.DestinationMember.Type.IsMapsterImmutable()
                    && member.DestinationMember.SetterModifier == AccessModifier.None)
                {
                    if (member.DestinationMember is PropertyModel && arg.MapType != MapType.Projection)
                        adapt = SetValueTypeAutoPropertyByReflection(member, adapt, classModel);
                    else
                        continue;
                    if (adapt == Expression.Empty())
                        continue;
                }
              
                if (!member.UseDestinationValue)
                {
                    if (arg.Settings.IgnoreNullValues == true && member.Getter.CanBeNull())
                    {
                        if (adapt is ConditionalExpression condEx)
                        {
                            if (condEx.Test is BinaryExpression {NodeType: ExpressionType.Equal} binEx && 
                                binEx.Left == member.Getter && 
                                binEx.Right is ConstantExpression {Value: null})
                                adapt = condEx.IfFalse;
                        }
                        adapt = member.DestinationMember.SetExpression(destination, adapt);
                        var condition = Expression.NotEqual(member.Getter, Expression.Constant(null, member.Getter.Type));
                        adapt = Expression.IfThen(condition, adapt);
                    }
                    else
                    {
                        //Todo Try catch block should be removed after pull request approved
                        try
                        {
                            if (member.DestinationMember.SetterModifier != AccessModifier.None)
                            {
                                var destinationPropertyInfo = (PropertyInfo)member.DestinationMember.Info!;
                                adapt = destinationPropertyInfo.IsInitOnly()
                                    ? SetValueByReflection(member, (MemberExpression)adapt)
                                    : member.DestinationMember.SetExpression(destination, adapt);
                            }

                        }
                        catch (Exception e)
                        {
                            adapt = member.DestinationMember.SetExpression(destination, adapt);
                        }
                    }
                }
                else if (!adapt.IsComplex())
                    continue;

                if (member.Ignore.Condition != null)
                {
                    conditions ??= new Dictionary<LambdaExpression, Tuple<List<Expression>, Expression>>();
                    if (!conditions.TryGetValue(member.Ignore.Condition, out var tuple))
                    {
                        var body = member.Ignore.IsChildPath
                            ? member.Ignore.Condition.Body
                            : member.Ignore.Condition.Apply(arg.MapType, source, destination);
                        tuple = Tuple.Create(new List<Expression>(), body);
                        conditions[member.Ignore.Condition] = tuple;
                    }

                    tuple.Item1.Add(adapt);
                }
                else
                    lines.Add(adapt);
            }

            if (conditions != null)
            {
                foreach (var kvp in conditions)
                {
                    var condition = Expression.IfThen(
                        ExpressionEx.Not(kvp.Value.Item2),
                        Expression.Block(kvp.Value.Item1));
                    lines.Add(condition);
                }
            }

            return lines.Count > 0 ? (Expression)Expression.Block(lines) : Expression.Empty();
        }

        private static Expression SetValueByReflection(MemberMapping member, MemberExpression adapt)
        {
            var typeofExpression = Expression.Constant(member.Destination!.Type);
            var getPropertyMethod = typeof(Type).GetMethod("GetProperty", new[] { typeof(string), typeof(Type) })!;
            var getPropertyExpression = Expression.Call(typeofExpression, getPropertyMethod,
                new[] { Expression.Constant(member.DestinationMember.Name), Expression.Constant(member.DestinationMember.Type) });
            var setValueMethod =
                typeof(PropertyInfo).GetMethod("SetValue", new[] { typeof(object), typeof(object) })!;
            var memberAsObject = adapt.To(typeof(object));
            return Expression.Call(getPropertyExpression, setValueMethod,
                new[] { member.Destination, memberAsObject });
        }

        protected override Expression? CreateInlineExpression(Expression source, CompileArgument arg, bool IsRequiredOnly = false)
        {
            //new TDestination {
            //  Prop1 = convert(src.Prop1),
            //  Prop2 = convert(src.Prop2),
            //}

            var exp = CreateInstantiationExpression(source, arg);
            var memberInit = exp as MemberInitExpression;
            var newInstance = memberInit?.NewExpression ?? (NewExpression)exp;
            var contructorMembers = newInstance.GetAllMemberExpressionsMemberInfo().ToArray();
            ClassModel? classModel;
            ClassMapping? classConverter;
            if (IsRequiredOnly)
            {
                classModel = GetOnlyRequiredPropertySetterModel(arg);
                classConverter = CreateClassConverter(source, classModel, arg, ctorMapping: true);
            }
            else
            {
                classModel = GetSetterModel(arg);
                classConverter = CreateClassConverter(source, classModel, arg);
            }
            var members = classConverter.Members;

            var lines = new List<MemberBinding>();
            if (memberInit != null)
                lines.AddRange(memberInit.Bindings);
            foreach (var member in members)
            {
                if (member.UseDestinationValue)
                    return null;

                if (!arg.Settings.Resolvers.Any(r => r.DestinationMemberName == member.DestinationMember.Name) 
                    && member.Getter is MemberExpression memberExp && contructorMembers.Contains(memberExp.Member))
                    continue;

                if (member.DestinationMember.SetterModifier == AccessModifier.None)
                    continue;

                Expression value;

                // convert ApplyNullable Propagation for NotPrimitive Nullable types
                if (member.Getter is ConditionalExpression cond && member.Getter.Type.IsNotPrimitiveNullableType() 
                    && !member.DestinationMember.Type.IsNullable())
                {
                    var adapt = CreateAdaptExpression(cond.IfTrue.GetNotPrimitiveNullableValue(), member.DestinationMember.Type, arg, member);
                    value = Expression.Condition(cond.Test, adapt, member.DestinationMember.Type.CreateDefault());
                }
                else
                    value = CreateAdaptExpression(member.Getter, member.DestinationMember.Type, arg, member);

                //special null property check for projection
                //if we don't set null to property, EF will create empty object
                //except collection type & complex type which cannot be null
                if (arg.MapType == MapType.Projection
                    && member.Getter.Type != member.DestinationMember.Type
                    && !member.Getter.Type.IsCollection()
                    && !member.DestinationMember.Type.IsCollection()
                    && member.Getter.Type.GetTypeInfo().GetCustomAttributesData().All(attr => attr.GetAttributeType().Name != "ComplexTypeAttribute"))
                {
                    value = member.Getter.NotNullReturn(value);
                }
                var bind = Expression.Bind((MemberInfo)member.DestinationMember.Info!, value);
                lines.Add(bind);
            }

            return Expression.MemberInit(newInstance, lines);
        }
    }
}