use GetOrAdd in the cache dictionaries (#3)

MihailsKuzmins · web-flow · commit 870ec93094eb · 2021-10-16T18:53:03.000+03:00
* use GetOrAdd in Get

* use GetOrAdd in set

* use GetOrAdd in Get generic

* rename Cache

* lazy in MethodOf
diff --git a/src/ExpressionCache.cs b/src/ExpressionCache.cs
@@ -10,11 +10,11 @@ namespace MyNihongo.Expressions
 {
 	internal static class ExpressionCache
 	{
-		internal static readonly ConcurrentDictionary<Tuple<Type, string>, Delegate>
+		internal static readonly ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>
 			PropertyGetters = new(),
 			PropertySetters = new();
 
-		internal static readonly ConcurrentDictionary<Tuple<Type, string>, Delegate>
+		internal static readonly ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>
 			Invoke = new();
 	}
 }
diff --git a/src/MethodOf.cs b/src/MethodOf.cs
@@ -10,36 +10,6 @@ public static class MethodOf
 	{
 		public static T? Invoke<T>(object @this, string methodName, params object[] args)
 		{
-			var type = @this.GetType();
-			var key = new Tuple<Type, string>(type, methodName);
-
-			if (!ExpressionCache.Invoke.TryGetValue(key, out var lambda))
-			{
-				var param = Expression.Parameter(type);
-
-				if (args.Length == 0)
-				{
-					var call = Expression.Call(param, methodName, null);
-					lambda = Expression.Lambda(call, param).Compile();
-				}
-				else
-				{
-					var @params = new Expression[args.Length];
-
-					for (var i = 0; i < args.Length; i++)
-						@params[i] = Expression.Parameter(args[i].GetType());
-
-					var lambdaParams = new ParameterExpression[args.Length + 1];
-					lambdaParams[0] = param;
-					Array.Copy(@params, 0, lambdaParams, 1, @params.Length);
-
-					var call = Expression.Call(param, methodName, null, @params);
-					lambda = Expression.Lambda(call, lambdaParams).Compile();
-				}
-
-				ExpressionCache.Invoke.TryAdd(key, lambda);
-			}
-
 			object?[] invokeParams;
 
 			if (args.Length == 0)
@@ -53,7 +23,36 @@ public static class MethodOf
 				Array.Copy(args, 0, invokeParams, 1, args.Length);
 			}
 
-			return (T?)lambda.DynamicInvoke(invokeParams);
+			var key = new Tuple<Type, string>(@this.GetType(), methodName);
+			var @delegate = ExpressionCache.Invoke.GetOrAdd(key, x =>
+			{
+				return new Lazy<Delegate>(() =>
+				{
+					var param = Expression.Parameter(x.Item1);
+
+					if (args.Length == 0)
+					{
+						var call = Expression.Call(param, x.Item2, null);
+						return Expression.Lambda(call, param).Compile();
+					}
+					else
+					{
+						var @params = new Expression[args.Length];
+
+						for (var i = 0; i < args.Length; i++)
+							@params[i] = Expression.Parameter(args[i].GetType());
+
+						var lambdaParams = new ParameterExpression[args.Length + 1];
+						lambdaParams[0] = param;
+						Array.Copy(@params, 0, lambdaParams, 1, @params.Length);
+
+						var call = Expression.Call(param, x.Item2, null, @params);
+						return Expression.Lambda(call, lambdaParams).Compile();
+					}
+				});
+			}).Value;
+
+			return (T?)@delegate.DynamicInvoke(invokeParams);
 		}
 	}
 }
diff --git a/src/PropertyOf.cs b/src/PropertyOf.cs
@@ -17,36 +17,36 @@ public static class PropertyOf
 
 		public static T? Get<T>(object source, string propertyName)
 		{
-			var type = source.GetType();
-			var key = new Tuple<Type, string>(type, propertyName);
-
-			if (!ExpressionCache.PropertyGetters.TryGetValue(key, out var @delegate))
+			var key = new Tuple<Type, string>(source.GetType(), propertyName);
+			var @delegate = ExpressionCache.PropertyGetters.GetOrAdd(key, static x =>
 			{
-				var param = Expression.Parameter(type);
-				var prop = Expression.Property(param, propertyName);
+				return new Lazy<Delegate>(() =>
+				{
+					var param = Expression.Parameter(x.Item1);
+					var prop = Expression.Property(param, x.Item2);
 
-				@delegate = Expression.Lambda(prop, param).Compile();
-				ExpressionCache.PropertyGetters.TryAdd(key, @delegate);
-			}
+					return Expression.Lambda(prop, param).Compile();
+				});
+			}).Value;
 
 			return (T?)@delegate.DynamicInvoke(source);
 		}
 
 		public static void Set<T>(object source, string propertyName, T value)
 		{
-			var type = source.GetType();
-			var key = new Tuple<Type, string>(type, propertyName);
-
-			if (!ExpressionCache.PropertySetters.TryGetValue(key, out var @delegate))
+			var key = new Tuple<Type, string>(source.GetType(), propertyName);
+			var @delegate = ExpressionCache.PropertySetters.GetOrAdd(key, static x =>
 			{
-				var param = Expression.Parameter(type);
-				var prop = Expression.Property(param, propertyName);
-				var valueParam = Expression.Parameter(typeof(T));
-				var assign = Expression.Assign(prop, valueParam);
+				return new Lazy<Delegate>(() =>
+				{
+					var param = Expression.Parameter(x.Item1);
+					var prop = Expression.Property(param, x.Item2);
+					var valueParam = Expression.Parameter(typeof(T));
+					var assign = Expression.Assign(prop, valueParam);
 
-				@delegate = Expression.Lambda(assign, param, valueParam).Compile();
-				ExpressionCache.PropertySetters.TryAdd(key, @delegate);
-			}
+					return Expression.Lambda(assign, param, valueParam).Compile();
+				});
+			}).Value;
 
 			@delegate.DynamicInvoke(source, value);
 		}
