fix UseDestinationValue with collection

Author: chaowlert

src/Mapster.Tests/WhenUsingDestinationValue.cs

@@ -1,4 +1,6 @@
-using System.Linq.Expressions;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Shouldly;
 
@@ -10,20 +12,23 @@ public class WhenUsingDestinationValue
         [TestMethod]
         public void MapUsingDestinationValue()
         {
+            TypeAdapterConfig.GlobalSettings.Compiler = exp => exp.CompileWithDebugInfo();
             TypeAdapterConfig<Invoice, InvoiceDto>.NewConfig().TwoWays();
 
             var dto = new InvoiceDto
             {
                 Id = 1,
                 DocumentNumber = "AA001",
                 SupplierCompany = "COM01",
-                SupplierName = "Apple"
+                SupplierName = "Apple",
+                Numbers = Enumerable.Range(1, 5).ToList(),
             };
             var poco = dto.Adapt<Invoice>();
             poco.Id.ShouldBe(dto.Id);
             poco.DocumentNumber.ShouldBe("FOO");
             poco.Supplier.Name.ShouldBe(dto.SupplierName);
             poco.Supplier.Company.ShouldBe(dto.SupplierCompany);
+            poco.Numbers.ShouldBe(Enumerable.Range(1, 5));
         }
 
         public class ContractingParty
@@ -41,6 +46,9 @@ public class Invoice
 
             [UseDestinationValue]
             public ContractingParty Supplier { get; } = new ContractingParty();
+
+            [UseDestinationValue]
+            public ICollection<int> Numbers { get; } = new List<int>();
         }
 
         public class InvoiceDto
@@ -49,6 +57,7 @@ public class InvoiceDto
             public string DocumentNumber { get; set; }
             public string SupplierName { get; set; }
             public string SupplierCompany { get; set; }
+            public IEnumerable<int> Numbers { get; set; }
         }
     }
 }

src/Mapster/Adapters/ArrayAdapter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -19,7 +20,26 @@ protected override bool CanMap(PreCompileArgument arg)
 
         protected override bool CanInline(Expression source, Expression? destination, CompileArgument arg)
         {
-            return arg.MapType == MapType.Projection || ExpressionEx.CreateCountExpression(source) == null;
+            return arg.MapType == MapType.Projection;
+        }
+
+        protected override Expression TransformSource(Expression source)
+        {
+            if (ExpressionEx.CreateCountExpression(source) != null)
+                return source;
+            var transformed = source;
+            var elemType = source.Type.ExtractCollectionType();
+            var type = typeof(IEnumerable<>).MakeGenericType(elemType);
+            if (!type.IsAssignableFrom(source.Type))
+            {
+                var cast = typeof(Enumerable).GetMethod(nameof(Enumerable.Cast))!
+                    .MakeGenericMethod(elemType);
+                transformed = Expression.Call(cast, transformed);
+            }
+
+            var toList = typeof(Enumerable).GetMethod(nameof(Enumerable.ToList))!
+                .MakeGenericMethod(elemType);
+            return Expression.Call(toList, transformed);
         }
 
         protected override Expression CreateInstantiationExpression(Expression source, Expression? destination, CompileArgument arg)
@@ -39,7 +59,12 @@ protected override Expression CreateBlockExpression(Expression source, Expressio
             {
                 //Array.Copy(src, 0, dest, 0, src.Length)
                 var method = typeof(Array).GetMethod("Copy", new[] { typeof(Array), typeof(int), typeof(Array), typeof(int), typeof(int) });
-                return Expression.Call(method, source, Expression.Constant(0), destination, Expression.Constant(0), ExpressionEx.CreateCountExpression(source));
+                var len = arg.UseDestinationValue
+                    ? Expression.Call(typeof(Math).GetMethod("Min", new[] {typeof(int), typeof(int)}),
+                        ExpressionEx.CreateCountExpression(source), 
+                        ExpressionEx.CreateCountExpression(destination))
+                    : ExpressionEx.CreateCountExpression(source);
+                return Expression.Call(method, source, Expression.Constant(0), destination, Expression.Constant(0), len);
             }
 
             return CreateArraySet(source, destination, arg);

src/Mapster/Adapters/BaseAdapter.cs

@@ -111,6 +111,7 @@ protected virtual Expression CreateExpressionBody(Expression source, Expression?
 
                 if (arg.Context.Running.Count > 1 && 
                     !arg.Context.Config.SelfContainedCodeGeneration &&
+                    !arg.UseDestinationValue &&
                     !arg.Context.IsSubFunction())
                 {
                     if (destination == null)
@@ -195,7 +196,7 @@ protected Expression CreateBlockExpressionBody(Expression source, Expression? de
                 transformedSource = src;
             }
             var set = CreateInstantiationExpression(transformedSource, destination, arg);
-            if (destination != null && this.UseTargetValue && arg.GetConstructUsing()?.Parameters.Count != 2 && destination.CanBeNull())
+            if (destination != null && (this.UseTargetValue || arg.UseDestinationValue) && arg.GetConstructUsing()?.Parameters.Count != 2 && destination.CanBeNull())
             {
                 //dest ?? new TDest();
                 set = Expression.Coalesce(destination, set);

src/Mapster/Adapters/CollectionAdapter.cs

@@ -94,6 +94,13 @@ protected override Expression CreateBlockExpression(Expression source, Expressio
                 actions.Add(ExpressionEx.Assign(list, destination)); //convert to list type
             }
 
+            //list.Clear();
+            if (arg.UseDestinationValue && arg.MapType == MapType.MapToTarget)
+            {
+                var clear = list.Type.GetMethod("Clear", Type.EmptyTypes);
+                actions.Add(Expression.Call(list, clear));
+            }
+
             actions.Add(CreateListSet(source, list, arg));
 
             if (shouldConvert)

src/Mapster/Adapters/DictionaryAdapter.cs

@@ -70,12 +70,10 @@ protected override Expression CreateBlockExpression(Expression source, Expressio
                     : mapped;
             }
 
-            
             //if (object.ReferenceEquals(source, destination))
             //  return destination;
             LabelTarget? label = null;
-            if (destination != null && 
-                source.Type.IsObjectReference() &&
+            if (source.Type.IsObjectReference() &&
                 destination.Type.IsObjectReference() &&
                 (source.Type.IsAssignableFrom(destination.Type) || destination.Type.IsAssignableFrom(source.Type)))
             {
@@ -84,7 +82,6 @@ protected override Expression CreateBlockExpression(Expression source, Expressio
                 actions.Add(Expression.IfThen(refEquals, Expression.Return(label, destination)));
             }
 
-
             var keyType = srcDictType.GetGenericArguments().First();
             var kvpType = source.Type.ExtractCollectionType();
             var kvp = Expression.Variable(kvpType, "kvp");

src/Mapster/Compile/CompileArgument.cs

@@ -14,6 +14,7 @@ public class CompileArgument
         public bool ExplicitMapping { get; set; }
         public TypeAdapterSettings Settings { get; set; }
         public CompileContext Context { get; set; }
+        public bool UseDestinationValue { get; set; }
 
         private HashSet<string>? _srcNames;
         internal HashSet<string> GetSourceNames()

src/Mapster/TypeAdapterConfig.cs

@@ -407,6 +407,7 @@ internal LambdaExpression CreateInlineMapExpression(Type sourceType, Type destin
                 {
                     arg.Settings.Resolvers.AddRange(mapping.NextResolvers);
                     arg.Settings.Ignore.Apply(mapping.NextIgnore);
+                    arg.UseDestinationValue = mapping.UseDestinationValue;
                 }
 
                 return CreateMapExpression(arg);