Merge pull request #96 from johelvisguzman/issue95

johelvisguzman · web-flow · commit 9d547c27fd96 · 2018-05-23T09:23:45.000-04:00
Made some performance changes to the convention helper class and repository base
diff --git a/src/DotNetToolkit.Repository.InMemory/InMemoryRepositoryBase.cs b/src/DotNetToolkit.Repository.InMemory/InMemoryRepositoryBase.cs
@@ -95,7 +95,7 @@ protected virtual void Dispose(bool disposing)
         internal void EnsureDeleted()
         {
             _items.Clear();
-            InMemoryCache<TEntity, TKey>.Instance.GetContext(DatabaseName).Clear();
+            InMemoryCache.Instance.GetContext(DatabaseName).Clear();
         }
 
         #endregion
@@ -231,7 +231,7 @@ protected override void SaveChanges()
         {
             lock (_syncRoot)
             {
-                var context = InMemoryCache<TEntity, TKey>.Instance.GetContext(DatabaseName);
+                var context = InMemoryCache.Instance.GetContext(DatabaseName);
 
                 foreach (var entitySet in _items.Select(y => y.Value))
                 {
@@ -273,7 +273,7 @@ protected override void SaveChanges()
         /// </summary>
         protected override IQueryable<TEntity> GetQuery(IFetchStrategy<TEntity> fetchStrategy = null)
         {
-            return InMemoryCache<TEntity, TKey>.Instance
+            return InMemoryCache.Instance
                 .GetContext(DatabaseName)
                 .Select(y => y.Value)
                 .AsQueryable();
@@ -284,7 +284,7 @@ protected override IQueryable<TEntity> GetQuery(IFetchStrategy<TEntity> fetchStr
         /// </summary>
         protected override TEntity GetEntity(TKey key, IFetchStrategy<TEntity> fetchStrategy)
         {
-            InMemoryCache<TEntity, TKey>.Instance
+            InMemoryCache.Instance
                 .GetContext(DatabaseName)
                 .TryGetValue(key, out TEntity entity);
 
@@ -358,17 +358,17 @@ private enum EntityState
 
         #endregion
 
-        #region Nested type: InMemoryCache<TEntity, TKey>
+        #region Nested type: InMemoryCache
 
         /// <summary>
         /// Represents an internal thread safe database storage which will store any information for the in-memory
         /// store that is needed through the life time of the application.
         /// </summary>
-        private class InMemoryCache<TEntity, TKey> where TEntity : class
+        private class InMemoryCache
         {
             #region Fields
 
-            private static volatile InMemoryCache<TEntity, TKey> _instance;
+            private static volatile InMemoryCache _instance;
             private static readonly object _syncRoot = new object();
             private readonly ConcurrentDictionary<string, SortedDictionary<TKey, TEntity>> _storage;
 
@@ -377,7 +377,7 @@ private class InMemoryCache<TEntity, TKey> where TEntity : class
             #region Constructors
 
             /// <summary>
-            /// Prevents a default instance of the <see cref="InMemoryCache{TEntity, TKey}"/> class from being created.
+            /// Prevents a default instance of the <see cref="InMemoryCache"/> class from being created.
             /// </summary>
             private InMemoryCache()
             {
@@ -391,7 +391,7 @@ private InMemoryCache()
             /// <summary>
             /// Gets the instance.
             /// </summary>
-            public static InMemoryCache<TEntity, TKey> Instance
+            public static InMemoryCache Instance
             {
                 get
                 {
@@ -400,7 +400,7 @@ public static InMemoryCache<TEntity, TKey> Instance
                         lock (_syncRoot)
                         {
                             if (_instance == null)
-                                _instance = new InMemoryCache<TEntity, TKey>();
+                                _instance = new InMemoryCache();
                         }
                     }
 
diff --git a/src/DotNetToolkit.Repository/Helpers/ConventionHelper.cs b/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;
         }
 
diff --git a/src/DotNetToolkit.Repository/Helpers/InMemoryCache.cs b/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>();
+        }
+    }
+}
diff --git a/src/DotNetToolkit.Repository/RepositoryBase.cs b/src/DotNetToolkit.Repository/RepositoryBase.cs
@@ -264,8 +264,8 @@ protected virtual TKey GeneratePrimaryKey()
             if (propertyType == typeof(int))
             {
                 var key = GetQuery()
-                    .OrderByDescending(x => x.GetPrimaryKeyPropertyValue<TKey>())
                     .Select(x => x.GetPrimaryKeyPropertyValue<TKey>())
+                    .OrderByDescending(x => x)
                     .FirstOrDefault();
 
                 return (TKey)Convert.ChangeType(Convert.ToInt32(key) + 1, typeof(TKey));

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ protected virtual void Dispose(bool disposing)`
`95`	`95`	`internal void EnsureDeleted()`
`96`	`96`	`{`
`97`	`97`	`_items.Clear();`
`98`		`- InMemoryCache<TEntity, TKey>.Instance.GetContext(DatabaseName).Clear();`
	`98`	`+ InMemoryCache.Instance.GetContext(DatabaseName).Clear();`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`#endregion`
`@@ -231,7 +231,7 @@ protected override void SaveChanges()`
`231`	`231`	`{`
`232`	`232`	`lock (_syncRoot)`
`233`	`233`	`{`
`234`		`- var context = InMemoryCache<TEntity, TKey>.Instance.GetContext(DatabaseName);`
	`234`	`+ var context = InMemoryCache.Instance.GetContext(DatabaseName);`
`235`	`235`
`236`	`236`	`foreach (var entitySet in _items.Select(y => y.Value))`
`237`	`237`	`{`
`@@ -273,7 +273,7 @@ protected override void SaveChanges()`
`273`	`273`	`/// </summary>`
`274`	`274`	`protected override IQueryable<TEntity> GetQuery(IFetchStrategy<TEntity> fetchStrategy = null)`
`275`	`275`	`{`
`276`		`- return InMemoryCache<TEntity, TKey>.Instance`
	`276`	`+ return InMemoryCache.Instance`
`277`	`277`	`.GetContext(DatabaseName)`
`278`	`278`	`.Select(y => y.Value)`
`279`	`279`	`.AsQueryable();`
`@@ -284,7 +284,7 @@ protected override IQueryable<TEntity> GetQuery(IFetchStrategy<TEntity> fetchStr`
`284`	`284`	`/// </summary>`
`285`	`285`	`protected override TEntity GetEntity(TKey key, IFetchStrategy<TEntity> fetchStrategy)`
`286`	`286`	`{`
`287`		`- InMemoryCache<TEntity, TKey>.Instance`
	`287`	`+ InMemoryCache.Instance`
`288`	`288`	`.GetContext(DatabaseName)`
`289`	`289`	`.TryGetValue(key, out TEntity entity);`
`290`	`290`
`@@ -358,17 +358,17 @@ private enum EntityState`
`358`	`358`
`359`	`359`	`#endregion`
`360`	`360`
`361`		`- #region Nested type: InMemoryCache<TEntity, TKey>`
	`361`	`+ #region Nested type: InMemoryCache`
`362`	`362`
`363`	`363`	`/// <summary>`
`364`	`364`	`/// Represents an internal thread safe database storage which will store any information for the in-memory`
`365`	`365`	`/// store that is needed through the life time of the application.`
`366`	`366`	`/// </summary>`
`367`		`- private class InMemoryCache<TEntity, TKey> where TEntity : class`
	`367`	`+ private class InMemoryCache`
`368`	`368`	`{`
`369`	`369`	`#region Fields`
`370`	`370`
`371`		`- private static volatile InMemoryCache<TEntity, TKey> _instance;`
	`371`	`+ private static volatile InMemoryCache _instance;`
`372`	`372`	`private static readonly object _syncRoot = new object();`
`373`	`373`	`private readonly ConcurrentDictionary<string, SortedDictionary<TKey, TEntity>> _storage;`
`374`	`374`
`@@ -377,7 +377,7 @@ private class InMemoryCache<TEntity, TKey> where TEntity : class`
`377`	`377`	`#region Constructors`
`378`	`378`
`379`	`379`	`/// <summary>`
`380`		`- /// Prevents a default instance of the <see cref="InMemoryCache{TEntity, TKey}"/> class from being created.`
	`380`	`+ /// Prevents a default instance of the <see cref="InMemoryCache"/> class from being created.`
`381`	`381`	`/// </summary>`
`382`	`382`	`private InMemoryCache()`
`383`	`383`	`{`
`@@ -391,7 +391,7 @@ private InMemoryCache()`
`391`	`391`	`/// <summary>`
`392`	`392`	`/// Gets the instance.`
`393`	`393`	`/// </summary>`
`394`		`- public static InMemoryCache<TEntity, TKey> Instance`
	`394`	`+ public static InMemoryCache Instance`
`395`	`395`	`{`
`396`	`396`	`get`
`397`	`397`	`{`
`@@ -400,7 +400,7 @@ public static InMemoryCache<TEntity, TKey> Instance`
`400`	`400`	`lock (_syncRoot)`
`401`	`401`	`{`
`402`	`402`	`if (_instance == null)`
`403`		`- _instance = new InMemoryCache<TEntity, TKey>();`
	`403`	`+ _instance = new InMemoryCache();`
`404`	`404`	`}`
`405`	`405`	`}`
`406`	`406`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,9 @@ public static PropertyInfo GetPrimaryKeyPropertyInfo(this Type entityType)`
`60`	`60`	`if (entityType == null)`
`61`	`61`	`throw new ArgumentNullException(nameof(entityType));`
`62`	`62`
	`63`	`+ if (InMemoryCache.Instance.PrimaryKeyMapping.ContainsKey(entityType))`
	`64`	`+ return InMemoryCache.Instance.PrimaryKeyMapping[entityType];`
	`65`	`+`
`63`	`66`	`var propertyInfo = entityType`
`64`	`67`	`.GetRuntimeProperties()`
`65`	`68`	`.Where(x => x.IsMapped())`
`@@ -74,6 +77,8 @@ public static PropertyInfo GetPrimaryKeyPropertyInfo(this Type entityType)`
`74`	`77`
`75`	`78`	`if (propertyInfo != null && propertyInfo.IsMapped())`
`76`	`79`	`{`
	`80`	`+ InMemoryCache.Instance.PrimaryKeyMapping[entityType] = propertyInfo;`
	`81`	`+`
`77`	`82`	`return propertyInfo;`
`78`	`83`	`}`
`79`	`84`	`}`
`@@ -97,11 +102,16 @@ public static PropertyInfo GetPrimaryKeyPropertyInfo<T>()`
`97`	`102`	`/// <returns>The name of the table.</returns>`
`98`	`103`	`public static string GetTableName(this Type entityType)`
`99`	`104`	`{`
	`105`	`+ if (InMemoryCache.Instance.TableNameMapping.ContainsKey(entityType))`
	`106`	`+ return InMemoryCache.Instance.TableNameMapping[entityType];`
	`107`	`+`
`100`	`108`	`var tableName = entityType.GetTypeInfo().GetCustomAttribute<TableAttribute>()?.Name;`
`101`	`109`
`102`	`110`	`if (string.IsNullOrEmpty(tableName))`
`103`	`111`	`tableName = PluralizationHelper.Pluralize(entityType.Name);`
`104`	`112`
	`113`	`+ InMemoryCache.Instance.TableNameMapping[entityType] = tableName;`
	`114`	`+`
`105`	`115`	`return tableName;`
`106`	`116`	`}`
`107`	`117`
`@@ -145,6 +155,11 @@ public static int GetColumnOrder(this PropertyInfo pi)`
`145`	`155`	`/// <returns>The name of the foreign key.</returns>`
`146`	`156`	`public static PropertyInfo GetForeignKeyPropertyInfo(this Type sourceType, Type foreignType)`
`147`	`157`	`{`
	`158`	`+ var tupleKey = Tuple.Create(sourceType, foreignType);`
	`159`	`+`
	`160`	`+ if (InMemoryCache.Instance.ForeignKeyMapping.ContainsKey(tupleKey))`
	`161`	`+ return InMemoryCache.Instance.ForeignKeyMapping[tupleKey];`
	`162`	`+`
`148`	`163`	`var properties = sourceType.GetRuntimeProperties().Where(x => x.IsMapped());`
`149`	`164`	`var foreignPropertyInfo = properties.SingleOrDefault(x => x.PropertyType == foreignType);`
`150`	`165`
`@@ -179,6 +194,8 @@ public static PropertyInfo GetForeignKeyPropertyInfo(this Type sourceType, Type`
`179`	`194`	`}`
`180`	`195`	`}`
`181`	`196`
	`197`	`+ InMemoryCache.Instance.ForeignKeyMapping[tupleKey] = propertyInfo;`
	`198`	`+`
`182`	`199`	`return propertyInfo;`
`183`	`200`	`}`
`184`	`201`
Original file line number	Diff line number	Diff line change
`@@ -264,8 +264,8 @@ protected virtual TKey GeneratePrimaryKey()`
`264`	`264`	`if (propertyType == typeof(int))`
`265`	`265`	`{`
`266`	`266`	`var key = GetQuery()`
`267`		`- .OrderByDescending(x => x.GetPrimaryKeyPropertyValue<TKey>())`
`268`	`267`	`.Select(x => x.GetPrimaryKeyPropertyValue<TKey>())`
	`268`	`+ .OrderByDescending(x => x)`
`269`	`269`	`.FirstOrDefault();`
`270`	`270`
`271`	`271`	`return (TKey)Convert.ChangeType(Convert.ToInt32(key) + 1, typeof(TKey));`