[DO NOT MERGE] Poor main attempt to battle thread safety

BoDi.Tests/ParallelBoDiTests.cs

@@ -0,0 +1,66 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BoDi.Tests
+{
+    [TestFixture]
+    public class ParallelBoDiTests
+    {
+        private interface IBodiFactory
+        {
+            IObjectContainer Create(IObjectContainer parent = null);
+
+        }
+        private class BoDiSimpleFactory : IBodiFactory
+        {
+            public IObjectContainer Create(IObjectContainer parent = null) => new ObjectContainer(parent);
+        }
+
+        private static IObjectContainer[] Create(IBodiFactory factory)
+        {
+            var parent = factory.Create();
+            parent.RegisterTypeAs<object, object>().InstancePerContext();
+
+            IEnumerable<IObjectContainer> CreateChilds(int count)
+            {
+                for (var i = 1; i < count; i ++)
+                {
+                    yield return factory.Create(parent);
+                }
+            }
+
+            return CreateChilds(50).ToArray();
+        }
+
+        [Test]
+        public async Task ShouldWorkWhenCreateParallely()
+        {
+            var containers = Create(new BoDiSimpleFactory());
+
+            var result = await Task.WhenAll(containers.Select(c => Task.Run(() => c.Resolve<object>())).ToArray());
+            AssertResultsAreSame(result);
+        }
+
+        private static void AssertResultsAreSame(object[] result)
+        {
+            var first = result.First();
+            foreach (var any in result)
+            {
+                Assert.AreSame(first, any);
+            }
+        }
+
+
+        [Test]
+        public void ShouldWorkWhenCreateSequentally()
+        {
+            var containers = Create(new BoDiSimpleFactory());
+            var result = containers.Select(c => c.Resolve<object>()).ToArray();
+            AssertResultsAreSame(result);
+        }
+    }
+}

BoDi/BoDi.cs

@@ -523,12 +523,15 @@ private object ChangeType(string name, Type keyType)
 
         private bool isDisposed = false;
         private readonly ObjectContainer baseContainer;
+        protected object SyncRootForChilds = new object();
+
         private readonly Dictionary<RegistrationKey, IRegistration> registrations = new Dictionary<RegistrationKey, IRegistration>();
         private readonly List<RegistrationKey> resolvedKeys = new List<RegistrationKey>();
         private readonly Dictionary<RegistrationKey, object> objectPool = new Dictionary<RegistrationKey, object>();
 
         public event Action<object> ObjectCreated;
         public IObjectContainer BaseContainer => baseContainer;
+
 
         public ObjectContainer(IObjectContainer baseContainer = null) 
         {
@@ -778,7 +781,12 @@ private object Resolve(Type typeToResolve, ResolutionList resolutionPath, string
             }
 
             if (baseContainer != null)
-                return baseContainer.GetRegistrationResult(keyToResolve);
+            {
+                lock (baseContainer.SyncRootForChilds)
+                {
+                    return baseContainer.GetRegistrationResult(keyToResolve);
+                }
+            }
 
             if (IsSpecialNamedInstanceDictionaryKey(keyToResolve))
             {
@@ -845,7 +853,21 @@ private object ResolveObject(RegistrationKey keyToResolve, ResolutionList resolu
 
             var resolutionPathForResolve = registrationToUse.Key == this ? 
                 resolutionPath : new ResolutionList();
-            var result = registrationToUse.Value.Resolve(registrationToUse.Key, keyToResolve, resolutionPathForResolve);
+
+            object result;
+
+            if (registrationToUse.Key == this)
+            {
+                result = registrationToUse.Value.Resolve(registrationToUse.Key, keyToResolve, resolutionPathForResolve);
+            }
+            else
+            {
+                lock (registrationToUse.Key.SyncRootForChilds)
+                {
+                    result = registrationToUse.Value.Resolve(registrationToUse.Key, keyToResolve, resolutionPathForResolve);
+                }
+            }
+
             if (isImplicitTypeRegistration) // upon successful implicit registration, we register the rule, so that sub context can also get the same resolved value
                 AddRegistration(keyToResolve, registrationToUse.Value);
             return result;