/*----------------------------------------------------------------------------------------*/
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="KernelBase"/> class.
/// </summary>
/// <param name="options">The options to use.</param>
/// <param name="modules">The modules to load into the kernel.</param>
protected KernelBase(KernelOptions options, IEnumerable <IModule> modules)
{
Ensure.ArgumentNotNull(options, "options");
Options = options;
// Ensure that at least a null logger is connected while we load the components.
Logger = NullLogger.Instance;
Components = InitializeComponents();
ValidateComponents();
// If the user has connected a real logger factory, get a real logger.
Logger = Components.LoggerFactory.GetLogger(GetType());
// Create the container scope, and register it with the tracker.
IScope scope = Components.ScopeFactory.Create();
Components.Tracker.RegisterScope(this, scope);
// Load the modules into the module manager.
Components.ModuleManager.Load(modules);
ActivateEagerServices();
}
public void SelfBoundTypeReceivesPrivateMethodInjection()
{
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options))
{
var mock = kernel.Get<RequestsPrivateMethodInjection>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
}
}
public void DebugInfoCreatedFromStackTrace()
{
var module = new InlineModule(m => m.Bind<IMock>().To<SimpleObject>());
var options = new KernelOptions { GenerateDebugInfo = true };
using (var kernel = new StandardKernel(options, module))
{
IContext context = kernel.Components.ContextFactory.Create(typeof(IMock));
IBinding binding = kernel.Components.BindingSelector.SelectBinding(typeof(IMock), context);
Assert.That(binding, Is.Not.Null);
Assert.That(binding.DebugInfo, Is.Not.Null);
}
}
public void ServiceBoundTypeReceivesPrivateFieldInjection()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(RequestsPrivateFieldInjection)));
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options, module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
var typedMock = mock as RequestsPrivateFieldInjection;
Assert.That(typedMock, Is.Not.Null);
Assert.That(typedMock.Child, Is.Not.Null);
}
}
public void EagerActivationCausesSingletonInstancesToBeImmediatelyActivated()
{
var module = new InlineModule(m => m.Bind<ObjectWithSingletonBehavior>().ToSelf());
var options = new KernelOptions { UseEagerActivation = true };
using (var kernel = new StandardKernel(options, module))
{
Type type = typeof(ObjectWithSingletonBehavior);
IContext context = kernel.Components.ContextFactory.Create(type);
IBinding binding = kernel.Components.BindingSelector.SelectBinding(type, context);
Assert.That(binding, Is.Not.Null);
IActivationPlan plan = binding.Components.Planner.GetPlan(binding, type);
var behavior = plan.Behavior as SingletonBehavior;
Assert.That(behavior, Is.Not.Null);
Assert.That(behavior.ContextCache, Is.Not.Empty);
}
}
public void HeuristicSelectsConstructorWithMostValidArgumentsEvenIfNotLargest()
{
var testModule = new InlineModule(
m => m.Bind<PocoForFieldAutoWiring>().ToSelf(),
m => m.Bind<IMock>().To<SimpleObject>()
);
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options, new AutoWiringModule(), testModule))
{
var mock = kernel.Get<PocoForFieldAutoWiring>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.InstanceOfType(typeof(SimpleObject)));
Assert.That(mock.ServiceA, Is.Null);
Assert.That(mock.ServiceB, Is.Null);
}
}
public void HeuristicSelectsPropertiesIfTheyHaveMatchingBindings()
{
var testModule = new InlineModule(
m => m.Bind<PocoForFieldAutoWiring>().ToSelf(),
m => m.Bind<IServiceA>().To<ServiceImplA>(),
m => m.Bind<IServiceB>().To<ServiceImplB>()
);
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options, new AutoWiringModule(), testModule))
{
var mock = kernel.Get<PocoForFieldAutoWiring>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Null);
Assert.That(mock.ServiceA, Is.Not.Null);
Assert.That(mock.ServiceA, Is.InstanceOfType(typeof(ServiceImplA)));
Assert.That(mock.ServiceB, Is.Not.Null);
Assert.That(mock.ServiceB, Is.InstanceOfType(typeof(ServiceImplB)));
}
}
public void CanInjectCircularReferencesIntoMethods()
{
var module = new InlineModule(
m => m.Bind<CircularMethodMockA>().ToSelf(),
m => m.Bind<CircularMethodMockB>().ToSelf()
);
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options, module))
{
var mockA = kernel.Get<CircularMethodMockA>();
var mockB = kernel.Get<CircularMethodMockB>();
Assert.That(mockA, Is.Not.Null);
Assert.That(mockB, Is.Not.Null);
Assert.That(mockA.MockB, Is.SameAs(mockB));
Assert.That(mockB.MockA, Is.SameAs(mockA));
}
}
/*----------------------------------------------------------------------------------------*/
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="KernelBase"/> class.
/// </summary>
/// <param name="options">The options to use.</param>
/// <param name="modules">The modules to load into the kernel.</param>
protected KernelBase(KernelOptions options, IEnumerable<IModule> modules)
{
Ensure.ArgumentNotNull(options, "options");
Options = options;
// Ensure that at least a null logger is connected while we load the components.
Logger = NullLogger.Instance;
Components = InitializeComponents();
ValidateComponents();
// If the user has connected a real logger factory, get a real logger.
Logger = Components.LoggerFactory.GetLogger(GetType());
// Create the container scope, and register it with the tracker.
IScope scope = Components.ScopeFactory.Create();
Components.Tracker.RegisterScope(this, scope);
// Load the modules into the module manager.
Components.ModuleManager.Load(modules);
ActivateEagerServices();
}
public void IncompatibleProviderAndBindingServiceTypeThrowsException()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(ObjectWithNoInterfaces)));
var options = new KernelOptions { IgnoreProviderCompatibility = false };
using (var kernel = new StandardKernel(options, module))
{
kernel.Get<IMock>();
}
}
public void IncompatibleProviderAllowedIfProviderCompatibilityIsIgnored()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(ObjectWithNoInterfaces)));
var options = new KernelOptions { IgnoreProviderCompatibility = true };
using (var kernel = new StandardKernel(options, module))
{
var mock = kernel.Get(typeof(IMock)) as ObjectWithNoInterfaces;
Assert.That(mock, Is.Not.Null);
}
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Initializes a new instance of the <see cref="StandardKernel"/> class.
/// </summary>
/// <param name="options">The kernel options to use.</param>
/// <param name="modules">One or more modules to load into the kernel.</param>
public StandardKernel(KernelOptions options, params IModule[] modules)
: base(options, modules)
{
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Initializes a new instance of the <see cref="StandardKernel"/> class.
/// </summary>
/// <param name="options">The kernel options to use.</param>
/// <param name="modules">One or more modules to load into the kernel.</param>
public StandardKernel(KernelOptions options, IEnumerable <IModule> modules)
: base(options, modules)
{
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Initializes a new instance of the <see cref="StandardKernel"/> class.
/// </summary>
/// <param name="options">The kernel options to use.</param>
/// <param name="modules">One or more modules to load into the kernel.</param>
public StandardKernel(KernelOptions options, params IModule[] modules)
: base(options, modules)
{
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Initializes a new instance of the <see cref="StandardKernel"/> class.
/// </summary>
/// <param name="options">The kernel options to use.</param>
/// <param name="modules">One or more modules to load into the kernel.</param>
public StandardKernel(KernelOptions options, IEnumerable<IModule> modules)
: base(options, modules)
{
}