@@ -65,16 +65,17 @@ private static class Cache<TDestination>
 			public static Func<T, TDestination> Get(string propertyName)
 			{
 				var key = new Tuple<Type, string>(typeof(T), propertyName);
-				if (ExpressionCache.PropertyGetters.TryGetValue(key, out var @delegate))
-					return (Func<T, TDestination>)@delegate;
-
-				var param = Expression.Parameter(typeof(T));
-				var prop = Expression.Property(param, propertyName);
 
-				var lambda = Expression.Lambda<Func<T, TDestination>>(prop, param).Compile();
-				ExpressionCache.PropertyGetters.TryAdd(key, lambda);
+				return (Func<T, TDestination>)ExpressionCache.PropertyGetters.GetOrAdd(key, static x =>
+				{
+					return new Lazy<Delegate>(() =>
+					{
+						var param = Expression.Parameter(x.Item1);
+						var prop = Expression.Property(param, x.Item2);
 
-				return lambda;
+						return Expression.Lambda<Func<T, TDestination>>(prop, param).Compile();
+					});
+				}).Value;
 			}
 		}
 	}
diff --git a/tests/MyNihongo.Expressions.Tests/MethodOfTests/InvokeShould.cs b/tests/MyNihongo.Expressions.Tests/MethodOfTests/InvokeShould.cs
@@ -34,7 +34,7 @@ public void SaveExpressionInCache()
 			const string method = nameof(InvokeCacheTest.GetResult);
 			var key = new Tuple<Type, string>(typeof(InvokeCacheTest), method);
 
-			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Delegate>)typeof(ExpressionCache)
+			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>)typeof(ExpressionCache)
 				.GetField(nameof(ExpressionCache.Invoke), BindingFlags.Static | BindingFlags.NonPublic)
 				!.GetValue(null);
 
diff --git a/tests/MyNihongo.Expressions.Tests/PropertyOfTests/GetShould.cs b/tests/MyNihongo.Expressions.Tests/PropertyOfTests/GetShould.cs
@@ -45,7 +45,7 @@ public void SaveExpressionsInCacheFromNonGeneric()
 			const string prop = nameof(item.Prop);
 			var key = new Tuple<Type, string>(item.GetType(), prop);
 
-			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Delegate>)typeof(ExpressionCache)
+			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>)typeof(ExpressionCache)
 				.GetField(nameof(ExpressionCache.PropertyGetters), BindingFlags.Static | BindingFlags.NonPublic)
 				!.GetValue(null);
 
@@ -71,7 +71,7 @@ public void SaveExpressionsInCacheFromGeneric()
 			const string prop = nameof(item.Prop);
 			var key = new Tuple<Type, string>(item.GetType(), prop);
 
-			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Delegate>)typeof(ExpressionCache)
+			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>)typeof(ExpressionCache)
 				.GetField(nameof(ExpressionCache.PropertyGetters), BindingFlags.Static | BindingFlags.NonPublic)
 				!.GetValue(null);
 
diff --git a/tests/MyNihongo.Expressions.Tests/PropertyOfTests/SetShould.cs b/tests/MyNihongo.Expressions.Tests/PropertyOfTests/SetShould.cs
@@ -36,7 +36,7 @@ public void SaveExpressionsInCache()
 			const string prop = nameof(item.Prop);
 			var key = new Tuple<Type, string>(item.GetType(), prop);
 
-			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Delegate>)typeof(ExpressionCache)
+			var dictionary = (ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>)typeof(ExpressionCache)
 				.GetField(nameof(ExpressionCache.PropertySetters), BindingFlags.Static | BindingFlags.NonPublic)
 				!.GetValue(null);
 
@@ -62,17 +62,5 @@ public void ThrowExceptionIfPropertyNotFound()
 				.Should()
 				.ThrowExactly<ArgumentException>();
 		}
-
-		[Fact]
-		public void ThrowExceptionIfInvalidType()
-		{
-			var input = new TestRecord();
-
-			Action action = () => PropertyOf.Set(input, nameof(TestRecord.Text), 123);
-
-			action
-				.Should()
-				.ThrowExactly<ArgumentException>();
-		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,11 @@ namespace MyNihongo.Expressions`
`10`	`10`	`{`
`11`	`11`	`internal static class ExpressionCache`
`12`	`12`	`{`
`13`		`- internal static readonly ConcurrentDictionary<Tuple<Type, string>, Delegate>`
	`13`	`+ internal static readonly ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>`
`14`	`14`	`PropertyGetters = new(),`
`15`	`15`	`PropertySetters = new();`
`16`	`16`
`17`		`- internal static readonly ConcurrentDictionary<Tuple<Type, string>, Delegate>`
	`17`	`+ internal static readonly ConcurrentDictionary<Tuple<Type, string>, Lazy<Delegate>>`
`18`	`18`	`Invoke = new();`
`19`	`19`	`}`
`20`	`20`	`}`