Add Inherits Lasyload

Author: DocSvartz

src/Mapster/Models/TypeTuple.cs

@@ -40,4 +40,50 @@ public TypeTuple(Type source, Type destination)
             Destination = destination;
         }
     }
+
+    public class InheritsTypeTuple : IEquatable<InheritsTypeTuple>
+    {
+        public bool Equals(InheritsTypeTuple other)
+        {
+            return Source == other.Source && Destination == other.Destination;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is InheritsTypeTuple))
+                return false;
+            return Equals((InheritsTypeTuple)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return (Source.GetHashCode() << 16) ^ (Destination.GetHashCode() & 65535);
+        }
+
+        public static bool operator ==(InheritsTypeTuple left, InheritsTypeTuple right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(InheritsTypeTuple left, InheritsTypeTuple right)
+        {
+            return !left.Equals(right);
+        }
+
+        public Type Source { get; }
+        public Type Destination { get; }
+        public bool IsLoading { get; private set; }
+
+        public void IsUploaded()
+        {
+            IsLoading = true;
+        }
+
+        public InheritsTypeTuple(Type source, Type destination)
+        {
+            Source = source;
+            Destination = destination;
+            IsLoading = false;
+        }
+    }
 }

src/Mapster/TypeAdapter.cs

@@ -1,8 +1,9 @@
-using System;
+using Mapster.Models;
+using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Reflection;
-using Mapster.Models;
 
 namespace Mapster
 {
@@ -38,6 +39,14 @@ public static TDestination Adapt<TDestination>(this object? source)
         /// <returns>Adapted destination type.</returns>
         public static TDestination Adapt<TDestination>(this object? source, TypeAdapterConfig config)
         {
+            if (config.RuleMap.TryGetValue(new TypeTuple(source.GetType(), typeof(TDestination)), out var rule))
+            {
+                if (rule.Settings.InheritsTypeTuples.Count > 0)
+                {
+                    LoadInheritedRules(config, rule, rule.Settings.InheritsTypeTuples);
+                }
+            }
+
             // ReSharper disable once ConditionIsAlwaysTrueOrFalse
             if (source == null)
                 return default!;
@@ -46,6 +55,22 @@ public static TDestination Adapt<TDestination>(this object? source, TypeAdapterC
             return fn(source);
         }
 
+        private static void LoadInheritedRules(TypeAdapterConfig config, TypeAdapterRule rule, IEnumerable<InheritsTypeTuple> inheritedTypes)
+        {
+            foreach (var typeTuple in inheritedTypes.Where(t => !t.IsLoading))
+            {
+                if (config.RuleMap.TryGetValue(new TypeTuple(typeTuple.Source, typeTuple.Destination), out var parentRule))
+                {
+                    rule.LoadLasyInherits(parentRule);
+                    typeTuple.IsUploaded();
+                }
+                if (parentRule != null && parentRule.Settings.InheritsTypeTuples.Any())
+                {
+                    LoadInheritedRules(config, rule, parentRule.Settings.InheritsTypeTuples);
+                }
+            }
+        }
+
         /// <summary>
         /// Adapt the source object to the destination type.
         /// </summary>
@@ -254,7 +279,7 @@ public static TDestination ValidateAndAdapt<TSource, TDestination>(this TSource
             }
             return source.Adapt<TDestination>(config);
         }
-    }
+}
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S1104:Fields should not have public accessibility", Justification = "<Pending>")]
     public static class TypeAdapter<TSource, TDestination>

src/Mapster/TypeAdapterRule.cs

@@ -6,5 +6,10 @@ public class TypeAdapterRule
     {
         public Func<PreCompileArgument, int?> Priority { get; set; }
         public TypeAdapterSettings Settings { get; set; }
+
+        public void LoadLasyInherits(TypeAdapterRule rule)
+        {
+            this.Settings.Apply(rule.Settings);
+        }
     }
 }

src/Mapster/TypeAdapterSetter.cs

@@ -828,6 +828,26 @@ public TypeAdapterSetter<TSource, TDestination> Inherits<TBaseSource, TBaseDesti
             return this;
         }
 
+        public TypeAdapterSetter<TSource, TDestination> InheritsLazy<TBaseSource, TBaseDestination>()
+        {
+            this.CheckCompiled();
+
+            Type baseSourceType = typeof(TBaseSource);
+            Type baseDestinationType = typeof(TBaseDestination);
+
+            if (!baseSourceType.GetTypeInfo().IsAssignableFrom(typeof(TSource).GetTypeInfo()))
+                throw new InvalidCastException("In order to use inherits, TSource must be inherited from TBaseSource.");
+
+            if (!baseDestinationType.GetTypeInfo().IsAssignableFrom(typeof(TDestination).GetTypeInfo()))
+                throw new InvalidCastException("In order to use inherits, TDestination must be inherited from TBaseDestination.");
+
+            Settings.InheritsTypeTuples.Add(new InheritsTypeTuple(baseSourceType, baseDestinationType));
+
+
+            return this;
+        }
+
+
         public TypeAdapterSetter<TSource, TDestination> Fork(Action<TypeAdapterConfig> action)
         {
             this.CheckCompiled();

src/Mapster/TypeAdapterSettings.cs

@@ -117,6 +117,12 @@ public List<InvokerModel> Resolvers
         {
             get => Get(nameof(Resolvers), () => new List<InvokerModel>());
         }
+
+        public HashSet<InheritsTypeTuple> InheritsTypeTuples
+        {
+            get => Get(nameof(InheritsTypeTuples), () => new HashSet<InheritsTypeTuple>());
+        }
+
         public List<object> ExtraSources
         {
             get => Get(nameof(ExtraSources), () => new List<object>());