Added Safe Module Loading

src/Ninject.Test/Integration/ModuleLoadingTests/WhenLoadIsCalledWithModule.cs

@@ -76,6 +76,23 @@ public void TwoModulesWithSameNamesAreNotSupported()
             moduleLoadingAction.ShouldThrow<NotSupportedException>();
         }
 
+		[Fact]
+		public void TwoModulesWithSameNamesDoesNotLoadSecondModule()
+		{
+			const string ModuleName = "SomeModuleName";
+			var moduleMock1 = this.CreateModuleMock(ModuleName);
+			var module1 = moduleMock1.Object;
+			var moduleMock2= this.CreateModuleMock(ModuleName);
+			var module2 = moduleMock2.Object;
+
+            this.Kernel.LoadIfNotLoaded(module1);
+            this.Kernel.LoadIfNotLoaded(module2);
+
+			this.Kernel.GetModules().Should().BeEquivalentTo(module1);
+			moduleMock1.Verify(x => x.OnLoad(this.Kernel), Times.Once());
+			moduleMock2.Verify(x => x.OnLoad(this.Kernel), Times.Never());
+		}
+
         [Fact]
         public void ModuleWithSameNameCanBeLoadedAfterTheFirstIsUnloaded()
         {
@@ -114,6 +131,27 @@ public void ModulesAreVerifiedAfterAllModulesAreLoaded()
 
             orderStringBuilder.ToString().Should().Be("LoadModule1 LoadModule2 VerifyModule VerifyModule ");
         }
+
+        [Fact]
+        public void ModulesAreVerifiedAfterAllModulesAreLoadedExcludingPreviouslyLoadedModules()
+        {
+            var moduleMock1 = this.CreateModuleMock("SomeName1");
+            var moduleMock2 = this.CreateModuleMock("SomeName1");
+            var moduleMock3 = this.CreateModuleMock("SomeName2");
+            var orderStringBuilder = new StringBuilder();
+
+            moduleMock1.Setup(m => m.OnLoad(this.Kernel)).Callback(() => orderStringBuilder.Append("LoadModule1 "));
+            moduleMock3.Setup(m => m.OnLoad(this.Kernel)).Callback(() => orderStringBuilder.Append("LoadModule2 "));
+            moduleMock1.Setup(m => m.OnVerifyRequiredModules()).Callback(() => orderStringBuilder.Append("VerifyModule "));
+            moduleMock3.Setup(m => m.OnVerifyRequiredModules()).Callback(() => orderStringBuilder.Append("VerifyModule "));
+
+            this.Kernel.Settings.LoadModuleIfNotLoaded = true;
+            this.Kernel.Load(moduleMock1.Object, moduleMock2.Object, moduleMock3.Object);
+
+            orderStringBuilder.ToString().Should().Be("LoadModule1 LoadModule2 VerifyModule VerifyModule ");
+            moduleMock2.Verify(m => m.OnLoad(this.Kernel), Times.Never());
+            moduleMock2.Verify(m => m.OnVerifyRequiredModules(), Times.Never());
+        }
     }
 }
 #endif

src/Ninject/INinjectSettings.cs

@@ -90,6 +90,16 @@ public interface INinjectSettings
         /// <value><c>true</c> if null is allowed as injected value otherwise false.</value>
         bool AllowNullInjection { get; set; }
 
+		/// <summary>
+		/// Gets or sets a value indicating whether only unloaded modules be loaded.
+		/// If the module is not loaded, it will load the module; otherwise, it will skip
+		/// loading the module.
+		/// By default this is disabled and whenever a module is loaded and has already been
+		/// loaded, an exception is thrown.
+		/// </summary>
+		/// <value><c>true</c>Module is loaded only if it has not been loaded; otherwise, <c>false</c>.</value>
+		bool LoadModuleIfNotLoaded { get; set; }
+
         /// <summary>
         /// Gets the value for the specified key.
         /// </summary>

src/Ninject/KernelConfiguration.cs

@@ -147,7 +147,15 @@ public void Load(IEnumerable<INinjectModule> m)
 
                 if (this.modules.TryGetValue(module.Name, out existingModule))
                 {
-                    throw new NotSupportedException(ExceptionFormatter.ModuleWithSameNameIsAlreadyLoaded(module, existingModule));
+					if (this.Settings.LoadModuleIfNotLoaded)
+                    {
+                        // Go to next module because this one was loaded
+                        continue;
+                    }
+                    else
+					{
+						throw new NotSupportedException(ExceptionFormatter.ModuleWithSameNameIsAlreadyLoaded (module, existingModule));
+					}
                 }
 
                 module.OnLoad(this);

src/Ninject/NinjectSettings.cs

@@ -158,6 +158,20 @@ public bool AllowNullInjection
             set { this.Set("AllowNullInjection", value); }
         }
 
+		/// <summary>
+		/// Gets or sets a value indicating whether only unloaded modules be loaded.
+		/// If the module is not loaded, it will load the module; otherwise, it will skip
+		/// loading the module.
+		/// By default this is disabled and whenever a module is loaded and has already been
+		/// loaded, an exception is thrown.
+		/// </summary>
+		/// <value><c>true</c>Module is loaded only if it has not been loaded; otherwise, <c>false</c>.</value>
+		public bool LoadModuleIfNotLoaded
+		{
+			get { return this.Get("LoadModuleIfNotLoaded", false); }
+			set { this.Set("LoadModuleIfNotLoaded", value); }
+		}
+
         /// <summary>
         /// Gets the value for the specified key.
         /// </summary>

src/Ninject/Syntax/ModuleLoadExtensions.cs

@@ -42,6 +42,33 @@ public static void Load(this IKernelConfiguration kernelConfiguration, params IN
             kernelConfiguration.Load(modules);
         }
 
+		/// <summary>
+		/// Creates a new instance of the module and loads it into the kernel if it is not loaded.
+		/// </summary>
+		/// <typeparam name="TModule">The type of module.</typeparam>
+		/// <param name="kernelConfiguration">The kernel configuration into which the module is loaded.</param>
+		public static void LoadIfNotLoaded<TModule>(this IKernelConfiguration kernelConfiguration)
+			where TModule : INinjectModule, new()
+		{
+			kernelConfiguration.LoadIfNotLoaded(new TModule());
+		}
+
+		/// <summary>
+		/// Loads the module(s) into the kernel if the module is not loaded.
+		/// </summary>
+		/// <param name="kernelConfiguration">The kernel configuration.</param>
+		/// <param name="modules">The modules to load into which the modules are loaded.</param>
+		public static void LoadIfNotLoaded(this IKernelConfiguration kernelConfiguration, params INinjectModule[] modules)
+		{
+			foreach (var module in modules)
+			{
+				if (kernelConfiguration.HasModule(module.Name))
+				{
+					kernelConfiguration.Load(module);
+				}
+			}
+		}
+
         #if !NO_ASSEMBLY_SCANNING
         /// <summary>
         /// Loads modules from the files that match the specified pattern(s).