Fix issue #755 - revert to behavior from 7.4.0 and map to implementation not using DynamicGeneration Type

src/Mapster.Tests/WhenMappingRecordRegression.cs

@@ -278,6 +278,52 @@ public void MultiCtorAndInlineRecordWorked()
         }
 
 
+        [TestMethod]
+        public void MappingInterfaceToInterface()
+        {
+
+            SampleInterfaceClsBase source = new SampleInterfaceClsBase
+            {
+                ActivityData = new SampleActivityData
+                {
+                    Data = new SampleActivityParsedData
+                    {
+                        Steps = new List<string> { "A", "B", "C" }
+                    },
+                    Temp = "Temp data"
+
+                }
+
+            };
+            SampleInterfaceClsBase source2 = new SampleInterfaceClsBase
+            {
+                ActivityData = new SampleActivityData
+                {
+                    Data = new SampleActivityParsedData
+                    {
+                        Steps = new List<string> { "X", "Y", "Z" }
+                    },
+                    Temp = "Update Temp data"
+
+                }
+
+            };
+
+            var target = source.Adapt<SampleInterfaceClsDerived>();
+            var target2 = source2.Adapt<SampleInterfaceClsBase>();
+            var update = target.Adapt(target2);
+
+            target.ShouldNotBeNull();
+            target.ShouldSatisfyAllConditions(
+                () => target.ActivityData.ShouldBe(source.ActivityData)
+            );
+
+            update.ActivityData.ShouldBe(target.ActivityData);
+
+        }
+
+
+
         #region NowNotWorking
 
         /// <summary>
@@ -305,6 +351,69 @@ public void CollectionUpdate()
 
     #region TestClasses
 
+    public interface IActivityData : IActivityDataBase
+    {
+        public string Temp { get; set; }
+    }
+
+    public interface IActivityDataBase
+    {
+
+    }
+
+    public class SampleInterfaceClsBase
+    {
+        public IActivityDataBase? ActivityData { get; set; }
+
+        public SampleInterfaceClsBase()
+        {
+
+        }
+
+        public SampleInterfaceClsBase(IActivityDataBase data)
+        {
+            SetActivityData(data);
+        }
+
+        public void SetActivityData(IActivityDataBase data)
+        {
+            ActivityData = data;
+        }
+    }
+
+    public class SampleInterfaceClsDerived
+    {
+        public IActivityData? ActivityData { get; set; }
+
+        public SampleInterfaceClsDerived()
+        {
+
+        }
+
+        public SampleInterfaceClsDerived(IActivityData data)
+        {
+            SetActivityData(data);
+        }
+
+        public void SetActivityData(IActivityData data)
+        {
+            ActivityData = data;
+        }
+    }
+
+    public class SampleActivityData : IActivityData
+    {
+        public SampleActivityParsedData Data { get; set; }
+        public string Temp { get; set; }
+    }
+
+    public class SampleActivityParsedData
+    {
+        public List<string> Steps { get; set; } = new List<string>();
+    }
+
+
+
     class MultiCtorAndInlinePoco
     {
         public int MyInt { get; set; }
@@ -499,5 +608,14 @@ sealed record TestSealedRecord()
 
     sealed record TestSealedRecordPositional(int X);
 
+
+
+
+
+
+
+
+
+
     #endregion TestClasses
 }

src/Mapster/Adapters/ReadOnlyInterfaceAdapter.cs

@@ -45,5 +45,21 @@ protected override Expression CreateInstantiationExpression(Expression source, E
                 return base.CreateInstantiationExpression(source,destination, arg);
         }
 
+        protected override Expression CreateExpressionBody(Expression source, Expression? destination, CompileArgument arg)
+        {
+            if (source.Type.IsInterface)
+            {
+                if (arg.MapType != MapType.MapToTarget && source.Type.IsAssignableFrom(arg.DestinationType))
+                    return Expression.Convert(source, arg.DestinationType);
+
+                if (arg.MapType == MapType.MapToTarget && destination.Type.IsAssignableFrom(arg.SourceType))
+                    return source;
+
+                return base.CreateExpressionBody(source, destination, arg);
+            }
+
+            return base.CreateExpressionBody(source, destination, arg);
+        }
+
     }
 }