/// <summary>
/// Registers an object for navigation.
/// </summary>
/// <typeparam name="T">The Type of the object to register</typeparam>
/// <param name="ninjectModule"><see cref="NinjectModule"/> used to register type for Navigation.</param>
/// <param name="name">The unique name to register with the object.</param>
public static void RegisterTypeForNavigation <T>(this NinjectModule ninjectModule, string name = null)
{
Type type = typeof(T);
string viewName = string.IsNullOrWhiteSpace(name) ? type.Name : name;
ninjectModule.Bind <object>().To <T>().Named(viewName);
}
public static void BindBusinesses(this NinjectModule iocModule)
{
iocModule.Bind(typeof(IGenericBusiness <,>)).To(typeof(GenericBusiness <,>));
iocModule.Bind <IProductoBusiness>().To <ProductoBusiness>();
iocModule.Bind <IPedidoBusiness>().To <PedidoBusiness>();
iocModule.Bind <IClienteBusiness>().To <ClienteBusiness>();
}
public static T GetInstance <T>(NinjectModule module)
{
var kernel = StandardKernelInstance();
kernel.Load(module);
return(kernel.Get <T>());
}
public UpdateProducts(NinjectModule module)
{
InitializeComponent();
_module = module;
_productService = InstanceFactory.GetInstance <IProductService>(_module);
_categoryService = InstanceFactory.GetInstance <ICategoryService>(_module);
}
public static void AddHttpRestClientFactory(this NinjectModule module)
{
module
.Bind <IHttpRestClientFactory>()
.To <HttpRestClientFactory>()
.InSingletonScope();
}
/// <summary>
/// Adds a Ninject module.
/// </summary>
/// <param name="ninjectModule">The Ninject module.</param>
public void AddModule(NinjectModule ninjectModule)
{
lock (this.modules)
{
this.modules.Add(ninjectModule);
}
}
public MainPage(NinjectModule androidDependenciesModule)
{
InitializeComponent();
m_kernel = new StandardKernel(new AppModule(), androidDependenciesModule);
m_model = new MainPageModel(m_kernel.Get <IQuestionProvider>());
m_model.GetNextQuestion();
this.BindingContext = m_model;
}
public void LoadShouldBeCalled()
{
KernelConfigurationMock.Setup(p => p.Components).Returns(ComponentsMock.Object);
NinjectModule.OnLoad(KernelConfigurationMock.Object, SettingsMock.Object);
Assert.Equal(1, NinjectModule.LoadCount);
}
protected override IKernel CreateKernel()
{
var dbConnectionString = ConfigurationManager.ConnectionStrings["ManicureDBConnectionString"].ConnectionString;
var modules = new NinjectModule[] { new BusinessLogicModule(), new DalModule(dbConnectionString) };
return(new StandardKernel(modules));
}
public UpdateProducts(NinjectModule module, Product product)
{
_module = module;
Product1 = product;
_productService = Instancefactory.GetInstance<IProductService>(module);
_categoryService = Instancefactory.GetInstance<ICategoryService>(module);
InitializeComponent();
}
public void CallShouldBeDelegatedToKernelConfiguration()
{
KernelConfigurationMock.Setup(p => p.AddBinding(BindingMock.Object));
NinjectModule.AddBinding(BindingMock.Object);
KernelConfigurationMock.Verify(p => p.AddBinding(BindingMock.Object), Times.Once());
}
static void Main(string[] args)
{
NinjectModule serviceModule = ServiceModule.GetInstance();
//serviceModule.Load();
NinjectModule carModule = new CarModule();
//carModule.Load();
}
public static void BindBusinessesNamedScoped(this NinjectModule iocModule, string NamedScope)
{
iocModule.Bind(typeof(IGenericBusiness <,>)).To(typeof(GenericBusiness <,>)).InNamedScope(NamedScope);
iocModule.Bind <IProductoBusiness>().To <ProductoBusiness>().InNamedScope(NamedScope);
iocModule.Bind <IPedidoBusiness>().To <PedidoBusiness>().InNamedScope(NamedScope);
iocModule.Bind <IClienteBusiness>().To <ClienteBusiness>().InNamedScope(NamedScope);
iocModule.Bind <IPaisBusiness>().To <PaisBusiness>().InNamedScope(NamedScope);
}
public Task <bool> RunAsync(ISettings settings, NinjectModule configurationModule = null)
{
var standardKernel = new StandardKernel(configurationModule ?? new ConfigurationModule(settings));
var fixers = standardKernel.GetAll <IFixer>().OrderBy(x => x.Order).ToArray();
var solutionProcessor = standardKernel.Get <ISolutionProcessor>();
return(RunCoreAsync(settings, fixers, solutionProcessor));
}
private static NinjectModule getModule()
{
string path = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + @"bin\";
Assembly assembly = Assembly.LoadFrom(path + dalInfo[0]);
NinjectModule nModule = (NinjectModule)assembly.CreateInstance(dalInfo[1]);
return(nModule);
}
static void Main(string[] args)
{
NinjectModule ninjectModule = new NinjectModule();
var kernel = ninjectModule.Init();
WithQuartz(kernel).GetAwaiter().GetResult();
Console.ReadKey();
}
public static void AddModule(NinjectModule module)
{
var exists = _ninjectKernel.GetModules().FirstOrDefault(x => x.Name == module.Name);
if (exists == null)
{
_ninjectKernel.Load(module);
}
}
public void ArgumentNullExceptionShouldBeThrownWhenKernelConfigurationIsNull()
{
const IKernelConfiguration kernelConfiguration = null;
var actual = Assert.Throws <ArgumentNullException>(() => NinjectModule.OnLoad(kernelConfiguration, SettingsMock.Object));
Assert.Null(actual.InnerException);
Assert.Equal(nameof(kernelConfiguration), actual.ParamName);
}
public void BindingShouldBeAddedToBindings()
{
KernelConfigurationMock.Setup(p => p.AddBinding(BindingMock.Object));
NinjectModule.AddBinding(BindingMock.Object);
Assert.Equal(1, NinjectModule.Bindings.Count);
Assert.True(NinjectModule.Bindings.Contains(BindingMock.Object));
}
public void ArgumentNullExceptionShouldBeThrownWhenSettingsIsNull()
{
const INinjectSettings settings = null;
var actual = Assert.Throws <ArgumentNullException>(() => NinjectModule.OnLoad(KernelConfigurationMock.Object, settings));
Assert.Null(actual.InnerException);
Assert.Equal(nameof(settings), actual.ParamName);
}
public void SettingsShouldBeAssigned()
{
KernelConfigurationMock.Setup(p => p.Components).Returns(ComponentsMock.Object);
NinjectModule.OnLoad(KernelConfigurationMock.Object, SettingsMock.Object);
Assert.NotNull(NinjectModule.Settings);
Assert.Same(SettingsMock.Object, NinjectModule.Settings);
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
var modules = new NinjectModule[]
{
new RepositoriesModules(), new ValidatorsModules()
};
kernel.Load(modules);
}
public MainMenu(NinjectModule module)
{
_module = module;
_productService = InstanceFactory.GetInstance <IProductService>(_module);
_cartService = InstanceFactory.GetInstance <ICartService>(_module);
_categoryService = InstanceFactory.GetInstance <ICategoryService>(_module);
_cart = new Cart();
InitializeComponent();
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
NinjectModule[] modules = new NinjectModule[]
{
new WebModule(),
};
kernel.Load(modules);
}
/// <summary>
/// Creates the kernel that will manage your application.
/// </summary>
/// <returns>The created kernel.</returns>
private static IKernel CreateKernel()
{
var modules = new NinjectModule[] { new TestBindModule() };
var kernel = new StandardKernel(modules);
RegisterServices(kernel);
return(kernel);
}
/// <summary>
/// Injects the specified bindings.
/// </summary>
/// <param name="bindings">The bindings.</param>
public static void Inject(NinjectModule bindings)
{
log4net.Config.XmlConfigurator.Configure();
var settings = new NinjectSettings {
LoadExtensions = false
};
kernel = new StandardKernel(settings, new INinjectModule[] { new Log4NetModule(), bindings });
kernel.Load(Assembly.GetExecutingAssembly());
}
public void BindingShouldBeRemovedFromBindings()
{
NinjectModule.Bindings.Add(BindingMock.Object);
KernelConfigurationMock.Setup(p => p.RemoveBinding(BindingMock.Object));
NinjectModule.RemoveBinding(BindingMock.Object);
Assert.Empty(NinjectModule.Bindings);
}
public void NoArgumentNullCheckShouldBePerformed()
{
const Type service = null;
KernelConfigurationMock.Setup(p => p.Unbind(service));
NinjectModule.Unbind(service);
KernelConfigurationMock.Verify(p => p.Unbind(service), Times.Once());
}
public void CallShouldBeDelegatedToKernelConfiguration()
{
var service = typeof(string);
KernelConfigurationMock.Setup(p => p.Unbind(service));
NinjectModule.Unbind(service);
KernelConfigurationMock.Verify(p => p.Unbind(service), Times.Once());
}
public void NoArgumentNullCheckShouldBePerformed()
{
const IBinding binding = null;
KernelConfigurationMock.Setup(p => p.AddBinding(binding));
NinjectModule.AddBinding(binding);
KernelConfigurationMock.Verify(p => p.AddBinding(binding), Times.Once());
}
