Replaced SynchronizedDictionary with ConcurrentDictionary

snakefoot · snakefoot · commit 3be20d6b686d · 2026-05-20T23:12:12.000+02:00
diff --git a/src/Castle.Core/Components.DictionaryAdapter/DictionaryAdapterFactory.cs b/src/Castle.Core/Components.DictionaryAdapter/DictionaryAdapterFactory.cs
@@ -16,6 +16,7 @@ namespace Castle.Components.DictionaryAdapter
 {
 	using System;
 	using System.Collections;
+	using System.Collections.Concurrent;
 	using System.Collections.Generic;
 	using System.Collections.Specialized;
 	using System.ComponentModel;
@@ -34,8 +35,8 @@ namespace Castle.Components.DictionaryAdapter
 	/// </summary>
 	public class DictionaryAdapterFactory : IDictionaryAdapterFactory
 	{
-		private readonly SynchronizedDictionary<Type, DictionaryAdapterMeta> interfaceToMeta =
-			new SynchronizedDictionary<Type, DictionaryAdapterMeta>();
+		private readonly ConcurrentDictionary<Type, DictionaryAdapterMeta> interfaceToMeta =
+			new ConcurrentDictionary<Type, DictionaryAdapterMeta>();
 
 		#region IDictionaryAdapterFactory
 
diff --git a/src/Castle.Core/Core/Internal/SynchronizedDictionary.cs b/src/Castle.Core/Core/Internal/SynchronizedDictionary.cs
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs
@@ -176,7 +176,7 @@ private Type GetDelegateType(MetaMethod method, ClassEmitter @class)
 				GetCacheKeyTypes(method),
 				null);
 
-			return scope.TypeCache.GetOrAddWithoutTakingLock(key, _ =>
+			return scope.GetOrAddFromCache(key, _ =>
 				new DelegateTypeGenerator(method, targetType)
 				.Generate(@class, namingScope)
 				.BuildType());
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs
@@ -121,7 +121,7 @@ private Type GetDelegateType(MetaMethod method, ClassEmitter @class)
 				GetCacheKeyTypes(method),
 				null);
 
-			return scope.TypeCache.GetOrAddWithoutTakingLock(key, _ =>
+			return scope.GetOrAddFromCache(key, _ =>
 				new DelegateTypeGenerator(method, targetType)
 				.Generate(@class, namingScope)
 				.BuildType());
@@ -136,7 +136,7 @@ private Type GetInvocationType(MetaMethod method, ClassEmitter @class)
 
 			// no locking required as we're already within a lock
 
-			return scope.TypeCache.GetOrAddWithoutTakingLock(key, _ => BuildInvocationType(method, @class));
+			return scope.GetOrAddFromCache(key, _ => BuildInvocationType(method, @class));
 		}
 
 		private MethodGenerator IndirectlyCalledMethodGenerator(MetaMethod method, ClassEmitter proxy,
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyTargetContributor.cs
@@ -88,7 +88,7 @@ private Type GetInvocationType(MetaMethod method, ClassEmitter @class)
 
 			// no locking required as we're already within a lock
 
-			return scope.TypeCache.GetOrAddWithoutTakingLock(key, _ =>
+			return scope.GetOrAddFromCache(key, _ =>
 				new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
 				                                       method,
 				                                       method.Method,
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs
@@ -95,7 +95,7 @@ private Type GetInvocationType(MetaMethod method, ClassEmitter emitter)
 
 			// no locking required as we're already within a lock
 
-			return scope.TypeCache.GetOrAddWithoutTakingLock(key, _ =>
+			return scope.GetOrAddFromCache(key, _ =>
 				new CompositionInvocationTypeGenerator(methodInfo.DeclaringType,
 				                                       method,
 				                                       methodInfo,
diff --git a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs
@@ -140,7 +140,7 @@ private Type GetInvocationType(MetaMethod method, ClassEmitter emitter)
 
 			// no locking required as we're already within a lock
 
-			return scope.TypeCache.GetOrAddWithoutTakingLock(key, _ =>
+			return scope.GetOrAddFromCache(key, _ =>
 				new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
 				                                       method,
 				                                       method.Method,
diff --git a/src/Castle.Core/DynamicProxy/DefaultProxyBuilder.cs b/src/Castle.Core/DynamicProxy/DefaultProxyBuilder.cs
@@ -152,7 +152,7 @@ private void AssertValidTypeForTarget(Type type, Type target, string paramName)
 			}
 		}
 
-		private void AssertValidTypes(IEnumerable<Type>? targetTypes, string paramName)
+		private void AssertValidTypes(Type[]? targetTypes, string paramName)
 		{
 			if (targetTypes != null)
 			{
diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs
@@ -271,6 +271,11 @@ private void EnsureValidBaseType(Type type)
 					"Base type for proxy is null reference. Please set it to System.Object or some other valid type.");
 			}
 
+			if (typeof(object).Equals(type))
+			{
+				return; // Skip GetConstructor reflection for System.Object
+			}
+
 			if (!type.IsClass)
 			{
 				ThrowInvalidBaseType(type, "it is not a class type");
diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs
@@ -40,7 +40,7 @@ internal abstract class BaseProxyGenerator
 		protected readonly Type[] interfaces;
 		private readonly ModuleScope scope;
 		private ILogger logger = NullLogger.Instance;
-		private ProxyGenerationOptions proxyGenerationOptions;
+		private readonly ProxyGenerationOptions proxyGenerationOptions;
 
 		protected BaseProxyGenerator(ModuleScope scope, Type targetType, Type[] interfaces, ProxyGenerationOptions proxyGenerationOptions)
 		{
@@ -74,9 +74,11 @@ public Type GetProxyType()
 		{
 			bool notFoundInTypeCache = false;
 
-			var proxyType = Scope.TypeCache.GetOrAdd(GetCacheKey(), cacheKey =>
+			var cacheKey = GetCacheKey();
+			var proxyType = Scope.GetOrAddFromCache(cacheKey, key =>
 			{
 				notFoundInTypeCache = true;
+
 				Logger.DebugFormat("No cached proxy type was found for target type {0}.", targetType.FullName);
 
 				EnsureOptionsOverrideEqualsAndGetHashCode();
diff --git a/src/Castle.Core/DynamicProxy/Generators/CacheKey.cs b/src/Castle.Core/DynamicProxy/Generators/CacheKey.cs
@@ -20,7 +20,7 @@ namespace Castle.DynamicProxy.Generators
 #if FEATURE_SERIALIZATION
 	[Serializable]
 #endif
-	internal class CacheKey
+	internal struct CacheKey : IEquatable<CacheKey>
 	{
 		private readonly MemberInfo target;
 		private readonly Type[] interfaces;
@@ -73,37 +73,31 @@ public override int GetHashCode()
 
 		public override bool Equals(object obj)
 		{
-			if (this == obj)
-			{
-				return true;
-			}
-
-			var cacheKey = obj as CacheKey;
-			if (cacheKey == null)
-			{
-				return false;
-			}
+			return obj is CacheKey other && Equals(other);
+		}
 
-			if (!Equals(type, cacheKey.type))
+		public bool Equals(CacheKey other)
+		{
+			if (!Equals(type, other.type))
 			{
 				return false;
 			}
-			if (!Equals(target, cacheKey.target))
+			if (!Equals(target, other.target))
 			{
 				return false;
 			}
-			if (interfaces.Length != cacheKey.interfaces.Length)
+			if (interfaces.Length != other.interfaces.Length)
 			{
 				return false;
 			}
 			for (var i = 0; i < interfaces.Length; i++)
 			{
-				if (!Equals(interfaces[i], cacheKey.interfaces[i]))
+				if (!Equals(interfaces[i], other.interfaces[i]))
 				{
 					return false;
 				}
 			}
-			if (!Equals(options, cacheKey.options))
+			if (!Equals(options, other.options))
 			{
 				return false;
 			}
diff --git a/src/Castle.Core/DynamicProxy/Internal/InvocationHelper.cs b/src/Castle.Core/DynamicProxy/Internal/InvocationHelper.cs
@@ -15,18 +15,16 @@
 namespace Castle.DynamicProxy.Internal
 {
 	using System;
-	using System.Collections.Generic;
+	using System.Collections.Concurrent;
 	using System.Diagnostics;
 	using System.Reflection;
-	using System.Threading;
 
-	using Castle.Core.Internal;
 	using Castle.DynamicProxy.Generators;
 
 	internal static class InvocationHelper
 	{
-		private static readonly SynchronizedDictionary<CacheKey, MethodInfo> cache =
-			new SynchronizedDictionary<CacheKey, MethodInfo>();
+		private static readonly ConcurrentDictionary<CacheKey, MethodInfo> cache =
+			new ConcurrentDictionary<CacheKey, MethodInfo>();
 
 		public static MethodInfo GetMethodOnObject(object target, MethodInfo proxiedMethod)
 		{
diff --git a/src/Castle.Core/DynamicProxy/Internal/TypeUtil.cs b/src/Castle.Core/DynamicProxy/Internal/TypeUtil.cs
@@ -130,15 +130,14 @@ internal static MethodInfo[] GetAllInstanceMethods(this Type type)
 		/// </summary>
 		internal static Type[] GetAllInterfaces(params Type[]? types)
 		{
-			if (types == null)
+			if (types == null || types.Length == 0)
 			{
 				return Type.EmptyTypes;
 			}
 
 			var interfaces = new HashSet<Type>();
-			for (var index = 0; index < types.Length; index++)
+			foreach (var type in types)
 			{
-				var type = types[index];
 				if (type == null)
 				{
 					continue;
@@ -153,9 +152,8 @@ internal static Type[] GetAllInterfaces(params Type[]? types)
 				}
 
 				var innerInterfaces = type.GetInterfaces();
-				for (var i = 0; i < innerInterfaces.Length; i++)
+				foreach (var @interface in innerInterfaces)
 				{
-					var @interface = innerInterfaces[i];
 					interfaces.Add(@interface);
 				}
 			}
@@ -168,7 +166,6 @@ public static Type[] GetAllInterfaces(this Type type)  // NOTE: also used by Win
 			return GetAllInterfaces(new[] { type });
 		}
 
-
 		public static Type? GetTypeOrNull(object? target)
 		{
 			if (target == null)
@@ -307,6 +304,9 @@ internal static bool IsDelegateType(this Type type)
 
 		private static Type[] Sort(ICollection<Type> types)
 		{
+			if (types.Count == 0)
+				return Type.EmptyTypes;
+
 			var array = new Type[types.Count];
 			types.CopyTo(array, 0);
 			//NOTE: is there a better, stable way to sort Types. We will need to revise this once we allow open generics
diff --git a/src/Castle.Core/DynamicProxy/ModuleScope.cs b/src/Castle.Core/DynamicProxy/ModuleScope.cs
diff --git a/src/Castle.Core/DynamicProxy/ProxyUtil.cs b/src/Castle.Core/DynamicProxy/ProxyUtil.cs

Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ private void AssertValidTypeForTarget(Type type, Type target, string paramName)`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`		`- private void AssertValidTypes(IEnumerable<Type>? targetTypes, string paramName)`
	`155`	`+ private void AssertValidTypes(Type[]? targetTypes, string paramName)`
`156`	`156`	`{`
`157`	`157`	`if (targetTypes != null)`
`158`	`158`	`{`
Original file line number	Diff line number	Diff line change
`@@ -271,6 +271,11 @@ private void EnsureValidBaseType(Type type)`
`271`	`271`	`"Base type for proxy is null reference. Please set it to System.Object or some other valid type.");`
`272`	`272`	`}`
`273`	`273`
	`274`	`+ if (typeof(object).Equals(type))`
	`275`	`+ {`
	`276`	`+ return; // Skip GetConstructor reflection for System.Object`
	`277`	`+ }`
	`278`	`+`
`274`	`279`	`if (!type.IsClass)`
`275`	`280`	`{`
`276`	`281`	`ThrowInvalidBaseType(type, "it is not a class type");`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ internal abstract class BaseProxyGenerator`
`40`	`40`	`protected readonly Type[] interfaces;`
`41`	`41`	`private readonly ModuleScope scope;`
`42`	`42`	`private ILogger logger = NullLogger.Instance;`
`43`		`- private ProxyGenerationOptions proxyGenerationOptions;`
	`43`	`+ private readonly ProxyGenerationOptions proxyGenerationOptions;`
`44`	`44`
`45`	`45`	`protected BaseProxyGenerator(ModuleScope scope, Type targetType, Type[] interfaces, ProxyGenerationOptions proxyGenerationOptions)`
`46`	`46`	`{`
`@@ -74,9 +74,11 @@ public Type GetProxyType()`
`74`	`74`	`{`
`75`	`75`	`bool notFoundInTypeCache = false;`
`76`	`76`
`77`		`- var proxyType = Scope.TypeCache.GetOrAdd(GetCacheKey(), cacheKey =>`
	`77`	`+ var cacheKey = GetCacheKey();`
	`78`	`+ var proxyType = Scope.GetOrAddFromCache(cacheKey, key =>`
`78`	`79`	`{`
`79`	`80`	`notFoundInTypeCache = true;`
	`81`	`+`
`80`	`82`	`Logger.DebugFormat("No cached proxy type was found for target type {0}.", targetType.FullName);`
`81`	`83`
`82`	`84`	`EnsureOptionsOverrideEqualsAndGetHashCode();`