Replaced SynchronizedDictionary with ConcurrentDictionary

snakefoot · snakefoot · commit 328d81047442 · 2026-05-20T21:04:19.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/Generators/BaseProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs
@@ -74,20 +74,26 @@ public Type GetProxyType()
 		{
 			bool notFoundInTypeCache = false;
 
-			var proxyType = Scope.TypeCache.GetOrAdd(GetCacheKey(), cacheKey =>
+			var cacheKey = GetCacheKey();
+			if (!Scope.TryGetTypeFromCache(cacheKey, out var proxyType))
 			{
-				notFoundInTypeCache = true;
-				Logger.DebugFormat("No cached proxy type was found for target type {0}.", targetType.FullName);
+				proxyType = Scope.GetOrAddFromCache(cacheKey, key =>
+				{
+					notFoundInTypeCache = true;
+
+					Logger.DebugFormat("No cached proxy type was found for target type {0}.", targetType.FullName);
 
-				EnsureOptionsOverrideEqualsAndGetHashCode();
+					EnsureOptionsOverrideEqualsAndGetHashCode();
 
-				var name = Scope.NamingScope.GetUniqueName("Castle.Proxies." + targetType.Name + "Proxy");
-				return GenerateType(name, Scope.NamingScope.SafeSubScope());
-			});
+					var name = Scope.NamingScope.GetUniqueName("Castle.Proxies." + targetType.Name + "Proxy");
+					return GenerateType(name, Scope.NamingScope.SafeSubScope());
+				});
+			}
 
 			if (!notFoundInTypeCache)
 			{
-				Logger.DebugFormat("Found cached proxy type {0} for target type {1}.", proxyType.FullName, targetType.FullName);
+				if (Logger.IsDebugEnabled)
+					Logger.DebugFormat("Found cached proxy type {0} for target type {1}.", proxyType.FullName, targetType.FullName);
 			}
 
 			return proxyType;
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/ModuleScope.cs b/src/Castle.Core/DynamicProxy/ModuleScope.cs
@@ -18,13 +18,12 @@ namespace Castle.DynamicProxy
 {
 	using System;
 	using System.Collections.Generic;
-	using System.Diagnostics;
+	using System.Collections.Concurrent;
 	using System.Diagnostics.CodeAnalysis;
 	using System.IO;
 	using System.Reflection;
 	using System.Reflection.Emit;
 	using System.Resources;
-	using System.Threading;
 
 	using Castle.Core.Internal;
 	using Castle.DynamicProxy.Generators;
@@ -54,7 +53,7 @@ public class ModuleScope
 		private readonly string weakModulePath;
 
 		// Keeps track of generated types
-		private readonly SynchronizedDictionary<CacheKey, Type> typeCache = new SynchronizedDictionary<CacheKey, Type>();
+		private readonly ConcurrentDictionary<CacheKey, Type> typeCache = new ConcurrentDictionary<CacheKey, Type>();
 
 		// Used to lock the module builder creation
 		private readonly object moduleLocker = new object();
@@ -148,7 +147,26 @@ internal INamingScope NamingScope
 			get { return namingScope; }
 		}
 
-		internal SynchronizedDictionary<CacheKey, Type> TypeCache => typeCache;
+
+		internal bool TryGetTypeFromCache(CacheKey key, out Type? type) => typeCache.TryGetValue(key, out type);
+
+		internal Type GetOrAddFromCache(CacheKey key, Func<CacheKey, Type> factory)
+		{
+			if (typeCache.TryGetValue(key, out var type))
+				return type;
+
+			lock (typeCache)
+			{
+				if (typeCache.TryGetValue(key, out type))
+					return type;
+
+				type = factory(key);
+				if (typeCache.TryAdd(key, type))
+					return type;
+
+				return typeCache[key];
+			}
+		}
 
 		/// <summary>
 		///   Gets the key pair used to sign the strong-named assembly generated by this <see cref = "ModuleScope" />.
@@ -504,15 +522,13 @@ private void AddCacheMappings(AssemblyBuilder builder)
 		{
 			var mappings = new Dictionary<CacheKey, string>();
 
-			typeCache.ForEach((key, value) =>
+			foreach (var type in typeCache)
 			{
-				// NOTE: using == returns invalid results.
-				// we need to use Equals here for it to work properly
-				if (builder.Equals(value.Assembly))
+				if (builder.Equals(type.Value.Assembly))
 				{
-					mappings.Add(key, value.FullName);
+					mappings.Add(type.Key, type.Value.FullName);
 				}
-			});
+			}
 
 			CacheMappingsAttribute.ApplyTo(builder, mappings);
 		}
