private static void ConfigureContainer() { Container = new Container(); // Basic test first Container.Register<IClient, TestClient>(); // Singletons can be set up using Reuse - demo this by getting an instance, updating value, then resolving a new instance Container.Register<ISingletonClient, SingletonClient>(Reuse.Singleton); // Registering with a primitive type to be passed to constructor Container.Register<IServiceWithParameter, ServiceWithParameter>(Made.Of(() => new ServiceWithParameter(Arg.Index<string>(0)), requestIgnored => "this is the parameter")); // Then registering a complex object instance to be used Container.Register<TestObject>(); var testObj = new TestObject { ObjectName = "Ian", ObjectType = "Person" }; // Register the instance above (into the container) - giving it an Id ("serviceKey") = "obj1" Container.RegisterInstance<TestObject>(testObj, serviceKey: "obj1"); // Register ServiceWithTypeParameter - saying "When you make me a ServiceWithTypeParameter; and a contructor needs a TestObject - use the one with Id "obj1" Container.Register<IServiceWithTypeParameter, ServiceWithTypeParameter>(made: Parameters.Of.Type<TestObject>(serviceKey: "obj1")); // And finally multiple implementations // Registering multiple interface implementations using an enum key Container.Register<IMultipleImplementations, MultipleImplementationOne>(serviceKey: InterfaceKey.FirstKey); Container.Register<IMultipleImplementations, MultipleImplementationTwo>(serviceKey: InterfaceKey.SecondKey); }
public IContainer CreateContainer() { var assemblies = new List <Assembly>() { GetType().Assembly }; var container = new DryIoc.Container(rules => { rules.WithoutThrowOnRegisteringDisposableTransient() .WithAutoConcreteTypeResolution() .With(FactoryMethod.ConstructorWithResolvableArguments) .WithoutThrowOnRegisteringDisposableTransient() .WithFuncAndLazyWithoutRegistration() .WithDefaultIfAlreadyRegistered(IfAlreadyRegistered.Replace); if (Device.RuntimePlatform == Device.iOS) { rules = rules.WithoutFastExpressionCompiler(); } return(rules); }); SetupLogging(container); RegisterPages(container, assemblies); RegisterServices(container, assemblies); RegisterViewModels(container, assemblies); container.Register <IReloadManager, ReloadManager>(); return(container); }
/// <summary> /// Initialisiert den UI Bootloader /// </summary> /// <param name="container"></param> /// <returns></returns> public static Container Init(Container container) { SetupViews(container); SetupViewModels(container); SetupViewCommands(container); return container; }
public void test_lazy_resolve_and_resolutionscope_reuse() { var container = new Container(); container.Register <Component>(Reuse.InResolutionScope); container.Register <CreationContext>(Reuse.InResolutionScope); container.Register <Factory>(Reuse.Transient); var object1 = new object(); var factory1 = container.Resolve <Factory>(); factory1.Parameter = object1; var object2 = new object(); var factory2 = container.Resolve <Factory>(); factory2.Parameter = object2; var component1 = factory1.CreateComponent(); var component2 = factory2.CreateComponent(); Assert.AreSame(component1.Parameter, object1); Assert.AreNotSame(component1.Parameter, component2.Parameter); }
public void ShellPagedViewModel_Markup_Returns_ActualViewModel() { var container = new Container(); var app = new Application(); ZeroApp .On(app) .WithContainer(DryIocZeroContainer.Build(container)) .RegisterShell(() => new FirstShell()) .Start(); var firstPage = container.Resolve <FirstPage>(); var markup = new ShellPagedViewModelMarkup() { ViewModel = typeof(FirstViewModel), Page = firstPage }; var provider = new XamlServiceProvider(); var vmValue = (FirstViewModel)markup.ProvideValue(provider); Assert.AreEqual(typeof(FirstViewModel), vmValue.GetType()); Assert.AreEqual(vmValue, container.Resolve <FirstViewModel>()); }
public async Task Push_And_Prepare_Model(string stringValue) { var container = new Container(); var app = new Application(); ZeroApp .On(app) .WithContainer(DryIocZeroContainer.Build(container)) .RegisterShell(() => new FirstShell()) .Start(); var firstViewModel = container.Resolve <FirstViewModel>(); var secondViewModel = container.Resolve <SecondViewModel>(); var secondViewModelPageBeforePush = secondViewModel.CurrentPage; var secondViewModelPreviousModelBeforePush = secondViewModel.PreviousModel; Assert.IsNull(secondViewModelPageBeforePush); Assert.IsNull(secondViewModelPreviousModelBeforePush); Assert.IsNull(secondViewModel.SecondStringProperty); await firstViewModel.Push <SecondPage>(stringValue); var secondViewModelPageAfterPush = secondViewModel.CurrentPage; var secondViewModelPreviousModelAfterPush = secondViewModel.PreviousModel; Assert.IsNotNull(secondViewModelPageAfterPush); Assert.IsNotNull(secondViewModelPreviousModelAfterPush); Assert.AreEqual(secondViewModelPageAfterPush.GetType(), typeof(SecondPage)); Assert.AreEqual(secondViewModelPreviousModelAfterPush.GetType(), typeof(FirstViewModel)); Assert.AreEqual(firstViewModel, secondViewModel.PreviousModel); Assert.IsNotNull(secondViewModel.SecondStringProperty); Assert.AreEqual(stringValue, secondViewModel.SecondStringProperty); }
public void DryIoc() { var container = new DryIoc.Container(); foreach (var type in _types) { container.Register(type, type); } int length = 0; if (Scenario == ResolveScenario.ResolveOne) { length = 1; } else if (Scenario == ResolveScenario.ResolveHalf) { length = _types.Length / 2; } else if (Scenario == ResolveScenario.ResolveAll) { length = _types.Length; } for (var i = 0; i < length; i++) { container.Resolve(_types[i]); } container.Dispose(); }
public override TestResult DoTest(ITestCase testCase, int testCasesNumber, bool singleton) { var result = new TestResult { Singleton = singleton, TestCasesNumber = testCasesNumber }; var sw = new Stopwatch(); var c = new Container(); if (singleton) { sw.Start(); c = (Container)testCase.SingletonRegister(c); sw.Stop(); } else { sw.Start(); c = (Container)testCase.TransientRegister(c); sw.Stop(); } result.RegisterTime = sw.ElapsedMilliseconds; sw.Reset(); result.ResolveTime = DoResolve(sw, testCase, c, testCasesNumber, singleton); c.Dispose(); return result; }
public DryIocContainerBuilder( IEnumerable <Assembly> pluginAssemblies, IEnumerable <string> pluginPaths, bool dslAspects = false) { this.DslAspects = dslAspects; var container = new DryIoc.Container(rules => rules.With(FactoryMethod.ConstructorWithResolvableArguments)).OpenScopeWithoutContext(); Proxy = new CastleDynamicProxyProvider(); this.RegisterSingleton <IMixinProvider>(Proxy); this.RegisterSingleton <IDynamicProxyProvider>(Proxy); var aopRepository = new AspectRepository(Proxy); this.RegisterSingleton <IAspectRegistrator>(aopRepository); this.RegisterSingleton <IAspectComposer>(aopRepository); this.RegisterSingleton <IInterceptorRegistrator>(aopRepository); Factory = new DryIocObjectFactory(container, aopRepository); this.RegisterSingleton <IObjectFactory>(Factory); this.RegisterSingleton <IServiceProvider>(Factory); Plugins = new PluginsConfiguration { Directories = (pluginPaths ?? new string[0]).ToList(), Assemblies = (pluginAssemblies ?? new Assembly[0]).ToList() }; this.RegisterSingleton(Plugins); this.RegisterType <SystemInitialization>(); this.RegisterType(typeof(PluginRepository <>), InstanceScope.Singleton, true, typeof(IPluginRepository <>)); var types = AssemblyScanner.GetAllTypes(); this.RegisterSingleton <IExtensibilityProvider>(new DryIocMefProvider(Plugins, Proxy, container)); DryIocObjectFactory.RegisterToContainer(container, this); }
public static Container Setup() { var container = new Container(); RegisterConfigurations(container); return container; }
private static void SetupViewCommands(Container container) { container.Register<NameInputViewCommand>(); container.Register<NameAndScoreInputViewCommand>(); container.Register<DifficultyManagementViewCommand>(); container.Register<NameAndLevelInputViewCommand>(); container.Register<LogEntryInputViewCommand>(); }
/// <summary>Adds all modules regs to container as final point.</summary> static void RegisterModules(DryIoc.Container container) { CommonModule.Register(container); DesktopCommonModule.Register(container); ServerModule.Register(container); FileSystemModule.Register(container); UIModule.Register(container); }
/// <summary>Shared through all session, but inner cmp to app scope initialization.</summary> static void RegisterSessionSingletons(DryIoc.Container container) { var tray = (TaskbarIcon)Application.Current.Resources["SysTray"]; container.UseInstance(tray); container.UseInstance(new AppInfo(typeof(App).Assembly)); container.UseInstance(TaskScheduler.FromCurrentSynchronizationContext()); // UI Tasks Scheduler }
public void RegisterDependencies(Container container) { //http context container.RegisterInstance<HttpContextBase>(new HttpContextWrapper(HttpContext.Current) as HttpContextBase, new SingletonReuse()); //cache provider container.Register<ICacheProvider, HttpCacheProvider>(reuse: Reuse.Singleton); // settings register for access across app container.Register<IDatabaseSettings>(made: Made.Of(() => new DatabaseSettings()), reuse: Reuse.Singleton); //data provider : TODO: Use settings to determine the support for other providers container.Register<IDatabaseProvider>(made: Made.Of(() => new SqlServerDatabaseProvider()), reuse: Reuse.Singleton); //database context container.Register<IDatabaseContext>(made: Made.Of(() => DatabaseContextManager.GetDatabaseContext()), reuse: Reuse.Singleton); //and respositories container.Register(typeof(IDataRepository<>), typeof(EntityRepository<>)); var asm = AssemblyLoader.LoadBinDirectoryAssemblies(); //services //to register services, we need to get all types from services assembly and register each of them; var serviceAssembly = asm.First(x => x.FullName.Contains("mobSocial.Services")); var serviceTypes = serviceAssembly.GetTypes(). Where(type => type.IsPublic && // get public types !type.IsAbstract && // which are not interfaces nor abstract type.GetInterfaces().Length != 0);// which implementing some interface(s) container.RegisterMany(serviceTypes, reuse: Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Replace); //we need a trasient reporter service rather than singleton container.Register<IVerboseReporterService, VerboseReporterService>(reuse: Reuse.InResolutionScope, ifAlreadyRegistered:IfAlreadyRegistered.Replace); //settings var allSettingTypes = TypeFinder.ClassesOfType<ISettingGroup>(); foreach (var settingType in allSettingTypes) { var type = settingType; container.RegisterDelegate(type, resolver => { var instance = (ISettingGroup) Activator.CreateInstance(type); resolver.Resolve<ISettingService>().LoadSettings(instance); return instance; }, reuse: Reuse.Singleton); } //and ofcourse the page generator container.Register<IPageGenerator, PageGenerator>(reuse: Reuse.Singleton); //event publishers and consumers container.Register<IEventPublisherService, EventPublisherService>(reuse: Reuse.Singleton); //all consumers which are not interfaces container.RegisterMany(new[] {typeof(IEventConsumer<>)}, serviceTypeCondition: type => !type.IsInterface); }
public static IContainer BootstrapIoCContainer() { var container = new Container(); container.Register<IEVEBootstrap, EVEBootstrap>(); container.Register<IExecuteEVEActions, EveActionExecutor>(); container.Register<IQuickAutopilotLogic, QuickAutopilotLogic>(); return container; }
public DryIocObjectFactory( Container lifetimeScope, IAspectComposer aspects) { Contract.Requires(lifetimeScope != null); Contract.Requires(aspects != null); CurrentScope = lifetimeScope; this.Aspects = aspects; }
public override void Dispose() { // Allow the container and everything it references to be garbage collected. if (this.container == null) { return; } this.container.Dispose(); this.container = null; }
public void container_can_resolve_personlistviewmodel() { var ass = Assembly.GetAssembly(typeof(PersonListViewModel)); var container = new Container(); container.Register(typeof (IRepository<Person>), typeof (TestPersonRepository)); container = container.RegisterViewModels(ass); var personListVm = container.Resolve<IListViewModel<Person>>(); Assert.IsNotNull(personListVm, "PersonListViewModel could not be resolved"); }
private static void RegisterServices(Container container) { container.Register<ICountryService, CountryService>(); container.Register<IAreaService, AreaService>(); container.Register<ISummitGroupService, SummitGroupService>(); container.Register<ISummitService, SummitService>(); container.Register<IRouteService, RouteService>(); container.Register<IVariationService, VariationService>(); container.Register<ILogEntryService, LogEntryService>(); container.Register<IDifficultyLevelScaleService, DifficultyLevelScaleService>(); container.Register<IDifficultyLevelService, DifficultyLevelService>(); }
private static void RegisterDaos(Container container) { container.Register<ICountryDao, CountryDao>(); container.Register<IAreaDao, AreaDao>(); container.Register<ISummitGroupDao, SummitGroupDao>(); container.Register<ISummitDao, SummitDao>(); container.Register<IRoutesDao, RouteDao>(); container.Register<IDifficultyLevelScaleDao, DifficultyLevelScaleDao>(); container.Register<IDifficultyLevelDao, DifficultyLevelDao>(); container.Register<IVariationDao, VariationDao>(); container.Register<ILogEntryDao, LogEntryDao>(); }
internal static void Register(DryIoc.Container container) { container.Register <AppTrayViewModel>(Reuse.Singleton); container.Register <AppTrayView>(Reuse.Singleton); container.Register <ITrayTooltipNotifier, TrayTooltipNotifier>(Reuse.Singleton); //#if DEBUG // container.RegisterInitializer<object>((service, resolver) => // Trace.TraceWarning($"RESOLVED obj: {service.GetType()}")); //#endif // container.Register<ICoreDataConnection, CoreDataConnection>(Reuse.Singleton); }
/// <summary> /// Constructs the service provider around the given context. /// </summary> /// <param name="context">The system context in which this service provider /// will be constructed around.</param> public SystemServiceProvider(ISystemContext context) { if (context == null) throw new ArgumentNullException("context"); SystemContext = context; container = new DryIoc.Container(); container.RegisterInstance<ISystemContext>(context); resolveContexts = new List<IServiceResolveContext>(); }
public static DryIoc.IContainer PrepareDryIoc() { var container = new Container(); container.Register <Parameter1>(Reuse.Transient); container.Register <Parameter2>(Reuse.Singleton); container.Register <Parameter3>(Reuse.Scoped); container.Register <ScopedBlah>(Reuse.Scoped); return(container); }
/// <summary>Builds container and invokes specified 'intializer' against ready container.</summary> internal Container() // (Func<Container, T> with) { _container = new DryIoc.Container(); RegisterAppScopeServices(_container); RegisterSessionSingletons(_container); RegisterModules(_container); //var root = with(_container); //var root = container.Resolve<T>(); //_container.WithNoMoreRegistrationAllowed(); //return (container, root); }
public override void Prepare() { this.container = new Container(); this.RegisterDummies(); this.RegisterStandard(); this.RegisterComplex(); this.RegisterPropertyInjection(); this.RegisterOpenGeneric(); this.RegisterConditional(); this.RegisterMultiple(); }
private static IMediator BuildMediator() { var container = new Container(); container.RegisterDelegate<SingleInstanceFactory>(r => serviceType => r.Resolve(serviceType)); container.RegisterDelegate<MultiInstanceFactory>(r => serviceType => r.ResolveMany(serviceType)); container.RegisterInstance(Console.Out); container.RegisterMany(new[] { typeof(IMediator).GetAssembly(), typeof(Ping).GetAssembly() }, type => type.GetTypeInfo().IsInterface); return container.Resolve<IMediator>(); }
private static void SetupViewModels(Container container) { container.Register<IMainViewModel, MainViewModel>(); container.Register<INameInputViewModel, NameInputViewModel>(); container.Register<IDifficultyLevelScaleManagementViewModel, DifficultyLevelScaleManagementViewModel>(); container.Register<IDifficultyLevelManagementViewModel, DifficultyLevelManagementViewModel>(); container.Register<INameAndScoreInputViewModel, NameAndScoreInputViewModel>(); container.Register<IDifficultyManagementViewModel, DifficultyManagementViewModel>(); container.Register<INameAndLevelInputViewModel, NameAndLevelInputViewModel>(); container.Register<ILogEntryInputViewModel, LogEntryInputViewModel>(); container.Register<ILogItemViewModel, LogItemViewModel>(); container.Register<IVariationItemViewModel, VariationItemViewModel>(); }
private InversionOfControlContainer() { container = new Container(rules => rules.WithoutThrowOnRegisteringDisposableTransient()); container.Register<INewsService, NewsService>(Reuse.Singleton); container.Register<INewsDao, NewsDao>(Reuse.Singleton); container.Register<IProvider, Provider>(Reuse.Singleton); container.Register<IPersonDao, PersonDao>(Reuse.Singleton); container.Register<IPersonService, PersonService>(Reuse.Singleton); container.Register<IUserSevice, UserService>(Reuse.Singleton); container.Register<IUserDao, UserDao>(Reuse.Singleton); container.Register<ICommentService, CommentService>(Reuse.Singleton); container.Register<ICommentDao, CommentDao>(Reuse.Singleton); }
/// <summary> /// Initialisiert den Bootloader /// </summary> /// <param name="container"></param> /// <returns></returns> public static Container Init(Container container) { GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"), "neo4j", "extra"); client.Connect(); container.RegisterInstance(client); RegisterDaos(container); RegisterServices(container); return container; }
public void SetUp() { Xamarin.Forms.Mocks.MockForms.Init(); this._container = new Container(); this._app = new Application(); ZeroApp .On(this._app) .WithContainer(DryIocZeroContainer.Build(this._container)) .RegisterShell(() => new FirstShell()) .Start(); }
public void TransientRegister_Success() { ITestCase testCase = new TestCaseA(); var c = new Container(); c = (Container)testCase.TransientRegister(c); var obj1 = c.Resolve<ITestA>(); var obj2 = c.Resolve<ITestA>(); Assert.AreNotEqual(obj1, obj2); Helper.Check(obj1, false); Helper.Check(obj2, false); }
// This method gets called by the runtime. Use this method to add services to the container. public IServiceProvider ConfigureServices(IServiceCollection services) { services.AddApplicationInsightsTelemetry(Configuration); services.AddMvc(); // DryIOC // http://stackoverflow.com/questions/36179819/dryioc-asp-net-5-web-api var container = new DryIoc.Container().WithDependencyInjectionAdapter(services); container.Register <ICustomerRepository, CustomerRepository>(Reuse.Singleton); var serviceProvider = container.Resolve <IServiceProvider>(); return(serviceProvider); }
public void SingletonRegister_Success() { ITestCase testCase = new TestCaseA(); var c = new Container(); c = (Container)testCase.SingletonRegister(c); var obj1 = c.Resolve<ITestA>(); var obj2 = c.Resolve<ITestA>(); Assert.AreEqual(obj1, obj2); Helper.Check(obj1, true); Helper.Check(obj2, true); }
public IGame BuildGame() { var container = new Container(); new AlphaCivPackage().Load(container); new FixedCities().SetUpCities(() => new DryIocCityBuilder(container)); new ThreeUnitsWithoutActions().SetUpUnits(() => new DryIocUnitBuilder(container)); var game = container.Resolve<IGame>(); game.ContainerName = "DryIoc/AlphaCiv"; return game; }
void Configure(IAppBuilder app_) { var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); var di = new DryIoc.Container(); di.RegisterInstance <IBackStore>(new BackStore(), Reuse.Singleton); di.WithWebApi(config); app_.UseDryIocOwinMiddleware(di); app_.UseWebApi(config); }
private static IContainer InitializeContainer() { var rules = Rules.Default .WithAutoConcreteTypeResolution() .With(Made.Of(FactoryMethod.ConstructorWithResolvableArguments)) .WithoutThrowOnRegisteringDisposableTransient() .WithFuncAndLazyWithoutRegistration() #if __IOS__ .WithoutFastExpressionCompiler() #endif .WithDefaultIfAlreadyRegistered(IfAlreadyRegistered.Replace); var container = new Container(rules); RegisterRequiredServices(container); return(container); }
protected void Application_Start(object sender, EventArgs e) { WebApiConfig.Register(GlobalConfiguration.Configuration); IContainer container = new Container(); container.Register<IProductRepository, FakeProductRepository>(WebReuse.InRequest); container.RegisterDelegate<ILogger>( resolver => new Logger(s => Debug.WriteLine(s)), Reuse.Singleton); container.Register<ProductsController>(WebReuse.InRequest); container.WithWebApi(GlobalConfiguration.Configuration); }
internal static void Register(DryIoc.Container container) { Type getImplType(Request r) => r.Parent.ImplementationType; // https://bitbucket.org/dadhi/dryioc/wiki/ExamplesContextBasedResolution container.Register( made: Made.Of(() => LogManager.GetCurrentClassLogger(Arg.Index <Type>(0)), getImplType), setup: Setup.With(condition: req => req.Parent.ImplementationType != null), reuse: Reuse.Transient); container.UseInstance(new EnvInfo()); container.Register <ISettingsService, SettingsService>(Reuse.Singleton); container.Register(typeof(IShell <>), typeof(CommandPromptShell), Reuse.Singleton); // reg open gen https://bitbucket.org/dadhi/dryioc/wiki/OpenGenerics container.Register <IWebBrowser, WebBrowser>(Reuse.Singleton); }
public void RegisterDependencies(Container container) { container.Register<IClientService, ClientService>(); container.Register<IAppTokenService, AppTokenService>(); container.RegisterDelegate<IDataRepository<OAuthClient>>( resolver => new EntityRepository<OAuthClient>(DatabaseContextManager.GetDatabaseContext<OAuthDbContext>()), ifAlreadyRegistered: IfAlreadyRegistered.Replace); container.RegisterDelegate<IDataRepository<AppToken>>( resolver => new EntityRepository<AppToken>(DatabaseContextManager.GetDatabaseContext<OAuthDbContext>()), ifAlreadyRegistered: IfAlreadyRegistered.Replace); //override authentication service container.Register<IAuthenticationService, OAuthAuthenticationService>( ifAlreadyRegistered: IfAlreadyRegistered.Replace, reuse: Reuse.Singleton); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); WebApiConfig.Register(config); var container = new DryIoc.Container(); // ReplaceControllersIOCLifeCircle(config, container); //dry container.Register <ILixo, Lixo>(Reuse.Transient, ifAlreadyRegistered: IfAlreadyRegistered.Replace); var modelBuilder = new ODataConventionModelBuilder(config); modelBuilder.EnableLowerCamelCase(); config.EnableCaseInsensitive(true); modelBuilder.EntitySet <Person>("People"); var server = new HttpServer(config); config.MapODataServiceRoute( ODataConstants.RouteName, ODataConstants.RoutePrefix, modelBuilder.GetEdmModel(), new DefaultODataBatchHandler(server) ); //app.UseDryIocOwinMiddleware(container); app .UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll) .UseWebApi(server) .UseDryIocWithTransientControllers(container, config) ; }
internal static DryIoc.IContainer Compose() { var c = new DryIoc.Container(); c.Register <DirectoriesViewModel>(Reuse.Singleton); c.Register <SyncsViewModel>(Reuse.Singleton); c.Register <MainViewModel>(Reuse.Singleton); c.Register <IBusyStack, BusyStack>(Reuse.Transient); c.UseInstance(ScarletCommandBuilder.Default); c.UseInstance(ScarletCommandManager.Default); c.UseInstance(ScarletDispatcher.Default); c.UseInstance(ScarletExitService.Default); c.UseInstance(ScarletMessenger.Default); c.UseInstance(ScarletWeakEventManager.Default); return(c); }
static void Main(string[] args) { var container = new DryIoc.Container(); container.Register <IMySuperService, MySuperServiceImpl>(Reuse.Transient); container.Register <IMyWorker, MyWorkerImpl>(); var worker = container.Resolve <IMyWorker>(); worker.Work(); var worker2 = container.Resolve <IMyWorker>(); worker2.Work(); System.Console.ReadLine(); }
static void Main(string[] args) { Container container = new Container(); container.Register<ICalculo, Soma>(); container.Register<ICalculo, Subtracao>(); container.Register<Calculadora>(Reuse.Singleton); Calculadora calculadora = container.Resolve<Calculadora>(); calculadora.EfetuarCalculos(500, 200); IEnumerable<ICalculo> calculos = container.Resolve<IEnumerable<ICalculo>>(); foreach (var calculo in calculos) { var result = calculo.Calcular(100, 50); Console.WriteLine($"Resultado: {result}"); } Console.Read(); }
public void Configuration(IAppBuilder app) { var webApiConfig = new HttpConfiguration(); var hubConfig = new HubConfiguration { EnableJSONP = true, EnableJavaScriptProxies = true }; webApiConfig.MapHttpAttributeRoutes(); webApiConfig.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); webApiConfig.EnableCors( new EnableCorsAttribute("*", "*", "GET, POST, OPTIONS, PUT, DELETE, PATCH") ); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = new WebPhysicalFileSystem(".\\wwwroot") }; var container = new Container() .WithWebApi(webApiConfig) .WithSignalR(Assembly.GetExecutingAssembly()); container.Register<ITest, Test>(); app.Use(new Func<AppFunc, AppFunc>(next => env => Invoke(next, env))) .UseErrorPage(ErrorPageOptions.ShowAll) .UseCors(CorsOptions.AllowAll) .Use(typeof(OwinMiddleWareQueryStringExtractor)) .UseOAuthAuthorizationServer(new OAuthOptions()) .UseJwtBearerAuthentication(new JwtOptions()) .UseAngularServer("/", "/index.html") .UseFileServer(options) .UseWebApi(webApiConfig) .MapSignalR(hubConfig); }
public static IContainer BuildContainer() { var container = new DryIoc.Container(); container.Register <SampleDbContext>(reuse: Reuse.Scoped); container.Register <TraceInterceptor>(reuse: Reuse.Transient); container.Register <TraceInterceptorAsync>(reuse: Reuse.Transient); container.RegisterMany( typeof(ICustomerFindService).Assembly.GetTypes().Where(x => x.IsDependencyComponent()), serviceTypeCondition: t => t.IsComponentInterface(), reuse: Reuse.Scoped, ifAlreadyRegistered: IfAlreadyRegistered.Replace ); container.Intercept <TraceInterceptor>(t => t.IsComponentInterface()); return(container); }
internal static IBus Build(Config configuration) { var logger = configuration.Logger; logger.Debug("Constructing bus..."); _container = _container ?? new Container(); _container.Register(configuration.Logger.GetType(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register(configuration.Serializer.GetType(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register(configuration.Compressor.GetType(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register(configuration.Transport.GetType(), Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.CommandPipeline.GetCommandHandlerTypes(), Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.CommandPipeline.GetCommandTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.CommandPipeline.GetPreHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.CommandPipeline.GetPostHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.CommandPipeline.GetErrorHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.EventPipeline.GetCompetingEventHandlerTypes(), Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.EventPipeline.GetMulticastEventHandlerTypes(), Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.EventPipeline.GetEventTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.EventPipeline.GetPreHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.EventPipeline.GetPostHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.EventPipeline.GetErrorHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetRequestHandlerTypes(), Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetMulticastRequestHandlerTypes(), Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetRequestTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetResponseTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetPreHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetPostHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.RegisterMany(configuration.RequestResponsePipeline.GetErrorHookTypes(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register<IPipeline, CommandPipeline>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register<IPipeline, EventPipeline>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register<IPipeline, RequestResponsePipeline>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); _container.Register<IBus, Bus>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep); return _container.Resolve<IBus>(); }
public Locator() { Container = new Container(); Container.Register<IBitmapFactory, PclBitmapFactory>(Reuse.Singleton); Container.Register<IAppSettingsHelper, AppSettingsHelper>(Reuse.Singleton); Container.Register<IDispatcherHelper, DispatcherHelper>(Reuse.Singleton); Container.Register<INotificationManager, NotificationManager>(Reuse.Singleton); Container.Register<ICredentialHelper, CredentialHelper>(Reuse.Singleton); var factory = new AudioticaFactory(DispatcherHelper, AppSettingsHelper, BitmapFactory); Container.Register<IScrobblerService, ScrobblerService>(Reuse.Singleton); Container.Register<SpotifyWebApi>(Reuse.Singleton); Container.Register<ISpotifyService, SpotifyService>(Reuse.Singleton); Container.RegisterDelegate(r => factory.CreateCollectionSqlService(10), Reuse.Singleton); Container.RegisterDelegate(r => factory.CreatePlayerSqlService(4), Reuse.Singleton, named: "BackgroundSql"); Container.RegisterDelegate(r => factory.CreateCollectionService(SqlService, BgSqlService), Reuse.Singleton); Container.Register<Mp3MatchEngine>(Reuse.Singleton); }
public static void Main(string[] args) { var dryIoc = new DryIoc.Container(); ContainerRegistrar.Register((x, y) => dryIoc.Register(x, y)); dryIoc.Register <ILogger, ConsoleLogger>(); var unity = new UnityContainer(); ContainerRegistrar.Register((x, y) => unity.RegisterType(x, y)); unity.RegisterType <ILogger, ConsoleLogger>(); var structureMap = new StructureMap.Container(c => { ContainerRegistrar.Register((x, y) => c.For(x).Use(y)); c.For <ILogger>().Use <ConsoleLogger>(); }); var autofac = new Autofac.ContainerBuilder(); ContainerRegistrar.Register((x, y) => autofac.RegisterType(x).As(y)); autofac.RegisterType <ILogger>().As <ConsoleLogger>(); }
public void Test_ViewModels_ShellService_And_MessagingCenter_Are_Registered_On_Startup() { var container = new Container(); var app = new Application(); ZeroApp .On(app) .WithContainer(DryIocZeroContainer.Build(container)) .RegisterShell(() => new FirstShell()) .Start(); var firstViewModel = container.Resolve <FirstViewModel>(); var secondViewModel = container.Resolve <SecondViewModel>(); var shellService = container.Resolve <IShellService>(); var messagingCenter = container.Resolve <IMessagingCenter>(); Assert.NotNull(firstViewModel); Assert.NotNull(secondViewModel); Assert.NotNull(shellService); Assert.NotNull(messagingCenter); }
public SimpleObjectBenchmarks() { var serviceContainer = new ServiceContainer(); serviceContainer.Transients.AddType <IUserService, UserService1>(); serviceContainer.Transients.AddType <IUserService, UserService2>(); serviceContainer.Transients.AddType <IUserService, UserService>(); serviceContainer.Transients.AddType(typeof(IRepository <>), typeof(Repository <>)); serviceResolver = serviceContainer.Build(); var serviceCollection = new ServiceCollection(); serviceCollection.AddTransient <IUserService, UserService1>(); serviceCollection.AddTransient <IUserService, UserService2>(); serviceCollection.AddTransient <IUserService, UserService>(); serviceCollection.AddTransient(typeof(IRepository <>), typeof(Repository <>)); serviceProvider = serviceCollection.BuildServiceProvider(); var containerBuilder = new ContainerBuilder(); containerBuilder.RegisterType <UserService1>().As <IUserService>().InstancePerDependency(); containerBuilder.RegisterType <UserService2>().As <IUserService>().InstancePerDependency(); containerBuilder.RegisterGeneric(typeof(Repository <>)).As(typeof(IRepository <>)); containerBuilder.RegisterType <UserService>().As <IUserService>().InstancePerDependency(); autofacContainer = containerBuilder.Build(); zkWebContainer = new ZKWebContainer(); zkWebContainer.Register <IUserService, UserService1>(ReuseType.Transient, null); zkWebContainer.Register <IUserService, UserService2>(ReuseType.Transient, null); zkWebContainer.Register <IUserService, UserService>(ReuseType.Transient, null); zkWebContainer.Register(typeof(IRepository <>), typeof(Repository <>), ReuseType.Transient, null); dryIocContainer = new DryIocContainer(); dryIocContainer.Register <IUserService, UserService1>(); dryIocContainer.Register <IUserService, UserService2>(); dryIocContainer.Register <IUserService, UserService>(); dryIocContainer.Register(typeof(IRepository <>), typeof(Repository <>)); }
public static void RegisterIoC(HttpConfiguration config) { var appCfg = new AppConfiguration(); var di = new DryIoc.Container().WithWebApi(config); var creds = new GraphCredentials { ClientId = appCfg.ClientId, // "5c642f80-ae79-4d3a-a753-5498eeb2e7d0", Key = appCfg.Key, //"6WxvoAUri6JXdEDIdTISz/SfCRZa7NUZCL7nAl4lcoM=", Tenant = appCfg.TenantId //"e58cae89-8f91-4f69-8cce-51abf1d13b44" }; di.Register <IGroupRepository, GroupRepository>(setup: Setup.With(trackDisposableTransient: true)); di.Register <IUserGroupManager, UserGroupManager>(Made.Of(() => new UserGroupManager(creds, Arg.Of <IGroupRepository>()))); di.Register <IAdminGroupManager, AdminGroupManager>(Made.Of(() => new AdminGroupManager(creds, Arg.Of <IGroupRepository>()))); var errors = di.VerifyResolutions(); Debug.Assert(errors.Length == 0); }
public async Task Pop_And_ReversePrepare_Model(string stringValue) { var container = new Container(); var app = new Application(); ZeroApp .On(app) .WithContainer(DryIocZeroContainer.Build(container)) .RegisterShell(() => new FirstShell()) .Start(); var firstViewModel = container.Resolve <FirstViewModel>(); var secondViewModel = container.Resolve <SecondViewModel>(); Assert.AreEqual(firstViewModel.CurrentPage.GetType(), typeof(FirstPage)); Assert.IsNull(secondViewModel.CurrentPage); Assert.AreEqual(firstViewModel.CurrentPage.Navigation.NavigationStack.Count, 1); await firstViewModel.Push <SecondPage>(); Assert.AreEqual(firstViewModel.CurrentPage.Navigation.NavigationStack.Count, 2); Assert.AreEqual(firstViewModel.CurrentPage.GetType(), typeof(FirstPage)); Assert.AreEqual(secondViewModel.CurrentPage.GetType(), typeof(SecondPage)); await secondViewModel.Pop(stringValue); Assert.AreEqual(firstViewModel.CurrentPage.Navigation.NavigationStack.Count, 1); Assert.AreEqual(firstViewModel.CurrentPage.GetType(), typeof(FirstPage)); Assert.AreEqual(secondViewModel.CurrentPage.GetType(), typeof(SecondPage)); Assert.NotNull(firstViewModel.FirstStringProperty); Assert.AreEqual(firstViewModel.FirstStringProperty, stringValue); }
public DryIocContainer() { _Container = new DryIoc.Container(rules => rules.NotNull().WithAutoConcreteTypeResolution()); }
public override void Dispose() { // Allow the container and everything it references to be disposed. this.container.Dispose(); this.container = null; }
public HandlerRegistry(Container container) => _container = container;
private void BuildScopeIfRequired() { if (!ShouldBuildScope) return; lock (sync) { if (!ShouldBuildScope) return; CurrentScope = CurrentScope.OpenScope(); RegisterNew(); FactoryBuilders.Clear(); ShouldBuildScope = false; MyScopes.Push(CurrentScope); } }
/// <summary>App scope initialization services regs. The most outer block, thus creating container builder.</summary> static void RegisterAppScopeServices(DryIoc.Container container) { // todo: implement and use with split into diff scopes: 1) init doesn't need all the stuff, even UI so will be quick }
static public void Main(string[] args) { var _benchmark = new Benchmark(() => new Action(() => new Calculator())); _benchmark.Add("SimpleInjector", () => { var _container = new SimpleInjector.Container(); _container.Register <ICalculator, Calculator>(SimpleInjector.Lifestyle.Transient); return(() => _container.GetInstance <ICalculator>()); }); //TODO : change to test new Puresharp DI recast _benchmark.Add("Puresharp", () => { var _container = new Puresharp.Composition.Container(); _container.Add <ICalculator>(() => new Calculator(), Puresharp.Composition.Lifetime.Volatile); return(() => _container.Enumerable <ICalculator>()); }); //TODO : change to test MEF2 _benchmark.Add("MEF", () => { var _container = new System.Composition.Hosting.ContainerConfiguration().WithAssembly(typeof(ICalculator).Assembly).CreateContainer(); return(() => _container.GetExport <ICalculator>()); }); _benchmark.Add("Castle Windsor", () => { var _container = new WindsorContainer(); _container.Register(Castle.MicroKernel.Registration.Component.For <ICalculator>().ImplementedBy <Calculator>()); return(() => _container.Resolve <ICalculator>()); }); _benchmark.Add("Unity", () => { var _container = new UnityContainer(); _container.RegisterType <ICalculator, Calculator>(); return(() => _container.Resolve <ICalculator>()); }); _benchmark.Add("StuctureMap", () => { var _container = new StructureMap.Container(_Builder => _Builder.For <ICalculator>().Use <Calculator>()); return(() => _container.GetInstance <ICalculator>()); }); _benchmark.Add("DryIoc", () => { var _container = new DryIoc.Container(); _container.Register <ICalculator, Calculator>(); return(() => _container.Resolve <ICalculator>()); }); _benchmark.Add("Autofac", () => { var _builder = new Autofac.ContainerBuilder(); _builder.RegisterType <Calculator>().As <ICalculator>(); var _container = _builder.Build(Autofac.Builder.ContainerBuildOptions.None); return(() => _container.Resolve <ICalculator>()); }); _benchmark.Add("Ninject", () => { var _container = new Ninject.StandardKernel(); _container.Bind <ICalculator>().To <Calculator>(); return(() => _container.Get <ICalculator>()); }); _benchmark.Add("Abioc", () => { var _setup = new Abioc.Registration.RegistrationSetup(); _setup.Register <ICalculator, Calculator>(); var _container = Abioc.ContainerConstruction.Construct(_setup, typeof(ICalculator).Assembly); return(() => _container.GetService <ICalculator>()); }); _benchmark.Add("Grace", () => { var _container = new Grace.DependencyInjection.DependencyInjectionContainer(); _container.Configure(c => c.Export <Calculator>().As <ICalculator>()); return(() => _container.Locate <ICalculator>()); }); _benchmark.Run(Console.WriteLine); }
public ActivatedContainer(Container container) { _container = container; }
private void Dispose(bool disposing) { if (disposing) { lock (this) { container.Dispose(); } } container = null; }