Using hash codes for Members and certain cache key types

Author: SteveWilkes

AgileMapper/Members/MappingTypes.cs

@@ -6,16 +6,21 @@ namespace AgileObjects.AgileMapper.Members
 
     internal class MappingTypes
     {
+        private readonly int _hashCode;
+
         public MappingTypes(
             Type sourceType,
             Type targetType,
-            bool runtimeTypesAreTheSame,
-            bool isEnumerable)
+            bool runtimeTypesAreTheSame)
         {
             SourceType = sourceType;
             TargetType = targetType;
             RuntimeTypesAreTheSame = runtimeTypesAreTheSame;
-            IsEnumerable = isEnumerable;
+
+            unchecked
+            {
+                _hashCode = (sourceType.GetHashCode() * 397) ^ targetType.GetHashCode();
+            }
         }
 
         #region Factory Method
@@ -85,8 +90,7 @@ public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
             return new MappingTypes(
                 sourceType,
                 targetType,
-                false, // <- runtimeTypesAreTheSame
-                isEnumerable);
+                false);
         }
 
         #endregion
@@ -99,25 +103,14 @@ public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
 
         public bool RuntimeTypesAreTheSame { get; }
 
-        public bool IsEnumerable { get; }
-
-        public bool Equals(MappingTypes otherTypes)
-        {
-            if (otherTypes == this)
-            {
-                return true;
-            }
-
-            return (otherTypes.SourceType == SourceType) && (otherTypes.TargetType == TargetType);
-        }
+        public bool Equals(MappingTypes otherTypes) => otherTypes._hashCode == _hashCode;
 
         public MappingTypes WithTypes<TNewSource, TNewTarget>()
         {
             return new MappingTypes(
                 typeof(TNewSource),
                 typeof(TNewTarget),
-                RuntimeTypesAreTheSame,
-                IsEnumerable);
+                RuntimeTypesAreTheSame);
         }
     }
 
@@ -129,7 +122,6 @@ internal static class MappingTypes<TSource, TTarget>
         public static readonly MappingTypes Fixed = new MappingTypes(
             typeof(TSource),
             typeof(TTarget),
-            true, // <- runtimeTypesAreTheSame
-            TypeInfo<TTarget>.IsEnumerable);
+            true);
     }
 }

AgileMapper/Members/Member.cs

