public KernelConfigurator(IKernel kernel)
{
_kernel = kernel;
var namedScopeModule = new NamedScopeModule();
if (!kernel.HasModule(namedScopeModule.Name))
{
kernel.Load(namedScopeModule);
}
_consumerRegistry = kernel.TryGet <IConsumerRegistry>();
if (_consumerRegistry == null)
{
kernel.Bind <IConsumerRegistry>().To <ConsumerRegistry>().InSingletonScope();
_consumerRegistry = kernel.Get <IConsumerRegistry>();
}
_sagaRegistry = kernel.TryGet <ISagaRegistry>();
if (_sagaRegistry == null)
{
kernel.Bind <ISagaRegistry>().To <SagaRegistry>().InSingletonScope();
_sagaRegistry = kernel.Get <ISagaRegistry>();
}
}
/// <summary>
/// Method for loading new modules containing bindings to types for dependency resolving.
/// </summary>
/// <param name="newModule">Module to load.</param>
public static void AddModule(INinjectModule newModule)
{
if (!Kernel.HasModule(newModule.Name))
{
Kernel.Load(newModule);
}
}
public IController GetInstance(Type controllerType, NameValueCollection queries)
{
//Her tip için
foreach (var resolverType in _resolverTypes)
{
//Her query farklı olduğu için gelen modülde farklı olacaktır.
var moduleInstance = (INinjectModule)Activator.CreateInstance(resolverType, queries);
//Gelen modülün Kernel'da olup olmadığı kontrol edilir.
if (_kernel.HasModule(moduleInstance.Name) /*&& Modül değişmiş ise*/)
{
//Eğer Kernel'da var ise modül silinir. Çünkü içeriği farklı.
//Problem: Eğer query demişmediği halde modülleri silip tekrar yüklüyor. Eğer modül değişmemişse silmesin.
//Çözüm önerisi queryleri karşılaştıran bir proxy sınıf ile çözülebilir.
_kernel.Unload(moduleInstance.Name);
}
//Değişen modülleri tekrar yükle.
_kernel.Load(moduleInstance);
}
//Kontroller tipine göre çözümlemeleri döndür.
var currentTypeInstance = (IController)_kernel.Get(controllerType);
return(currentTypeInstance);
}
public static void EnsureFactoryExtensionLoaded(IKernel kernel)
{
if (!kernel.HasModule(typeof(Ninject.Extensions.Factory.FuncModule).FullName))
{
kernel.Load(new[] { typeof(Ninject.Extensions.Factory.FuncModule).Assembly });
}
}
public static void LoadIfNotLoaded <T> (this IKernel kernel) where T : INinjectModule, new()
{
if (!kernel.HasModule(typeof(T).FullName))
{
kernel.Load <T>();
}
}
public void LoadModule_LoadsOnlyOnce()
{
var module = Substitute.For <INinjectModule>();
module.Name.Returns("module");
kernel.HasModule(module.Name).Returns(true);
sut.LoadModule(module);
kernel.DidNotReceiveWithAnyArgs().Load(module);
}
public static IKernel WithModule(this IKernel kernel, INinjectModule module)
{
if (kernel.HasModule(module.Name))
{
return(kernel);
}
try { kernel.Load(module); }
catch (Exception ex)
{
var error = $"Unable to load module '{module.Name}' see inner exception.";
throw new Exception(error, ex);
}
return(kernel);
}
/// <summary>
/// Attempts to load the module instance to the kernel
/// </summary>
/// <param name="kernel"></param>
/// <param name="module">Module to load</param>
/// <returns>IKernel instance with module loaded</returns>
/// <exception cref="Exception">Thrown if unable to load the module</exception>
/// <example>
/// kernel.WithModule(new LoggingModule());
/// </example>
public static IKernel WithModule(this IKernel kernel, INinjectModule module)
{
if (!kernel.HasModule(module.Name))
{
try
{
kernel.Load(module);
}
catch (Exception ex)
{
var error = string.Format("Unable to load module '{0}' see inner exception.", module.Name);
throw new Exception(error, ex);
}
}
return(kernel);
}
public void LoadAssemblies(IReadOnlyCollection <Assembly> assemblies)
{
foreach (var assembly in assemblies)
{
if (loadedAssemblies.Contains(assembly))
{
continue;
}
var modules = GetNinjectModules(assembly).Where(x => !kernel.HasModule(x.Name)).ToArray();
if (modules.Length > 0)
{
Logger.Trace($"Loading {modules.Length} dependency modules from assembly {assembly.FullName}: {string.Join(",", modules.Select(x => x.Name))}");
kernel.Load(modules);
}
loadedAssemblies.Add(assembly);
}
}
public static IKernel WithModule <TModule>(this IKernel kernel) where TModule : INinjectModule, new()
{
INinjectModule module = null;
try
{
module = (INinjectModule)Activator.CreateInstance(typeof(TModule));
if (!kernel.HasModule(module.Name))
{
kernel.Load <TModule>();
}
}
catch (Exception ex)
{
var error = $"Unable to load module '{module.Name}' see inner exception.";
throw new Exception(error, ex);
}
return(kernel);
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
// Find all assemblies that have ninject modules and load them if NONE from the assembly have already been loaded
// Note: this means that if a single module has been loaded directly, all others in that assembly will also have
// to be loaded in the same manner if they are to be used in this application
foreach (
var a in
AppDomain.CurrentDomain.GetAssemblies()
.Where(r => r.FullName.ToLower().StartsWith("revolutionsounds")))
{
if (a.GetTypes().Any(m => typeof (NinjectModule).IsAssignableFrom(m)) &&
!a.GetTypes().Any(m => typeof (NinjectModule).IsAssignableFrom(m) && kernel.HasModule(m.FullName)))
{
kernel.Load(a);
}
}
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
// Find all assemblies that have ninject modules and load them if NONE from the assembly have already been loaded
// Note: this means that if a single module has been loaded directly, all others in that assembly will also have
// to be loaded in the same manner if they are to be used in this application
foreach (
var a in
AppDomain.CurrentDomain.GetAssemblies()
.Where(r => r.FullName.ToLower().StartsWith("revolutionsounds")))
{
if (a.GetTypes().Any(m => typeof(NinjectModule).IsAssignableFrom(m)) &&
!a.GetTypes().Any(m => typeof(NinjectModule).IsAssignableFrom(m) && kernel.HasModule(m.FullName)))
{
kernel.Load(a);
}
}
}
protected override bool CanConnect(INinjectModule module)
{
return(base.CanConnect(module) &&
_connections.Any(m => m.Name == module.Name) == false &&
_kernel.HasModule(module.Name) == false);
}
public static void EnsureFactoryExtensionLoaded(IKernel kernel)
{
if (!kernel.HasModule(typeof (Ninject.Extensions.Factory.FuncModule).FullName))
kernel.Load(new[] {typeof (Ninject.Extensions.Factory.FuncModule).Assembly});
}
