Performance gain on primary key lookup

Added a static dictionary that "caches" the PK lookup after the first
time.  This way it doesn't have to use reflection to get the PK property
of the entity after the first time.  It is 3 times as fast getting it
from the dictionary than using the Reflection based on my simple
testing.

SharpRepository.Repository/Helpers/InternalCache.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace SharpRepository.Repository.Helpers
+{
+    internal static class InternalCache
+    {
+        internal static readonly IDictionary<Tuple<Type, Type>, PropertyInfo> PrimaryKeyMapping = new Dictionary<Tuple<Type, Type>, PropertyInfo>();
+    }
+}

SharpRepository.Repository/RepositoryBase.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using SharpRepository.Repository.Caching;
+using SharpRepository.Repository.Helpers;
 using SharpRepository.Repository.Queries;
 using SharpRepository.Repository.Specifications;
 using SharpRepository.Repository.Transactions;
@@ -538,34 +539,34 @@ protected virtual ISpecification<T> ByPrimaryKeySpecification(TKey key)
             return new Specification<T>(lambda);
         }
 
-        // TODO: cache this call so it's done on the first loading only
         protected virtual PropertyInfo GetPrimaryKeyPropertyInfo()
         {
             // checks for properties in this order that match TKey type
             //  1) RepositoryPrimaryKeyAttribute
             //  2) Id
             //  3) [Type Name]Id
             var type = typeof(T);
-            var pkType = typeof (TKey);
+            var pkType = typeof(TKey);
+            var tupleKey = Tuple.Create(type, pkType);
+
+            // check the static cache, this means that the reflection is only done the first time this repository type is used
+            //  big performance gain from this - over 3 times faster after first load
+            if (InternalCache.PrimaryKeyMapping.ContainsKey(tupleKey))
+            {
+                return InternalCache.PrimaryKeyMapping[tupleKey];
+            }
 
             var propertyName = Conventions.GetPrimaryKeyName(type);
 
             if (String.IsNullOrEmpty(propertyName)) return null;
 
             var propInfo = type.GetProperty(propertyName);
+            propInfo = propInfo == null || propInfo.PropertyType != pkType ? null : propInfo;
 
-
-            return propInfo == null || propInfo.PropertyType != pkType ? null : propInfo;
+            InternalCache.PrimaryKeyMapping[tupleKey] = propInfo;
+            return propInfo;
         }
 
-//        private static PropertyInfo GetPropertyCaseInsensitive(IReflect type, string propertyName, Type propertyType)
-//        {
-//            // make the property reflection lookup case insensitive
-//            const BindingFlags bindingFlags = BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance;
-//
-//            return type.GetProperty(propertyName, bindingFlags, null, propertyType, new Type[0], new ParameterModifier[0]);
-//        }
-
         public abstract IEnumerator<T> GetEnumerator();
         IEnumerator IEnumerable.GetEnumerator()
         {

SharpRepository.Repository/SharpRepository.Repository.csproj

@@ -93,6 +93,7 @@
     <Compile Include="CompoundKeyRepositoryBase.Batch.cs" />
     <Compile Include="CompoundKeyRepositoryBase.BatchItem.cs" />
     <Compile Include="DisabledCache.cs" />
+    <Compile Include="Helpers\InternalCache.cs" />
     <Compile Include="IDisabledCache.cs" />
     <Compile Include="Linq\LinqHelpers.cs" />
     <Compile Include="Queries\IPagingOptions.cs" />