Add TypeFields for maintaining cached setters for populating a Types fields

Author: mythz

src/ServiceStack.Text/TypeFields.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using ServiceStack.Reflection;
+using ServiceStack.Text;
+using ServiceStack.Text.Common;
+
+namespace ServiceStack
+{
+    public class TypeFields<T> : TypeFields
+    {
+        public static readonly TypeFields<T> Instance = new TypeFields<T>();
+
+        public readonly Dictionary<string, SetPropertyDelegateRefGeneric<T>> GenericPublicSetters =
+            new Dictionary<string, SetPropertyDelegateRefGeneric<T>>(PclExport.Instance.InvariantComparerIgnoreCase);
+
+        static TypeFields()
+        {
+            Instance.Type = typeof(T);
+            Instance.PublicFieldInfos = typeof(T).GetPublicFields();
+            foreach (var fi in Instance.PublicFieldInfos)
+            {
+                try
+                {
+                    Instance.PublicGetters[fi.Name] = PclExport.Instance.GetFieldGetterFn(fi);
+                    Instance.PublicSetters[fi.Name] = fi.GetValueSetter(typeof(T));
+                    Instance.GenericPublicSetters[fi.Name] = fi.GetValueSetterGenericRef<T>();
+                    Instance.PublicFields[fi.Name] = fi;
+                }
+                catch (Exception ex)
+                {
+                    Tracer.Instance.WriteError(ex);
+                }
+            }
+        }
+
+        public override SetPropertyDelegateRef GetPublicSetterRef(string name)
+        {
+            if (name == null)
+                return null;
+
+            return GenericPublicSetters.TryGetValue(name, out SetPropertyDelegateRefGeneric<T> fn)
+                ? delegate (ref object instance, object arg)
+                  {
+                    var valueInstance = (T)instance;
+                    fn(ref valueInstance, arg);
+                    instance = valueInstance;
+                  }
+            : (SetPropertyDelegateRef)null;
+        }
+    }
+
+    public abstract class TypeFields
+    {
+        static Dictionary<Type, TypeFields> CacheMap = new Dictionary<Type, TypeFields>();
+
+        public static TypeFields Get(Type type)
+        {
+            if (CacheMap.TryGetValue(type, out TypeFields value))
+                return value;
+
+            var genericType = typeof(TypeFields<>).MakeGenericType(type);
+            var instanceFi = genericType.GetPublicStaticField("Instance");
+            var instance = (TypeFields)instanceFi.GetValue(null);
+
+            Dictionary<Type, TypeFields> snapshot, newCache;
+            do
+            {
+                snapshot = CacheMap;
+                newCache = new Dictionary<Type, TypeFields>(CacheMap) {
+                    [type] = instance
+                };
+            } while (!ReferenceEquals(
+                Interlocked.CompareExchange(ref CacheMap, newCache, snapshot), snapshot));
+
+            return instance;
+        }
+
+        public Type Type;
+
+        public readonly Dictionary<string, PropertyGetterDelegate> PublicGetters =
+            new Dictionary<string, PropertyGetterDelegate>(PclExport.Instance.InvariantComparerIgnoreCase);
+
+        public readonly Dictionary<string, Action<object, object>> PublicSetters =
+            new Dictionary<string, Action<object, object>>(PclExport.Instance.InvariantComparerIgnoreCase);
+
+        public readonly Dictionary<string, FieldInfo> PublicFields =
+            new Dictionary<string, FieldInfo>(PclExport.Instance.InvariantComparerIgnoreCase);
+
+        public FieldInfo[] PublicFieldInfos { get; protected set; }
+
+        public virtual FieldInfo GetPublicField(string name)
+        {
+            foreach (var fi in PublicFieldInfos)
+            {
+                if (fi.Name == name)
+                    return fi;
+            }
+            return null;
+        }
+
+        public virtual PropertyGetterDelegate GetPublicGetter(FieldInfo fi)
+        {
+            if (fi == null)
+                return null;
+
+            return PublicGetters.TryGetValue(fi.Name, out PropertyGetterDelegate fn)
+                ? fn
+                : PclExport.Instance.GetFieldGetterFn(fi);
+        }
+
+        public virtual PropertyGetterDelegate GetPublicGetter(string name)
+        {
+            if (name == null)
+                return null;
+
+            return PublicGetters.TryGetValue(name, out PropertyGetterDelegate fn)
+                ? fn
+                : null;
+        }
+
+        public virtual Action<object, object> GetPublicSetter(FieldInfo fi)
+        {
+            if (fi == null)
+                return null;
+
+            return PublicSetters.TryGetValue(fi.Name, out Action<object, object> fn)
+                ? fn
+                : fi.GetValueSetter(Type);
+        }
+
+        public virtual Action<object, object> GetPublicSetter(string name)
+        {
+            if (name == null)
+                return null;
+
+            return PublicSetters.TryGetValue(name, out Action<object, object> fn)
+                ? fn
+                : null;
+        }
+
+        public virtual SetPropertyDelegateRef GetPublicSetterRef(string name)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

tests/ServiceStack.Text.Tests/ServiceStack.Text.Tests.csproj

@@ -26,6 +26,7 @@
 
   <ItemGroup>
     <PackageReference Include="NUnit" Version="3.6.1" />
+    <PackageReference Include="System.ValueTuple" Version="4.3.1" />
   </ItemGroup>
 
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net45' ">

tests/ServiceStack.Text.Tests/TypeFieldReflectorTests.cs

@@ -0,0 +1,30 @@
+using NUnit.Framework;
+
+namespace ServiceStack.Text.Tests
+{
+    public class TypeFieldReflectorTests
+    {
+        (string s, int i, long l, double d) CreateValueTuple() =>
+            ("foo", 1, 2, 3.3);
+
+        [Test]
+        public void Can_cache_ValueTuple_field_accessors()
+        {
+            var typeAccessor = TypeFields.Get(typeof((string s, int i, long l, double d)));
+
+            var oTuple = (object)CreateValueTuple();
+
+            typeAccessor.GetPublicSetterRef("Item1")(ref oTuple, "bar");
+            typeAccessor.GetPublicSetterRef("Item2")(ref oTuple, 10);
+            typeAccessor.GetPublicSetterRef("Item3")(ref oTuple, 20L);
+            typeAccessor.GetPublicSetterRef("Item4")(ref oTuple, 4.4d);
+
+            var tuple = ((string s, int i, long l, double d))oTuple;
+
+            Assert.That(tuple.s, Is.EqualTo("bar"));
+            Assert.That(tuple.i, Is.EqualTo(10));
+            Assert.That(tuple.l, Is.EqualTo(20));
+            Assert.That(tuple.d, Is.EqualTo(4.4));
+        }
+    }
+}