public static void Register(IKernel kernel)
{
if (!CurrentRequestData.DatabaseIsInstalled)
return;
foreach (IStylesheetBundle bundle in kernel.GetAll<IStylesheetBundle>())
{
var styleBundle = new StyleBundle(bundle.Url);
foreach (string file in bundle.Files)
{
styleBundle.Include(file);
}
BundleTable.Bundles.Add(styleBundle);
}
foreach (IScriptBundle bundle in kernel.GetAll<IScriptBundle>())
{
var styleBundle = new ScriptBundle(bundle.Url);
foreach (string file in bundle.Files)
{
styleBundle.Include(file);
}
BundleTable.Bundles.Add(styleBundle);
}
BundleTable.EnableOptimizations = kernel.Get<BundlingSettings>().EnableOptimisations;
}
public void OnLoad(IKernel kernel)
{
// Engine Components...
kernel.Bind<IWindowManager>().To<WindowManager>().InSingletonScope();
kernel.Bind<IEventAggregator>().To<EventAggregator>().InSingletonScope();
// Shell Components...
kernel.Bind<TreeNavigationViewModel>().ToSelf().InSingletonScope();
kernel.Bind<ShellViewModel>().ToSelf().InSingletonScope();
// Business Components...
//kernel.Bind<IShellScreen>().To<Konten>().InSingletonScope();
kernel.Bind<IShellScreen>().To<Kunden>().InSingletonScope();
kernel.Bind<IShellScreen>().To<Stammdaten>().InSingletonScope();
// HAck! How to set up?
var iShellScreens = kernel.GetAll<IShellScreen>();
foreach (var iShellScreen in iShellScreens)
{
var stamm = iShellScreen as Stammdaten;
if (stamm != null)
{
stamm.AddChild(new Konten());
}
}
}
private static void InitializeNfield(IKernel kernel)
{
DependencyResolver.Register(type => kernel.Get(type), type => kernel.GetAll(type));
NfieldSdkInitializer.Initialize((bind, resolve) => kernel.Bind(bind).To(resolve).InTransientScope(),
(bind, resolve) => kernel.Bind(bind).To(resolve).InSingletonScope(),
(bind, resolve) => kernel.Bind(bind).ToConstant(resolve));
}
public void Install(IKernel kernel)
{
kernel.Bind<IMapper>().To<Mapper>().InSingletonScope();
kernel.Bind(c => c.FromThisAssembly().
SelectAllClasses().InheritedFrom(typeof(IMapping))
.BindAllInterfaces());
kernel.GetAll<IMapping>().ToList().ForEach(m => m.Setup());
}
public TestAssistant()
{
_container = new StandardKernel();
IoC.GetInstance = (service, key) => _container.Get(service, key);
IoC.GetAllInstances = (service) => _container.GetAll(service);
IoC.BuildUp = (instance) => _container.Inject(instance);
BindConfigs();
}
public AppBootstrapper(IKernel kernel = null, IRoutingState router = null)
{
kernel = kernel ?? createStandardKernel();
Router = router ?? new RoutingState();
RxApp.ConfigureServiceLocator(
(t, s) => kernel.Get(t, s), (t, s) => kernel.GetAll(t, s));
Router.Navigate.Execute(RxApp.GetService<IDropRepoViewModel>());
}
public AppBootstrapper(IKernel kernel = null, IRoutingState router = null)
{
kernel = kernel ?? createStandardKernel();
Router = router ?? new RoutingState();
RxApp.ConfigureServiceLocator(
(t, s) => kernel.Get(t, s), (t, s) => kernel.GetAll(t, s));
// Our first screen is "Open cache"
Router.Navigate.Execute(RxApp.GetService<IOpenCacheViewModel>());
}
static OpenDomain()
{
_kernel = new StandardKernel();
DependencyResolver.Register(type => _kernel.Get(type), type => _kernel.GetAll(type));
NfieldSdkInitializer.Initialize((bind, resolve) => _kernel.Bind(bind).To(resolve).InTransientScope(),
(bind, resolve) => _kernel.Bind(bind).To(resolve).InSingletonScope(),
(bind, resolve) => _kernel.Bind(bind).ToConstant(resolve));
_kernel.Bind(typeof(IDomainManager)).To(typeof(DomainManager)).InSingletonScope();
_kernel.Bind(typeof(IInterviewerManager)).To(typeof(InterviewerManager)).InSingletonScope();
_kernel.Bind(typeof(IPSObjectMapper)).To(typeof(PSObjectMapper)).InSingletonScope();
_kernel.Bind(typeof(IProcessHelper)).To(typeof(ProcessHelper)).InSingletonScope();
}
private NHibernate.Cfg.Configuration BuildConfiguration(IKernel kernel)
{
var mappings =
from module in kernel.GetAll<ModuleBase>()
from t in module.GetNHibernateMappings()
select t;
return Fluently.Configure().Database(this.configurationProvider())
.Mappings(x => {
x.FluentMappings.AddFromAssembly(this.GetType().Assembly);
foreach (var t in mappings) x.FluentMappings.Add(t);
})
.BuildConfiguration();
}
internal static IEnumerable <T> ResolveAll <T>()
{
return(Kernel.GetAll <T>());
}
public IEnumerable <object> GetServices(Type serviceType)
{
return(kernel.GetAll(serviceType));
}
public static IEnumerable <TObject> ResolveAll <TObject>(params IParameter[] parameters)
{
return(_ninjectKernel.GetAll <TObject>(parameters));
}
/// <summary>
/// Return instances of all registered types requested.
/// </summary>
/// <remarks>
/// <para>
/// This method is useful if you've registered multiple types with the same
/// <see cref="Type"/> but different names.
/// </para>
/// <para>
/// Be aware that this method does NOT return an instance for the default (unnamed) registration.
/// </para>
/// </remarks>
/// <typeparam name="T">The type requested.</typeparam>
/// <param name="container">Container to resolve from.</param>
/// <param name="resolverOverrides">Any overrides for the resolve calls.</param>
/// <returns>Set of objects of type <typeparamref name="T"/>.</returns>
public static IEnumerable <T> ResolveAll <T>(this IKernel kernel, params IParameter[] resolverOverrides)
{
return(kernel.GetAll(typeof(T), resolverOverrides).Cast <T>());
}
public IEnumerable <object> GetServices(Type serviceType) => kernel.GetAll(serviceType);
public IEnumerable <object> GetServices(Type myServiceType)
{
return(myKernel.GetAll(myServiceType));
}
public IEnumerable <T> GetAll <T>()
{
return(kernel.GetAll <T>());
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public IEnumerable <object> GetAllInstances(Type type)
{
return(container.GetAll(type));
}
private static void RegisterServices(IKernel kernel)
{
CompositionRoot.BindConnection(kernel, ConnectionString);
CompositionRoot.BindDataAccess(kernel, ConnectionString, FilesConnectionString);
CompositionRoot.BindServices(kernel, MainLogger);
CompositionJobsHelper.BindJobs(kernel, ConnectionString, FilesConnectionString);
try
{
var runners = kernel.GetAll<IRunner>().ToArray();
RunnerController.Run(runners);
}
catch(Exception e)
{
MainLogger.Error("Failed to start runners ", e);
throw;
}
MainLogger.Info("Jobs are started");
}
public Dictionary <string, JRpcModule> GetAllServices()
{
return(_kernel.GetAll <JRpcModule>().ToDictionary(t => t.ModuleName, t => t));
}
public IEnumerable <object> GetServices(Type serviceType)
{
return(Kernal.GetAll(serviceType, new IParameter[0]));
//throw new NotImplementedException();
}
public IEnumerable <T> GetPluginInstances <T>()
{
return(kernel.GetAll <T>());
}
public IEnumerable <IRunableOrmConfiguration> GetRunnableConfigurations()
{
return(_kernel.GetAll <IRunableOrmConfiguration>());
}
/// <inheritdoc />
public virtual IEnumerable <object> GetServices(Type serviceType, string contract = null) =>
string.IsNullOrEmpty(contract)
? _kernel.GetAll(serviceType)
: _kernel.GetAll(serviceType, contract);
public System.Collections.Generic.IEnumerable <object> GetServices(System.Type serviceType)
{
return(kernel.GetAll(serviceType));
}
public IEnumerable <T> GetAll <T>()
{
return(_injectionKernel.GetAll <T>());
}
public override IEnumerable <object> GetServices(Type serviceType)
{
return(System.Linq.Enumerable.Concat(_kernel.GetAll(serviceType), base.GetServices(serviceType)));
}
public IEnumerable <IHandleMessages <T> > GetHandlerInstancesFor <T>()
{
return(kernel.GetAll <IHandleMessages <T> >().ToArray());
}
protected override IEnumerable <object> GetAllInstances(Type service)
{
return(_kernel.GetAll(service));
}
protected override IEnumerable <object> GetAllInstances(Type service)
{
service.ThrowIfNull("service");
return(kernel.GetAll(service));
}
public IEnumerable <object> GetServices(Type serviceType)
{
return(_container.GetAll(serviceType));
}
private IEnumerable <T> GetExportedValues <T>([CanBeNull] string contractName)
{
return(contractName != null ? _kernel.GetAll <T>(contractName) : _kernel.GetAll <T>());
}
private void ConfigureAutoMapper(IKernel container)
{
container.Bind<IAutoMapper>().To<AutoMapperAdapter>().InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<UserEntityToUserDtoTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<UserDtoToUserEntityTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<UserEntityListToUserDtoListTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<CompanyEntityToCompanyDtoTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<CompanyDtoToCompanyEntityTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<PropertyEntityToPropertyDtoTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<PropertyDtoToPropertyEntityTypeMapping>()
.InSingletonScope();
container.Bind<IAutoMapperTypeMapping>()
.To<PropertyEntityListToPropertyDtoListTypeMapping>()
.InSingletonScope();
// Configure the registered mappings
var autoMapperTypeMapper = new AutoMapperTypeMapping();
autoMapperTypeMapper.Configure(container.GetAll<IAutoMapperTypeMapping>());
}
public object GetService(Type serviceType)
{
return(kernel.GetAll(serviceType));
}
public override IEnumerable <object> GetServices(Type serviceType)
{
return(_kernel.GetAll(serviceType).Concat(base.GetServices(serviceType)));
}
public static IEnumerable <object> ObterDependencias(Type serviceType)
{
return(kernel.GetAll(serviceType));
}
public IEnumerable <T> GetServices <T>()
{
return(sourceKernel.GetAll <T>());
}
public static void Start(IKernel kernel)
{
kernel.GetAll <IInitializer>()
.ToList()
.ForEach(initializer => initializer.Init());
}
private static void RegisterHandlers(IKernel kernel)
{
kernel.Bind(
convention =>
convention.From(Assembly.GetAssembly(typeof(CommandBus)))
.SelectAllClasses()
.InNamespaces("WaiterManagement.BLL.Commands.Handlers")
.BindAllInterfaces());
var commandBus = new CommandBus(x => kernel.GetAll<IHandleCommand>().First(y => y.GetType().GetInterfaces()[1].GetGenericArguments()[0] == x));
kernel.Bind<ICommandBus>().ToConstant(commandBus);
kernel.Bind(
convention =>
convention.From(Assembly.GetAssembly(typeof(EventBus)))
.SelectAllClasses()
.InNamespaces("WaiterManagement.BLL.Events.Handlers")
.BindAllInterfaces());
kernel.Bind<IEventBus>().ToMethod(c => new EventBus(x => kernel.GetAll<IHandleEvent>().Where(y => y.GetType().GetInterfaces().Any(z => z.IsGenericType && z.GetGenericArguments()[0] == x))));
}
/// <summary>
/// Returns a list of objects instantiated because their type is compatible with the given type.
/// </summary>
/// <param name="typeToBuild">
/// The type to build.
/// </param>
/// <returns>
/// A list of objects
/// </returns>
public IEnumerable <object> BuildAll(Type typeToBuild)
{
return(kernel.GetAll(typeToBuild));
}
IDropRepoViewModel setupStandardFixture(RoutingState router, IKernel kernel, Action beforeCreateCallback = null)
{
RxApp.ConfigureServiceLocator((t,s) => kernel.Get(t,s), (t,s) => kernel.GetAll(t,s));
kernel.Bind<IDropRepoViewModel>().To<DropRepoViewModel>();
kernel.Get<IScreen>().Router.Returns(router);
if (beforeCreateCallback != null) beforeCreateCallback();
return kernel.Get<IDropRepoViewModel>();
}
public IEnumerable <Object> GetAllInstances(Type t) => _kernel.GetAll(t);
public IEnumerable <object> GetServices(Type serviceType)
{
var services = _kernel.GetAll(serviceType);
return(services);
}
public static IEnumerable <T> GetAll <T>(this HttpContextBase context)
{
IKernel kernel = context.Items[CurrentKernelKey] as IKernel;
return(kernel != null?kernel.GetAll <T>() : Enumerable.Empty <T>());
}
