Make property cache key unique per generic type

Author: mythz

src/ServiceStack.Text/Reflection/StaticAccessors.cs

@@ -11,6 +11,7 @@
 //
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using ServiceStack.Text;
@@ -26,12 +27,16 @@ public static class StaticAccessors
 
         public static Func<object, object> GetFastGetter(this Type type, string propName)
         {
-            var key = $"{type.Namespace}.{type.Name}::{propName}";
+            var key = GetTypePropertyKey(type, propName);
             Func<object, object> fn;
             if (getterFnCache.TryGetValue(key, out fn))
                 return fn;
 
-            fn = GetValueGetter(type.GetPropertyInfo(propName));
+            var pi = type.GetPropertyInfo(propName);
+            if (pi == null)
+                return null;
+
+            fn = GetValueGetter(pi);
 
             Dictionary<string, Func<object, object>> snapshot, newCache;
             do
@@ -45,16 +50,42 @@ public static Func<object, object> GetFastGetter(this Type type, string propName
             return fn;
         }
 
+        private static string GetTypePropertyKey(Type type, string propName)
+        {
+            var key = StringBuilderThreadStatic.Allocate()
+                .Append($"{type.Namespace}.{type.Name}::{propName}");
+
+            if (type.IsGenericType())
+            {
+                key.Append("<");
+                var i = 0;
+                foreach (var arg in type.GetGenericArguments())
+                {
+                    if (i++ > 0)
+                        key.Append(",");
+
+                    key.Append($"{arg.Namespace}.{arg.Name}");
+                }
+                key.Append(">");
+            }
+
+            return StringBuilderThreadStatic.ReturnAndFree(key);
+        }
+
         private static Dictionary<string, Action<object, object>> setterFnCache = new Dictionary<string, Action<object, object>>();
 
         public static Action<object, object> GetFastSetter(this Type type, string propName)
         {
-            var key = $"{type.Namespace}.{type.Name}::{propName}";
+            var key = GetTypePropertyKey(type, propName);
             Action<object, object> fn;
             if (setterFnCache.TryGetValue(key, out fn))
                 return fn;
 
-            fn = GetValueSetter(type.GetPropertyInfo(propName));
+            var pi = type.GetPropertyInfo(propName);
+            if (pi == null)
+                return null;
+
+            fn = GetValueSetter(pi);
 
             Dictionary<string, Action<object, object>> snapshot, newCache;
             do
@@ -86,7 +117,7 @@ public static Func<object, object> GetValueGetter(this PropertyInfo propertyInfo
 #else
 
             var instance = Expression.Parameter(typeof(object), "i");
-            var convertInstance = Expression.TypeAs(instance, propertyInfo.DeclaringType);
+            var convertInstance = Expression.TypeAs(instance, type);
             var property = Expression.Property(convertInstance, propertyInfo);
             var convertProperty = Expression.TypeAs(property, typeof(object));
             return Expression.Lambda<Func<object, object>>(convertProperty, instance).Compile();
@@ -129,17 +160,17 @@ public static Func<T, object> GetValueGetter<T>(this FieldInfo fieldInfo)
         }
 
 #if !XBOX
-        public static Action<object, object> GetValueSetter(this PropertyInfo propertyInfo, Type instanceType)
+        public static Action<object, object> GetValueSetter(this PropertyInfo propertyInfo)
         {
-            return GetValueSetter(propertyInfo);
+            return GetValueSetter(propertyInfo, propertyInfo.DeclaringType);
         }
 
-        public static Action<object, object> GetValueSetter(this PropertyInfo propertyInfo)
+        public static Action<object, object> GetValueSetter(this PropertyInfo propertyInfo, Type instanceType)
         {
             var instance = Expression.Parameter(typeof(object), "i");
             var argument = Expression.Parameter(typeof(object), "a");
 
-            var type = (Expression)Expression.TypeAs(instance, propertyInfo.DeclaringType);
+            var type = (Expression)Expression.TypeAs(instance, instanceType);
 
             var setterCall = Expression.Call(
                 type,