@@ -551,7 +567,7 @@ public void LoadAssemblyIntoCache(Assembly assembly)
 
 				if (loadedType != null)
 				{
-					typeCache.AddOrUpdateWithoutTakingLock(mapping.Key, loadedType);
+					typeCache[mapping.Key] = loadedType;
 				}
 			}
 		}
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
`@@ -20,7 +20,7 @@ namespace Castle.DynamicProxy.Generators`
`20`	`20`	`#if FEATURE_SERIALIZATION`
`21`	`21`	`[Serializable]`
`22`	`22`	`#endif`
`23`		`- internal class CacheKey`
	`23`	`+ internal struct CacheKey : IEquatable<CacheKey>`
`24`	`24`	`{`
`25`	`25`	`private readonly MemberInfo target;`
`26`	`26`	`private readonly Type[] interfaces;`
`@@ -73,37 +73,31 @@ public override int GetHashCode()`
`73`	`73`
`74`	`74`	`public override bool Equals(object obj)`
`75`	`75`	`{`
`76`		`- if (this == obj)`
`77`		`- {`
`78`		`- return true;`
`79`		`- }`
`80`		`-`
`81`		`- var cacheKey = obj as CacheKey;`
`82`		`- if (cacheKey == null)`
`83`		`- {`
`84`		`- return false;`
`85`		`- }`
	`76`	`+ return obj is CacheKey other && Equals(other);`
	`77`	`+ }`
`86`	`78`
`87`		`- if (!Equals(type, cacheKey.type))`
	`79`	`+ public bool Equals(CacheKey other)`
	`80`	`+ {`
	`81`	`+ if (!Equals(type, other.type))`
`88`	`82`	`{`
`89`	`83`	`return false;`
`90`	`84`	`}`
`91`		`- if (!Equals(target, cacheKey.target))`
	`85`	`+ if (!Equals(target, other.target))`
`92`	`86`	`{`
`93`	`87`	`return false;`
`94`	`88`	`}`
`95`		`- if (interfaces.Length != cacheKey.interfaces.Length)`
	`89`	`+ if (interfaces.Length != other.interfaces.Length)`
`96`	`90`	`{`
`97`	`91`	`return false;`
`98`	`92`	`}`
`99`	`93`	`for (var i = 0; i < interfaces.Length; i++)`
`100`	`94`	`{`
`101`		`- if (!Equals(interfaces[i], cacheKey.interfaces[i]))`
	`95`	`+ if (!Equals(interfaces[i], other.interfaces[i]))`
`102`	`96`	`{`
`103`	`97`	`return false;`
`104`	`98`	`}`
`105`	`99`	`}`
`106`		`- if (!Equals(options, cacheKey.options))`
	`100`	`+ if (!Equals(options, other.options))`
`107`	`101`	`{`
`108`	`102`	`return false;`
`109`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,18 +15,16 @@`
`15`	`15`	`namespace Castle.DynamicProxy.Internal`
`16`	`16`	`{`
`17`	`17`	`using System;`
`18`		`- using System.Collections.Generic;`
	`18`	`+ using System.Collections.Concurrent;`
`19`	`19`	`using System.Diagnostics;`
`20`	`20`	`using System.Reflection;`
`21`		`- using System.Threading;`
`22`	`21`
`23`		`- using Castle.Core.Internal;`
`24`	`22`	`using Castle.DynamicProxy.Generators;`
`25`	`23`
`26`	`24`	`internal static class InvocationHelper`
`27`	`25`	`{`
`28`		`- private static readonly SynchronizedDictionary<CacheKey, MethodInfo> cache =`
`29`		`- new SynchronizedDictionary<CacheKey, MethodInfo>();`
	`26`	`+ private static readonly ConcurrentDictionary<CacheKey, MethodInfo> cache =`
	`27`	`+ new ConcurrentDictionary<CacheKey, MethodInfo>();`
`30`	`28`
`31`	`29`	`public static MethodInfo GetMethodOnObject(object target, MethodInfo proxiedMethod)`
`32`	`30`	`{`