Use ConcurrentDictionary instead of SynchronizedDictionary

src/Castle.Core/Components.DictionaryAdapter/DictionaryAdapterFactory.cs

@@ -16,14 +16,15 @@ namespace Castle.Components.DictionaryAdapter
 {
 	using System;
 	using System.Collections;
+	using System.Collections.Concurrent;
 	using System.Collections.Generic;
 	using System.Collections.Specialized;
 	using System.ComponentModel;
+	using System.Diagnostics;
 	using System.Linq;
 	using System.Reflection;
 	using System.Reflection.Emit;
 	using System.Threading;
-	using System.Diagnostics;
 
 	using Castle.Components.DictionaryAdapter.Xml;
 	using Castle.Core.Internal;
@@ -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
 
@@ -132,8 +133,8 @@ private DictionaryAdapterMeta InternalGetAdapterMeta(Type type,
 					descriptor = other.CreateDescriptor();
 				}
 
-				var typeBuilder = CreateTypeBuilder(type);
-				return CreateAdapterMeta(type, typeBuilder, descriptor);
+				var typeBuilder = CreateTypeBuilder(t);
+				return CreateAdapterMeta(t, typeBuilder, descriptor);
 			});
 		}
 

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.TypeCache.GetOrAdd(key, _ =>
 				new DelegateTypeGenerator(method, targetType)
 				.Generate(@class, namingScope)
 				.BuildType());

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.TypeCache.GetOrAdd(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.TypeCache.GetOrAdd(key, _ => BuildInvocationType(method, @class));
 		}
 
 		private MethodGenerator IndirectlyCalledMethodGenerator(MetaMethod method, ClassEmitter proxy,

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.TypeCache.GetOrAdd(key, _ =>
 				new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
 				                                       method,
 				                                       method.Method,

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.TypeCache.GetOrAdd(key, _ =>
 				new CompositionInvocationTypeGenerator(methodInfo.DeclaringType,
 				                                       method,
 				                                       methodInfo,

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.TypeCache.GetOrAdd(key, _ =>
 				new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
 				                                       method,
 				                                       method.Method,

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)
 		{

src/Castle.Core/DynamicProxy/ModuleScope.cs

@@ -17,14 +17,13 @@
 namespace Castle.DynamicProxy
 {
 	using System;
+	using System.Collections.Concurrent;
 	using System.Collections.Generic;
-	using System.Diagnostics;
 	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,7 @@ internal INamingScope NamingScope
 			get { return namingScope; }
 		}
 
-		internal SynchronizedDictionary<CacheKey, Type> TypeCache => typeCache;
+		internal ConcurrentDictionary<CacheKey, Type> TypeCache => typeCache;
 
 		/// <summary>
 		///   Gets the key pair used to sign the strong-named assembly generated by this <see cref = "ModuleScope" />.
@@ -504,15 +503,18 @@ private void AddCacheMappings(AssemblyBuilder builder)
 		{
 			var mappings = new Dictionary<CacheKey, string>();
 
-			typeCache.ForEach((key, value) =>
+			foreach (var kvp in typeCache)
 			{
+				var key = kvp.Key;
+				var value = kvp.Value;
+
 				// NOTE: using == returns invalid results.
 				// we need to use Equals here for it to work properly
 				if (builder.Equals(value.Assembly))
 				{
 					mappings.Add(key, value.FullName);
 				}
-			});
+			};
 
 			CacheMappingsAttribute.ApplyTo(builder, mappings);
 		}
@@ -551,7 +553,7 @@ public void LoadAssemblyIntoCache(Assembly assembly)
 
 				if (loadedType != null)
 				{
-					typeCache.AddOrUpdateWithoutTakingLock(mapping.Key, loadedType);
+					typeCache[mapping.Key] = loadedType;
 				}
 			}
 		}

src/Castle.Core/DynamicProxy/ProxyUtil.cs

@@ -17,20 +17,19 @@
 namespace Castle.DynamicProxy
 {
 	using System;
-	using System.Collections.Generic;
+	using System.Collections.Concurrent;
 	using System.Diagnostics.CodeAnalysis;
 	using System.Linq;
 	using System.Reflection;
 	using System.Runtime.CompilerServices;
-	using System.Threading;
 
 	using Castle.Core.Internal;
 	using Castle.DynamicProxy.Generators;
 	using Castle.DynamicProxy.Internal;
 
 	public static class ProxyUtil
 	{
-		private static readonly SynchronizedDictionary<Assembly, bool> internalsVisibleToDynamicProxy = new SynchronizedDictionary<Assembly, bool>();
+		private static readonly ConcurrentDictionary<Assembly, bool> internalsVisibleToDynamicProxy = new ConcurrentDictionary<Assembly, bool>();
 
 		/// <summary>
 		///   Creates a delegate of the specified type to a suitable `Invoke` method