Fixed GeneratedTypes caching (#84)

Author: StefH

src-console/ConsoleApp1/Program.cs

@@ -14,7 +14,7 @@ public class Program
     {
         public static void Main(string[] args)
         {
-            var emps = new Employee[] { new Employee { Name = "a" }, new Employee { Name = "b" } }.AsQueryable();
+            var emps = new[] { new Employee { Name = "a" }, new Employee { Name = "b" } }.AsQueryable();
 
             // normal
             Expression<Func<Employee, string>> exp = u => u.Name;

src-console/System.Linq.Dynamic.Core.ConsoleTestApp/Program.cs

@@ -38,6 +38,13 @@ public static void Main(string[] args)
 
             DynamicProperty[] props = { new DynamicProperty("Name", typeof(string)), new DynamicProperty("Birthday", typeof(DateTime)) };
             Type type = DynamicClassFactory.CreateType(props);
+
+            DynamicProperty[] props2 = { new DynamicProperty("Name", typeof(string)), new DynamicProperty("Birthday", typeof(DateTime)) };
+            Type type2 = DynamicClassFactory.CreateType(props2);
+
+            DynamicProperty[] props3 = { new DynamicProperty("Name", typeof(int)), new DynamicProperty("Birthday", typeof(DateTime)) };
+            Type type3 = DynamicClassFactory.CreateType(props3);
+            
             DynamicClass dynamicClass = Activator.CreateInstance(type) as DynamicClass;
             dynamicClass.SetDynamicPropertyValue("Name", "Albert");
             dynamicClass.SetDynamicPropertyValue("Birthday", new DateTime(1879, 3, 14));

src/System.Linq.Dynamic.Core/DynamicClassFactory.cs

@@ -21,7 +21,7 @@ namespace System.Linq.Dynamic.Core
     public static class DynamicClassFactory
     {
         // EmptyTypes is used to indicate that we are looking for someting without any parameters. 
-        private readonly static Type[] EmptyTypes = new Type[0];
+        private static readonly Type[] EmptyTypes = new Type[0];
 
         private static readonly ConcurrentDictionary<string, Type> GeneratedTypes = new ConcurrentDictionary<string, Type>();
 
@@ -98,24 +98,20 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
         {
             Check.HasNoNulls(properties, nameof(properties));
 
-            var types = properties.Select(p => p.Type).ToArray();
-            var names = properties.Select(p => p.Name).ToArray();
+            Type[] types = properties.Select(p => p.Type).ToArray();
+            string[] names = properties.Select(p => p.Name).ToArray();
 
-            // Anonymous classes are generics based. The generic classes are distinguished by number of parameters and name of parameters.
-            // The specific types of the parameters are the generic arguments.
-            // We recreate this by creating a fullName composed of all the property names, separated by a "|".
-            string fullName = string.Join("|", names.Select(Escape).ToArray());
+            string key = GenerateKey(properties, createParameterCtor);
 
             Type type;
-
-            if (!GeneratedTypes.TryGetValue(fullName, out type))
+            if (!GeneratedTypes.TryGetValue(key, out type))
             {
                 // We create only a single class at a time, through this lock
                 // Note that this is a variant of the double-checked locking.
                 // It is safe because we are using a thread safe class.
                 lock (GeneratedTypes)
                 {
-                    if (!GeneratedTypes.TryGetValue(fullName, out type))
+                    if (!GeneratedTypes.TryGetValue(key, out type))
                     {
                         int index = Interlocked.Increment(ref _index);
 
@@ -350,7 +346,7 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
 
                         type = tb.CreateType();
 
-                        type = GeneratedTypes.GetOrAdd(fullName + "|_" + (createParameterCtor ? "1" : "0"), type);
+                        type = GeneratedTypes.GetOrAdd(key, type);
                     }
                 }
             }
@@ -363,6 +359,20 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
             return type;
         }
 
+        /// <summary>
+        /// Generates the key.
+        /// Anonymous classes are generics based. The generic classes are distinguished by number of parameters and name of parameters. The specific types of the parameters are the generic arguments.
+        /// </summary>
+        /// <param name="dynamicProperties">The dynamic propertys.</param>
+        /// <param name="createParameterCtor">if set to <c>true</c> [create parameter ctor].</param>
+        /// <returns></returns>
+        private static string GenerateKey(IEnumerable<DynamicProperty> dynamicProperties, bool createParameterCtor)
+        {
+            // We recreate this by creating a fullName composed of all the property names and types, separated by a "|".
+            // And append and extra field depending on createParameterCtor.
+            return string.Format("{0}_{1}", string.Join("|", dynamicProperties.Select(p => Escape(p.Name) + "~" + p.Type.FullName).ToArray()), createParameterCtor ? "c" : string.Empty);
+        }
+
         private static string Escape(string str)
         {
             // We escape the \ with \\, so that we can safely escape the "|" (that we use as a separator) with "\|"

src/System.Linq.Dynamic.Core/GeneratedTypesCache.cs

@@ -0,0 +1,39 @@
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace System.Linq.Dynamic.Core
+{
+    internal class GeneratedTypesCache
+    {
+        private static int _index = -1;
+
+        private static readonly ConcurrentDictionary<string, Type> GeneratedTypes = new ConcurrentDictionary<string, Type>();
+
+        internal bool TryGet(string[] propertyNames, out Type type)
+        {
+            type = null;
+            // Anonymous classes are generics based. The generic classes are distinguished by number of parameters and name of parameters.
+            // The specific types of the parameters are the generic arguments.
+            // We recreate this by creating a fullName composed of all the property names, separated by a "|".
+            string fullName = string.Join("|", propertyNames.Select(Escape).ToArray());
+
+            lock (GeneratedTypes)
+            {
+                if (!GeneratedTypes.TryGetValue(fullName, out type))
+                {
+                    int index = Interlocked.Increment(ref _index);
+                }
+            }
+
+            return true;
+        }
+
+        private static string Escape(string str)
+        {
+            // We escape the \ with \\, so that we can safely escape the "|" (that we use as a separator) with "\|"
+            str = str.Replace(@"\", @"\\");
+            str = str.Replace(@"|", @"\|");
+            return str;
+        }
+    }
+}