public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType <IConfiguration, JsonConfiguration>(); container.RegisterType <IConfiguration, JsonConfiguration>("json"); container.RegisterType <IConfiguration, XmlConfiguration>("xml"); container.RegisterSingletonType <IRocketSettingsProvider, RocketSettingsProvider>(); container.RegisterSingletonType <ILogger, ConsoleLogger>("console_logger"); container.RegisterSingletonType <ILogger, ProxyLogger>("proxy_logger", null); container.RegisterSingletonType <IEventManager, EventManager>(); container.RegisterSingletonType <ICommandHandler, DefaultCommandHandler>("default_cmdhandler"); container.RegisterSingletonType <ICommandHandler, ProxyCommandHandler>("proxy_cmdhandler", null); container.RegisterSingletonType <IPluginManager, DllPluginManager>("dll_plugins"); container.RegisterSingletonType <IPluginManager, NuGetPluginManager>("nuget_plugins"); container.RegisterSingletonType <IPluginManager, ProxyPluginManager>("proxy_plugins", null); container.RegisterSingletonType <ICommandProvider, RocketCommandProvider>("rocket_cmdprovider"); container.RegisterSingletonType <ICommandProvider, ProxyCommandProvider>("proxy_cmdprovider", null); container.RegisterSingletonType <IPermissionProvider, ConfigurationPermissionProvider>( "default_permissions"); container.RegisterSingletonType <IPermissionProvider, ConsolePermissionProvider>("console_permissions"); container.RegisterSingletonType <IPermissionProvider, ProxyPermissionProvider>("proxy_permissions", null); container.RegisterType <ITranslationCollection, TranslationCollection>(); container.RegisterSingletonType <IUserManager, ProxyUserManager>(); }
public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType <IConfiguration, YamlConfiguration>("yaml", null); container.RegisterType <IConfiguration, JsonConfiguration>("json"); container.RegisterType <IConfiguration, XmlConfiguration>("xml"); container.RegisterSingletonType <IRocketConfigurationProvider, RocketConfigurationProvider>(); container.RegisterSingletonType <ILogger, ConsoleLogger>("console_logger"); container.RegisterSingletonType <ILogger, LoggerProxy>("proxy_logger", null); container.RegisterSingletonType <IEventBus, EventBus>(); container.RegisterSingletonType <ICommandHandler, DefaultCommandHandler>("default_cmdhandler"); container.RegisterSingletonType <ICommandHandler, CommandHandlerProxy>("proxy_cmdhandler", null); container.RegisterSingletonType <IPluginLoader, DefaultClrPluginLoader>("dll_plugins"); container.RegisterSingletonType <IPluginLoader, NuGetPluginLoader>("nuget_plugins"); container.RegisterSingletonType <IPluginLoader, PluginLoaderProxy>("proxy_plugins", null); container.RegisterSingletonType <ICommandProvider, RocketCommandProvider>("rocket_cmdprovider"); container.RegisterSingletonType <ICommandProvider, CommandProviderProxy>("proxy_cmdprovider", null); var configPermissions = container.Activate <ConfigurationPermissionProvider>(); container.RegisterInstance <IPermissionProvider>(configPermissions, "default_permissions", null); container.RegisterInstance <IPermissionChecker>(configPermissions, "default_permissions"); container.RegisterSingletonType <IPermissionChecker, ConsolePermissionChecker>("console_checker"); container.RegisterSingletonType <IPermissionChecker, PermissionProviderProxy>("proxy_checker", null); container.RegisterType <ITranslationCollection, TranslationCollection>(); container.RegisterSingletonType <IUserManager, UserManagerProxy>(); }
protected virtual void ConfigureContainer(IDependencyContainer container) { container.RegisterType <IBootstrapperEnvironment, BootstrapperEnvironment>(true); container.RegisterType <ApplicationViewModel, ApplicationViewModel>(true); container.RegisterType <IWindowManager, WindowManager>(true); container.RegisterType <IViewModelManager, ViewModelManager>(true); container.RegisterInstance <ILayoutProvider>(CreateLayoutProvider()); }
public static void Instalize() { Container = new DependencyContainer(); Container.RegisterType<CarPerformanceSimulator>().As<ICarPerformanceSimulator>(); Container.RegisterType<RaceFactory>().As<IRaceFactory>(); Container.RegisterType<CarFactory>().As<ICarFactory>(); Container.RegisterType<DistanceCalculator>().As<IDistanceCalculator>(); }
public static IDependencyContainer RegisterFrameWorkTools(this IDependencyContainer container) { container.RegisterType <ICurrentDateTime, CurrentDateTime>(); container.RegisterType <Framework.Contracts.Logging.ILoggerFactory, Framework.Tools.Logging.LoggerFactory>(); container.RegisterType(typeof(Framework.Contracts.Logging.ILogger <>), typeof(Framework.Tools.Logging.Logger <>)); return(container); }
public void Register(IDependencyContainer container, IDependencyResolver resolver) { GameObject obj = new GameObject("Rocket.Rust"); UnityEngine.Object.DontDestroyOnLoad(obj); container.RegisterSingletonInstance <IImplementation>(obj.AddComponent <Rust>()); container.RegisterType <ILogger, UnityLogger>(); container.RegisterType <IPlayerManager, RustPlayerManager>(); }
public void RegisterType_SuccessfullyRegistersType() { var lifecycle = Lifecycle.SingletonPerApplication; _container.RegisterType <IDependencyContainer, DependencyContainer>(lifecycle); _unityContainer .Received(1) .RegisterType <IDependencyContainer, DependencyContainer>( Arg.Any <ContainerControlledLifetimeManager>() ); }
public IDependencyContainer RegisterTypes(IDependencyContainer container) => container .RegisterType <IGuidWrapper, GuidWrapper>(Lifecycle.SingletonPerApplication) .RegisterType <IDateTimeWrapper, DateTimeWrapper>(Lifecycle.SingletonPerApplication) .RegisterType <IItemObtainingService, ItemObtainingService>(Lifecycle.SingletonPerRequest) .RegisterType <IItemCreatingService, ItemCreatingService>(Lifecycle.SingletonPerRequest) .RegisterType <IItemUpdatingService, ItemUpdatingService>(Lifecycle.SingletonPerRequest);
protected void SetupDependencyContainer(FeatureContext context) { // register additional or swapped strategies foreach (var readerKeyValuePair in context.AdditionalStrategies) { var strategyType = readerKeyValuePair.Key; var strategyReaderType = readerKeyValuePair.Value; if (_defaultImplementations.Keys.Contains(strategyType)) { // swap already registered strategy _defaultImplementations[strategyType] = strategyReaderType; } else { _defaultImplementations.Add(strategyType, strategyReaderType); } // TODO: review this if (!strategyReaderType.IsInterface) { // we can create implementation only for concrete types // if registered reader is interface - most probably it's registered in via IoC registry already _container.RegisterType(strategyReaderType, strategyReaderType); } } }
internal static void RegisterApiDependencies(Func <IRouteOptions> getRouteOptions, IDependencyContainer container) => container .RegisterType(getRouteOptions, LifetimeTypes.PerApplicationSingleton) .RegisterType <IResolver>(() => container, LifetimeTypes.PerApplicationSingleton) .RegisterDependency <RepositoryTypesBootstrapper>() .RegisterDependency <ApiServicesBootstrapper>() .RegisterDependency <ServicesTypesBootstrapper>();
public void Initialize(IDependencyContainer container) { container .RegisterType<IMethods,Managercs>() .RegisterType<IRedisConnectorFactory, RedisConnectorFactory>() ; }
public static IDependencyContainer RegisterTypesByName(this IDependencyContainer container, Func <string, bool> checkname, params Assembly[] assemblies) { foreach (var assembly in assemblies) { foreach (var type in assembly.GetTypes().Where(t => t.IsClass && !t.IsAbstract)) { if (checkname(type.Name)) { container.RegisterType(type, type); } } } return(container); }
/// <summary> /// Registers public and internal types of the given assemblies with the unity container. This is necessary /// to workaround the internalsvisibleto hacks in the code base. /// </summary> /// <param name="container"></param> /// <param name="assemblies">List of assemblies in which all types should be registered with their interfaces. /// This includes internal types. </param> /// <returns>This instance.</returns> public static IDependencyContainer RegisterTypesIncludingInternals(this IDependencyContainer container, params Assembly[] assemblies) { foreach (var assembly in assemblies) { foreach (var type in assembly.GetTypes().Where(t => t.IsClass && !t.IsAbstract)) { string interfacename = "I" + type.Name; var interfacetype = type.GetInterface(interfacename); if (interfacetype != null) { container.RegisterType(interfacetype, type); } } } return(container); }
public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType <IEntityFrameworkDatabaseProvider, InMemoryDatabaseProvider> ("InMemory"); }
/// <summary> /// Registers a type for the given interface. /// </summary> /// <returns>This instance.</returns> public static IDependencyContainer RegisterType <TType>(this IDependencyContainer container) { container.RegisterType(typeof(TType), typeof(TType)); return(container); }
/// <summary> /// Registers a type for the given interface. /// </summary> /// <typeparam name="TInterface">Interface that can be later resolved.</typeparam> /// <typeparam name="TType">Type that implements interface. On Resolve<TInterface>() calls a new instance is returned every time.</typeparam> /// <returns>This instance.</returns> public static IDependencyContainer RegisterType <TInterface, TType>(this IDependencyContainer container) where TType : TInterface { container.RegisterType(typeof(TInterface), typeof(TType)); return(container); }
public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType(typeof(IStateMachineBuilder <, ,>), typeof(StateMachineBuilder <, ,>)); LoadModuleConfig(container); }
public static IDependencyContainer AddDependencies(this IDependencyContainer container) { container.RegisterType <IMappingService, MappingService>(); container.RegisterType <IConfig, DeveloperConfig>(); //container.RegisterType<IConfig, Config>(); container.RegisterSingleton <ILogger, Logger>(); container.RegisterType <IExecutionTimerLogger, ExecutionTimerLogger>(); container.RegisterType <IDependencyContainer, DependencyContainer>(); container.RegisterType <IHost, Host>(); container.RegisterType <IAuthenticationManager, AuthenticationManager>(); container.RegisterType(typeof(IService <>), typeof(BaseService <>)); container.RegisterType <IUserService, UserService>(); container.RegisterType <ICryptographyService, CryptographyService>(); container.RegisterType <ICarService, CarService>(); container.RegisterType <IUserRepository, UserRepository>(); container.RegisterType <ICarRepository, CarRepository>(); var types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetExportedTypes()) .Where(t => !t.IsAbstract && t.IsClass && t.GetInterfaces() .Any(c => c.IsGenericType && typeof(IRepository <>) .IsAssignableFrom(c.GetGenericTypeDefinition()))); foreach (var type in types) { var inheritedFrom = type.GetInterfaces() .First(x => x.IsGenericType && typeof(IRepository <>).IsAssignableFrom(x.GetGenericTypeDefinition())); container.RegisterType(inheritedFrom, type); } container.RegisterType <IValidator, Validator>(); container.RegisterType <ICommandUser, CommandUser>(); container.RegisterType <IParser, Parser>(); container.RegisterType <IModelBinder, DefaultModelBinder>(); var commandTypes = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetExportedTypes()) .Where(x => typeof(ICommand).IsAssignableFrom(x) && !x.IsAbstract && x.IsClass && x.IsDefined(typeof(CommandRouteAttribute))); foreach (var type in commandTypes) { var attributeValue = type.GetCustomAttributesData() .First(c => c.AttributeType == typeof(CommandRouteAttribute)) .ConstructorArguments .Select(z => z.Value) .First() .ToString(); container.RegisterType(typeof(ICommand), type, attributeValue); } return(container); }
/// <summary> /// Registers a mapping between two specified types to the dependency container. /// </summary> public static void RegisterType <T, TU>(this IDependencyContainer container) { container.RegisterType(typeof(T), typeof(TU)); }
public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType <IEntityFrameworkConnectionDescriptor, EntityFrameworkConnectionDescriptor>(); container.RegisterSingletonType <IEntityFrameworkService, EntityFrameworkService>(); }
public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType <IEntityFrameworkDatabaseProvider, MySqlDatabaseProvider> ("MySQL"); }
public static IDependencyContainer RegisterType <TFrom, TTo>(this IDependencyContainer container) where TTo : TFrom { container.RegisterType(typeof(TFrom), typeof(TTo)); return(container); }
public static IDependencyContainer RegisterType <TFrom, TTo>(this IDependencyContainer container, string key, bool singleton = false) { return(container.RegisterType(typeof(TFrom), typeof(TTo), key, singleton)); }
public IDependencyContainer RegisterTypes(IDependencyContainer container) => container.RegisterType <IItemRepository, ItemRepository>(Lifecycle.SingletonPerApplication);
public IDependencyContainer RegisterTypes(IDependencyContainer container) => container .RegisterType(CurrentHttpRequestMessage, Lifecycle.SingletonPerRequest) .RegisterType <IConnectionStringWrapper, ConnectionStringWrapper>(Lifecycle.SingletonPerApplication) .RegisterType <IUrlService, UrlService>(Lifecycle.SingletonPerRequest);
public void Register(IDependencyContainer container, IDependencyResolver resolver) { container.RegisterType <IEntityFrameworkDatabaseProvider, SqlServerCompactDatabaseProvider> ("SqlServerCompact", "SqlServerCE"); }