public static void RegisterFakeProviders(this IDependencyRegistrator dependencyRegistrator) { var assembliesProvider = new CustomAssemblySourceProvider(PlatformProvider.Current.GetRootPath(), new[] { Consts.ContractsAssemblyEnding, Consts.FakeAssemblyEnding }); var allAssemblies = assembliesProvider.Assemblies.ToArray(); var contractTypes = allAssemblies.FindContractTypes(); var fakeTypes = allAssemblies.FindFakeTypes(); var contractToFakeMatches = new Dictionary <Type, Type>(); foreach (var type in fakeTypes) { var contractType = contractTypes.FirstOrDefault( t => t.Name == "I" + type.Name.Replace(Consts.FakePrefix, string.Empty)); if (contractType != null) { contractToFakeMatches.Add(contractType, type); } } foreach (var contractToFakeMatch in contractToFakeMatches) { dependencyRegistrator.RegisterSingleton(contractToFakeMatch.Key, contractToFakeMatch.Value); } }
/// <summary> /// Registers the instance of the dependency.v /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="dependencyType">The type of dependency.</param> /// <param name="instance">The instance of dependency.</param> public static IDependencyRegistrator AddInstance(this IDependencyRegistrator dependencyRegistrator, Type dependencyType, object instance) { dependencyRegistrator.RegisterInstance(dependencyType, instance); return(dependencyRegistrator); }
public static IDependencyRegistrator RegisterMvvm(this IDependencyRegistrator service) { service.Register <IDialogManager>(x => new DialogManager()); return(service); }
/// <summary> /// Registers the collection of the dependencies. /// </summary> /// <typeparam name="TDependency">The type of the dependency.</typeparam> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="dependencies">The dependencies.</param> public static IDependencyRegistrator AddCollection <TDependency>( this IDependencyRegistrator dependencyRegistrator, IEnumerable <TDependency> dependencies) where TDependency : class { dependencyRegistrator.RegisterCollection(dependencies); return(dependencyRegistrator); }
/// <summary> /// Registers dependency in a transient lifetime style using fluent API. /// </summary> /// <typeparam name="TDependency">The type of the dependency declaration.</typeparam> /// <typeparam name="TImplementation">The type of the dependency implementation.</typeparam> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="dependencyCreator">Dependency creator delegate.</param> public static IDependencyRegistrator AddTransient <TDependency, TImplementation>( this IDependencyRegistrator dependencyRegistrator, Func <TImplementation> dependencyCreator) where TImplementation : class, TDependency { dependencyRegistrator.RegisterTransient(dependencyCreator); return(dependencyRegistrator); }
/// <summary> /// Registers the collection of the dependencies. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="dependencyType">The type of the dependency.</param> /// <param name="dependencyTypes">The dependency types.</param> public static IDependencyRegistrator AddCollection(this IDependencyRegistrator dependencyRegistrator, Type dependencyType, IEnumerable <Type> dependencyTypes) { dependencyRegistrator.RegisterCollection(dependencyType, dependencyTypes); return(dependencyRegistrator); }
/// <summary> /// Registers dependency in a transient lifetime style using fluent API. /// </summary> /// <typeparam name="TDependency">The type of the dependency.</typeparam> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="dependencyCreator">Dependency creator delegate.</param> public static IDependencyRegistrator AddTransient <TDependency>( this IDependencyRegistrator dependencyRegistrator, Func <TDependency> dependencyCreator) where TDependency : class { dependencyRegistrator.RegisterTransient(dependencyCreator); return(dependencyRegistrator); }
/// <summary> /// Registers dependency as a singleton using fluent API. /// </summary> /// <typeparam name="TDependency">The type of the dependency.</typeparam> /// <param name="dependencyRegistrator">The dependency registrator.</param> public static IDependencyRegistrator AddSingleton <TDependency>( this IDependencyRegistrator dependencyRegistrator) where TDependency : class { dependencyRegistrator.RegisterSingleton <TDependency>(); return(dependencyRegistrator); }
/// <summary> /// Registers the modules into the IoC container. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="contractType">The type of the contract.</param> /// <param name="modules">The collection of modules.</param> public static void RegisterModules( IDependencyRegistrator dependencyRegistrator, Type contractType, IEnumerable <ICompositionModule> modules) { RegisterCollection(dependencyRegistrator, contractType, modules.Select(t => t.GetType())); }
public override void Config(IDependencyRegistrator container, DependencyScope scope = DefaultDependencyScope) { // Unit of Work container.RegisterType <FamilyUnitOfWork, IFamilyUnitOfWork>(scope); // Managers container.RegisterType <FilesManager, IFilesManager>(scope); container.RegisterType <PersonsManager, IPersonsManager>(scope); container.RegisterType <ArticlesManager, IArticlesManager>(scope); container.RegisterType <MaterialsManager, IMaterialsManager>(scope); // Services container.RegisterType <VideoConverter, IVideoConverter>(scope); // Domain Events Handlers container.RegisterType <NotificationsHandlerService, IDomainEventHandler <RegistrationRequestedEvent> >(scope); container.RegisterType <NotificationsHandlerService, IDomainEventHandler <ManagerCreatedEvent> >(scope); container.RegisterType <NotificationsHandlerService, IDomainEventHandler <GuestCreatedEvent> >(scope); container.RegisterType <NotificationsHandlerService, IDomainEventHandler <PasswordRecoveryRequestedEvent> >(scope); container.RegisterType <NotificationsHandlerService, IDomainEventHandler <PasswordChangedEvent> >(scope); container.RegisterType <MaterialModificationService, IDomainEventHandler <MaterialAddedToArticleEvent> >(scope); container.RegisterType <MaterialModificationService, IDomainEventHandler <MaterialDeletedEvent> >(scope); container.RegisterType <MaterialModificationService, IDomainEventHandler <MaterialFileChangedEvent> >(scope); container.RegisterType <MaterialModificationService, IDomainEventHandler <MaterialTransformEvent> >(scope); container.RegisterType <MaterialModificationService, IDomainEventHandler <MaterialInfoChangedEvent> >(scope); container.RegisterType <MaterialModificationService, IDomainEventHandler <MaterialSavedEvent> >(scope); }
public Bootstrapper(IDependencyRegistrator dependencyRegistrator) : base(dependencyRegistrator) { // ReSharper disable once ArrangeThisQualifier this.registratorExtensibilityAspect = new ExtensibilityAspect <IHaveRegistrator>(this); // ReSharper disable once ArrangeThisQualifier UseAspect(this.registratorExtensibilityAspect); }
/// <summary> /// Creates an instance of <see cref="BootstrapperBase"/> /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> public BootstrapperBase(IDependencyRegistrator dependencyRegistrator) { Registrator = dependencyRegistrator; _platformAspect = new PlatformAspect(); _discoveryAspect = new DiscoveryAspect(CompositionOptions); _modularityAspect = new ModularityAspect(_discoveryAspect, CompositionOptions); _extensibilityAspect = new ExtensibilityAspect <BootstrapperBase>(this); }
protected override void ConfigureServices(IDependencyRegistrator registrator) { registrator .RegisterApplication(this) .RegisterView <MainWindow, MainWindowViewModel>() .RegisterMvvm() ; }
/// <summary> /// Registers collection of modules into the IoC container. /// </summary> /// <typeparam name="TModule">The type of the module.</typeparam> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="modules">The collection of modules.</param> public static void RegisterModules <TModule>( IDependencyRegistrator dependencyRegistrator, IEnumerable <ICompositionModule> modules) where TModule : class { var typedModules = modules.OfType <TModule>().ToArray(); dependencyRegistrator.RegisterCollection(typedModules); }
public static IDependencyRegistrator RegisterView <TView, TViewModel>(this IDependencyRegistrator service) where TView : FrameworkElement where TViewModel : class, INotifyPropertyChanged { service.Register <TView>(); service.Register <TViewModel>(); return(service); }
public Bootstrapper(IDependencyRegistrator dependencyRegistrator) : base(dependencyRegistrator) { _thisExtensibilityAspect = new ExtensibilityAspect <Bootstrapper>(this); UseAspect(_thisExtensibilityAspect); _registratorExtensibilityAspect = new ExtensibilityAspect <IHaveRegistrator>(this); UseAspect(_registratorExtensibilityAspect); _discoveryAspect = new DiscoveryAspect(CompositionOptions, GetType()); UseAspect(_discoveryAspect); }
/// <summary> /// Registers types as their abstractions using singleton lifetime style /// The assemblies are inspected using [IDependency]--[Dependency] naming convention /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="contractsAssembly">The assembly which contains the contracts/abstractions</param> /// <param name="implementationsAssembly">The assembly which contains the implementations.</param> /// <returns></returns> public static IDependencyRegistrator RegisterAutomagically( this IDependencyRegistrator dependencyRegistrator, Assembly contractsAssembly, Assembly implementationsAssembly) { return(dependencyRegistrator.RegisterAutomagically( (d, serviceType, implementationType) => d.RegisterSingleton(serviceType, implementationType), contractsAssembly, implementationsAssembly)); }
public FormsApp(IDependencyRegistrator dependencyRegistrator) { Initialize(); _dependencyRegistrator = dependencyRegistrator; //TODO: Move all registrations to modules _dependencyRegistrator.RegisterTransient <ShellViewModel>(); _dependencyRegistrator.RegisterTransient <MainViewModel>(); DisplayRootViewFor <ShellViewModel>(); }
/// <summary> /// Registers the view models. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="assemblies">The assemblies.</param> /// <param name="excludedTypes">The types to be excluded from the registration.</param> public static void RegisterViewModels( this IDependencyRegistrator dependencyRegistrator, IEnumerable <Assembly> assemblies, IEnumerable <Type> excludedTypes) { var viewModelTypes = assemblies .SelectMany(assembly => assembly.ExportedTypes) .Where(type => excludedTypes.Contains(type) == false && type.Name.EndsWith("ViewModel")) .Where(type => type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(INotifyPropertyChanged))); viewModelTypes.Aggregate(dependencyRegistrator, (seed, next) => seed.AddTransient(next, next)); }
/// <summary> /// Registers the collection of types that implement the specified contract /// into the IoC container. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="contractType">The type of the contract.</param> /// <param name="types">The types.</param> public static void RegisterCollection( IDependencyRegistrator dependencyRegistrator, Type contractType, IEnumerable <Type> types) { var typeInfo = contractType.GetTypeInfo(); var serviceTypes = types.Select(t => t.GetTypeInfo()).Where(t => t.IsInterface == false && t.IsAbstract == false && typeInfo.IsAssignableFrom(t)).Select(t => t.AsType()); dependencyRegistrator.RegisterCollection(contractType, serviceTypes); }
/// <summary> /// Registers already constructed instances into the container. /// </summary> /// <param name="registrator">The dependency registrator.</param> /// <param name="instances">The constructed instances collection.</param> /// <param name="withoutDisposalTracking">If it's set to true the container will exclude the instance from the disposal tracking.</param> /// <returns>The <see cref="IStashboxContainer"/> which on this method was called.</returns> public static IStashboxContainer RegisterInstances <TFrom>(this IDependencyRegistrator registrator, IEnumerable <TFrom> instances, bool withoutDisposalTracking = false) where TFrom : class { Shield.EnsureNotNull(instances, nameof(instances)); foreach (var instance in instances) { registrator.RegisterInstance(instance, withoutDisposalTracking: withoutDisposalTracking); } return((IStashboxContainer)registrator); }
public static IDependencyRegistrator RegisterBuilders(this IDependencyRegistrator dependencyRegistrator) { var assembliesProvider = new CustomAssemblySourceProvider(PlatformProvider.Current.GetRootPath(), new[] { Consts.BuildersAssemblyEnding }); var assemblies = assembliesProvider.Assemblies.ToArray(); var buildersTypes = assemblies.FindBuildersTypes(); foreach (var type in buildersTypes) { var instance = BuilderFactory.CreateBuilderInstance(type); dependencyRegistrator.RegisterInstance(type, instance); } return(dependencyRegistrator); }
private static void RegisterTransientDescriptor(IDependencyRegistrator container, ServiceDescriptor descriptor) { if (descriptor.ImplementationType != null) { container.Register(descriptor.ServiceType, descriptor.ImplementationType); } else if (descriptor.ImplementationFactory != null) { container.Register(descriptor.ServiceType, context => context .WithFactory(c => descriptor.ImplementationFactory(c.Resolve <IServiceProvider>()))); } else { container.RegisterInstance(descriptor.ServiceType, descriptor.ImplementationInstance); } }
/// <summary> /// Registers the collection of types that implement the specified contract /// into the dependency registrator. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="types">The types.</param> /// <param name="allowExactMatchOnly"></param> public static IDependencyRegistrator RegisterCollection <TService>( this IDependencyRegistrator dependencyRegistrator, IEnumerable <Type> types, bool allowExactMatchOnly = false) where TService : class { IEnumerable <Type> eligibleTypes; if (allowExactMatchOnly) { var typeInfo = typeof(TService).GetTypeInfo(); eligibleTypes = GetEligibleTypes(types, typeInfo); } else { eligibleTypes = types; } dependencyRegistrator.RegisterCollection <TService>(eligibleTypes); return(dependencyRegistrator); }
/// <summary> /// Registers the collection of types that implement the specified contract /// into the dependency registrator. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="contractType">The type of the contract.</param> /// <param name="types">The types.</param> /// <param name="allowExactMatchOnly"></param> public static IDependencyRegistrator RegisterCollection( IDependencyRegistrator dependencyRegistrator, Type contractType, IEnumerable <Type> types, bool allowExactMatchOnly = false) { IEnumerable <Type> eligibleTypes; if (allowExactMatchOnly) { var typeInfo = contractType.GetTypeInfo(); eligibleTypes = GetEligibleTypes(types, typeInfo); } else { eligibleTypes = types; } dependencyRegistrator.RegisterCollection(contractType, eligibleTypes); return(dependencyRegistrator); }
/// <summary> /// Registers service descriptors into the container. /// </summary> /// <param name="container">The <see cref="IStashboxContainer"/>.</param> /// <param name="services">The service descriptors.</param> public static void RegisterServiceDescriptors(this IDependencyRegistrator container, IEnumerable <ServiceDescriptor> services) { foreach (var descriptor in services) { switch (descriptor.Lifetime) { case ServiceLifetime.Scoped: RegisterScopedDescriptor(container, descriptor); break; case ServiceLifetime.Singleton: RegisterSingletonDescriptor(container, descriptor); break; case ServiceLifetime.Transient: RegisterTransientDescriptor(container, descriptor); break; default: throw new ArgumentOutOfRangeException(nameof(descriptor.Lifetime)); } } }
/// <summary> /// Creates an instance of the <see cref="LogoFXApplication{TRootViewModel}"/> /// </summary> /// <param name="bootstrapper">The app bootstrapper.</param> /// <param name="viewFirst">Use true to enable built-in navigation, false otherwise. The default value is true.</param> public LogoFXApplication( BootstrapperBase bootstrapper, bool viewFirst = true) { Initialize(); bootstrapper .Use(new RegisterCompositionModulesMiddleware <BootstrapperBase>()) .Use(new RegisterRootViewModelMiddleware <BootstrapperBase, TRootViewModel>()) .Initialize(); _dependencyRegistrator = bootstrapper.Registrator; if (viewFirst) { var viewType = ViewLocator.LocateTypeForModelType(typeof(TRootViewModel), null, null); DisplayRootView(viewType); } else { //Default navigation does not work in this case DisplayRootViewFor <TRootViewModel>(); } }
/// <summary> /// Initializes a new instance of <see cref="BuilderRegistrationService"/>. /// </summary> /// <param name="dependencyRegistrator">The dependency registrator.</param> /// <param name="dependencyResolver">The dependency resolver.</param> public BuilderRegistrationService( IDependencyRegistrator dependencyRegistrator, IDependencyResolver dependencyResolver) : base(dependencyRegistrator, dependencyResolver) { }
/// <summary> /// Registers a type with scoped lifetime. /// </summary> /// <typeparam name="TTo">Type that will be returned.</typeparam> /// <param name="registrator">The dependency registrator.</param> /// <param name="name">The name of the registration.</param> /// <returns>The <see cref="IStashboxContainer"/> which on this method was called.</returns> public static IStashboxContainer RegisterScoped <TTo>(this IDependencyRegistrator registrator, object name = null) where TTo : class => registrator.RegisterType <TTo>(context => context.WithName(name).WithScopedLifetime());
/// <summary> /// Registers a type with scoped lifetime. /// </summary> /// <param name="typeFrom">Type that will be requested.</param> /// <param name="typeTo">Type that will be returned.</param> /// <param name="registrator">The dependency registrator.</param> /// <param name="name">The name of the registration.</param> /// <returns>The <see cref="IStashboxContainer"/> which on this method was called.</returns> public static IStashboxContainer RegisterScoped(this IDependencyRegistrator registrator, Type typeFrom, Type typeTo, object name = null) => registrator.RegisterType(typeFrom, typeTo, context => context.WithName(name).WithScopedLifetime());
public abstract void Config(IDependencyRegistrator container, DependencyScope scope = DefaultDependencyScope);