@@ -1,9 +1,6 @@
 namespace AgileObjects.AgileMapper.Members
 {
     using System;
-#if NET_STANDARD
-    using System.Linq;
-#endif
     using System.Linq.Expressions;
     using System.Reflection;
     using Dictionaries;
@@ -18,6 +15,7 @@ internal class Member
         public const string RootTargetMemberName = "Target";
 
         private readonly Func<Expression, MemberInfo, Expression> _accessFactory;
+        private readonly int _hashCode;
 
         private Member(
             MemberType memberType,
@@ -55,6 +53,13 @@ private Member(
             IsWriteable = isWriteable;
             IsRoot = isRoot;
 
+            _hashCode = declaringType.GetHashCode();
+
+            unchecked
+            {
+                _hashCode = (_hashCode * 397) ^ name.GetHashCode();
+            }
+
             JoiningName = (isRoot || this.IsEnumerableElement()) ? name : "." + name;
             IsReadable = memberType.IsReadable();
             IsEnumerable = type.IsEnumerable();
@@ -231,15 +236,7 @@ private static class TargetMemberCache<T>
             public static readonly Member MemberInstance = RootTarget(typeof(T));
         }
 
-        public bool Equals(Member otherMember)
-        {
-            if (ReferenceEquals(otherMember, this))
-            {
-                return true;
-            }
-
-            return (otherMember.DeclaringType == DeclaringType) && (otherMember.Name == Name);
-        }
+        public bool Equals(Member otherMember) => otherMember._hashCode == _hashCode;
 
         #region ExcludeFromCodeCoverage
 #if DEBUG

AgileMapper/Members/TypeKey.cs

@@ -4,13 +4,17 @@ namespace AgileObjects.AgileMapper.Members
 
     internal class TypeKey
     {
-        private readonly KeyType _keyType;
+        private readonly int _hashCode;
 
         private TypeKey(Type type, KeyType keyType, string name = null)
         {
             Type = type;
             Name = name;
-            _keyType = keyType;
+
+            unchecked
+            {
+                _hashCode = ((int)keyType * 397) ^ type.GetHashCode();
+            }
         }
 
         public static TypeKey ForSourceMembers(Type type) => new TypeKey(type, KeyType.SourceMembers);
@@ -27,18 +31,16 @@ private TypeKey(Type type, KeyType keyType, string name = null)
 
         public override bool Equals(object obj)
         {
-            var otherKey = (TypeKey)obj;
-
             // ReSharper disable once PossibleNullReferenceException
-            return (_keyType == otherKey._keyType) && (Type == otherKey.Type);
+            return obj.GetHashCode() == _hashCode;
         }
 
         #region ExcludeFromCodeCoverage
 #if DEBUG
         [ExcludeFromCodeCoverage]
 #endif
         #endregion
-        public override int GetHashCode() => 0;
+        public override int GetHashCode() => _hashCode;
 
         private enum KeyType { SourceMembers, TargetMembers, TypeId, Parameter }
     }

AgileMapper/ObjectPopulation/Enumerables/EnumerableMappingExpressionFactory.cs

@@ -10,7 +10,7 @@ internal class EnumerableMappingExpressionFactory : MappingExpressionFactoryBase
         public static readonly MappingExpressionFactoryBase Instance = new EnumerableMappingExpressionFactory();
 
         public override bool IsFor(IObjectMappingData mappingData)
-            => mappingData.MapperKey.MappingTypes.IsEnumerable;
+            => mappingData.MapperData.TargetMember.IsEnumerable;
 
         protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
         {

AgileMapper/ObjectPopulation/SourceMemberTypeDependentKeyBase.cs

@@ -9,6 +9,7 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
     internal abstract class SourceMemberTypeDependentKeyBase
     {
         private Func<IMappingData, bool> _sourceMemberTypeTester;
+        private bool _hasTypeTester;
 
         public IObjectMappingData MappingData { get; set; }
 
@@ -31,9 +32,10 @@ public void AddSourceMemberTypeTesterIfRequired(IObjectMappingData mappingData =
             var typeTestLambda = Expression.Lambda<Func<IMappingData, bool>>(typeTest, Parameters.MappingData);
 
             _sourceMemberTypeTester = typeTestLambda.Compile();
+            _hasTypeTester = true;
         }
 
         protected bool SourceHasRequiredTypes(IMappingDataOwner otherKey)
-            => (_sourceMemberTypeTester == null) || _sourceMemberTypeTester.Invoke(otherKey.MappingData);
+            => !_hasTypeTester || _sourceMemberTypeTester.Invoke(otherKey.MappingData);
     }
 }

AgileMapper/SourceAndTargetTypesKey.cs

@@ -4,10 +4,17 @@ namespace AgileObjects.AgileMapper
 
     internal class SourceAndTargetTypesKey
     {
+        private readonly int _hashCode;
+
         public SourceAndTargetTypesKey(Type sourceType, Type targetType)
         {
             SourceType = sourceType;
             TargetType = targetType;
+
+            unchecked
+            {
+                _hashCode = (sourceType.GetHashCode() * 397) ^ targetType.GetHashCode();
+            }
         }
 
         public Type SourceType { get; }
@@ -16,18 +23,15 @@ public SourceAndTargetTypesKey(Type sourceType, Type targetType)
 
         public override bool Equals(object obj)
         {
-            var otherKey = (SourceAndTargetTypesKey)obj;
-
             // ReSharper disable once PossibleNullReferenceException
-            return (otherKey.SourceType == SourceType) &&
-                   (otherKey.TargetType == TargetType);
+            return obj.GetHashCode() == _hashCode;
         }
 
         #region ExcludeFromCodeCoverage
 #if DEBUG
         [ExcludeFromCodeCoverage]
 #endif
         #endregion
-        public override int GetHashCode() => 0;
+        public override int GetHashCode() => _hashCode;
     }
 }