Added some internal in-memory caching to the convention helper class to help with performance

Author: johelvisguzman

src/DotNetToolkit.Repository/Helpers/ConventionHelper.cs

@@ -60,6 +60,9 @@ public static PropertyInfo GetPrimaryKeyPropertyInfo(this Type entityType)
             if (entityType == null)
                 throw new ArgumentNullException(nameof(entityType));
 
+            if (InMemoryCache.Instance.PrimaryKeyMapping.ContainsKey(entityType))
+                return InMemoryCache.Instance.PrimaryKeyMapping[entityType];
+
             var propertyInfo = entityType
                 .GetRuntimeProperties()
                 .Where(x => x.IsMapped())
@@ -74,6 +77,8 @@ public static PropertyInfo GetPrimaryKeyPropertyInfo(this Type entityType)
 
                 if (propertyInfo != null && propertyInfo.IsMapped())
                 {
+                    InMemoryCache.Instance.PrimaryKeyMapping[entityType] = propertyInfo;
+
                     return propertyInfo;
                 }
             }
@@ -97,11 +102,16 @@ public static PropertyInfo GetPrimaryKeyPropertyInfo<T>()
         /// <returns>The name of the table.</returns>
         public static string GetTableName(this Type entityType)
         {
+            if (InMemoryCache.Instance.TableNameMapping.ContainsKey(entityType))
+                return InMemoryCache.Instance.TableNameMapping[entityType];
+
             var tableName = entityType.GetTypeInfo().GetCustomAttribute<TableAttribute>()?.Name;
 
             if (string.IsNullOrEmpty(tableName))
                 tableName = PluralizationHelper.Pluralize(entityType.Name);
 
+            InMemoryCache.Instance.TableNameMapping[entityType] = tableName;
+
             return tableName;
         }
 
@@ -145,6 +155,11 @@ public static int GetColumnOrder(this PropertyInfo pi)
         /// <returns>The name of the foreign key.</returns>
         public static PropertyInfo GetForeignKeyPropertyInfo(this Type sourceType, Type foreignType)
         {
+            var tupleKey = Tuple.Create(sourceType, foreignType);
+
+            if (InMemoryCache.Instance.ForeignKeyMapping.ContainsKey(tupleKey))
+                return InMemoryCache.Instance.ForeignKeyMapping[tupleKey];
+
             var properties = sourceType.GetRuntimeProperties().Where(x => x.IsMapped());
             var foreignPropertyInfo = properties.SingleOrDefault(x => x.PropertyType == foreignType);
 
@@ -179,6 +194,8 @@ public static PropertyInfo GetForeignKeyPropertyInfo(this Type sourceType, Type
                 }
             }
 
+            InMemoryCache.Instance.ForeignKeyMapping[tupleKey] = propertyInfo;
+
             return propertyInfo;
         }
 

src/DotNetToolkit.Repository/Helpers/InMemoryCache.cs

@@ -0,0 +1,40 @@
+namespace DotNetToolkit.Repository.Helpers
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Reflection;
+
+    internal class InMemoryCache
+    {
+        private static volatile InMemoryCache _instance;
+        private static readonly object _syncRoot = new object();
+
+        public static InMemoryCache Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_instance == null)
+                            _instance = new InMemoryCache();
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        public ConcurrentDictionary<Type, PropertyInfo> PrimaryKeyMapping { get; }
+        public ConcurrentDictionary<Tuple<Type, Type>, PropertyInfo> ForeignKeyMapping { get; }
+        public ConcurrentDictionary<Type, string> TableNameMapping { get; }
+
+        private InMemoryCache()
+        {
+            PrimaryKeyMapping = new ConcurrentDictionary<Type, PropertyInfo>();
+            ForeignKeyMapping = new ConcurrentDictionary<Tuple<Type, Type>, PropertyInfo>();
+            TableNameMapping = new ConcurrentDictionary<Type, string>();
+        }
+    }
+}