public Subscriber(SimpleInjector.Container container) { // TODO: Complete member initialization ErrorQueue = ConfigurationManager.AppSettings.Get("ErrorQueueNamingConvention"); ErrorExchange = ConfigurationManager.AppSettings.Get("ErrorExchangeNamingConvention"); this.container = container; }
public SimpleInjectorComponentContainer(global::SimpleInjector.Container container) { Guard.AgainstNull(container, "container"); _container = container; this.AttemptRegisterInstance <IComponentRegistry>(this); this.AttemptRegisterInstance <IComponentResolver>(this); }
public void SimpleInjectorResolveSingleInstance() { var container = new global::SimpleInjector.Container(); var registered = new Registered(); container.RegisterSingle(typeof(Registered), registered); var resolver = new SimpleInjectorDependencyResolver(container); var resolved = resolver.GetInstance(typeof(Registered)); Assert.That(resolved, Is.EqualTo(registered)); }
public void Setup() { _iocContainer = CreateContainer <IoC.Container, IoCContainer>(); _iocRootResolver = CreateContainer <Func <IServiceRoot>, IoCContainerByCompositionRoot <IServiceRoot> >(); _autofacContainer = CreateContainer <global::Autofac.IContainer, Autofac>(); _windsorContainerContainer = CreateContainer <WindsorContainer, CastleWindsor>(); _dryIocContainer = CreateContainer <Container, DryIoc>(); _lightInjectContainer = CreateContainer <ServiceContainer, LightInject>(); _ninjectContainer = CreateContainer <StandardKernel, Ninject>(); _unityContainer = CreateContainer <UnityContainer, Unity>(); _microsoftContainer = CreateContainer <ServiceProvider, MicrosoftDependencyInjection>(); _simpleInjectorContainer = CreateContainer <global::SimpleInjector.Container, SimpleInjector>(); }
public RabbitMQIntegrationModule(global::SimpleInjector.Container container) { container.Register <IRabbitBus, RabbitBus>(SimpleInjector.Lifestyle.Transient); var handler = DefineBusHandler(); IBus bus = RabbitHutch.CreateBus(ConfigHelper.ConnectionString, handler, serviceRegister => serviceRegister .Register <IEasyNetQLogger, QueueLogManager>() .Register <IConsumerErrorStrategy, ErrorStrategy>()); container.RegisterSingle <IBus>(bus); this.container = container; }
public RabbitMQIntegrationModule(global::SimpleInjector.Container container) { container.Register<IRabbitBus, RabbitBus>(SimpleInjector.Lifestyle.Transient); var handler = DefineBusHandler(); IBus bus = RabbitHutch.CreateBus(ConfigHelper.ConnectionString, handler, serviceRegister => serviceRegister .Register<IEasyNetQLogger, QueueLogManager>() .Register<IConsumerErrorStrategy, ErrorStrategy>()); container.RegisterSingle<IBus>(bus); this.container = container; }
public void Should_not_throw_when_configured_correctly() { var container = new global::SimpleInjector.Container(); container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle(); container.Options.AutoWirePropertiesImplicitly(); container.Options.AllowOverridingRegistrations = true; var endpointConfig = new EndpointConfiguration("Test"); endpointConfig.UseContainer <SimpleInjectorBuilder>(customization => { customization.UseExistingContainer(container); }); }
public void RegisterServices(global::SimpleInjector.Container container) { container.Register <ISitecoreContext>(() => new SitecoreContext()); container.Register <IMetadataLogic, MetadataLogic>(); container.Register <IScriptsLogic, ScriptsLogic>(); container.Register <ISitecoreSiteLogic, SitecoreSiteLogic>(); container.Register <IDateTimeLogic, DateTimeLogic>(); container.Register <ICanonicalLink, CanonicalLink>(); container.Register <ISettingsLogic, SettingsLogic>(); container.Register <ICacheLogic, CacheLogic>(); //singleton container.Register <ICacheRepositoryLogic, CacheRepositoryLogic>(Lifestyle.Singleton); }
public void Should_throw_argument_exception_if_not_allow_override() { var container = new global::SimpleInjector.Container(); var endpointConfig = new EndpointConfiguration("Test"); try { endpointConfig.UseContainer <SimpleInjectorBuilder>(customization => { customization.UseExistingContainer(container); }); } catch (ArgumentException ex) when(ex.Message == "Invalid container configuration - must set Options.AllowOverridingRegistrations to true") { return; } Assert.Fail("Expected exception not thrown"); }
public Endpoint() { var container = new global::SimpleInjector.Container(); container.Options.AllowOverridingRegistrations = true; container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle(); container.Options.AutoWirePropertiesImplicitly(); container.Register(() => new MyService { Id = "Created outside" }, global::SimpleInjector.Lifestyle.Scoped); EndpointSetup <DefaultServer>(config => { config.UseContainer <SimpleInjectorBuilder>(customization => { customization.UseExistingContainer(container); }); config.SendFailedMessagesTo("error"); }); }
public void Should_throw_argument_exception_if_not_properties_autowired() { var container = new global::SimpleInjector.Container(); container.Options.AllowOverridingRegistrations = true; container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle(); var endpointConfig = new EndpointConfiguration("Test"); try { endpointConfig.UseContainer <SimpleInjectorBuilder>(customization => { customization.UseExistingContainer(container); }); } catch (ArgumentException ex) when(ex.Message == "Invalid container - must set properties to be autowired (by calling Options.AutoWirePropertiesImplicitly())") { return; } Assert.Fail("Expected exception not thrown"); }
public DependenciasAplicacao(Container container) { _container = container; }
/// <summary> /// Register a binding of a type to a callback that can resolve an instance of the type with a given lifecycle /// </summary> /// <param name="container"><see cref="global::SimpleInjector.Container"/> to register into</param> /// <param name="service"><see cref="Type"/> to register</param> /// <param name="resolveCallback"><see cref="Func{T}"/> that resolves the instance</param> /// <param name="lifecycle"><see cref="BindingLifecycle">Lifecycle</see> of the binding</param> public static void Register(this global::SimpleInjector.Container container, Type service, Func <Type, object> resolveCallback, BindingLifecycle lifecycle) { var lifestyle = ResolveLifestyle(lifecycle); container.Register(service, () => resolveCallback, lifestyle); }
/// <summary> /// Register a binding of a type to a callback that can resolve it with a given lifecycle /// </summary> /// <typeparam name="T">Type to register</typeparam> /// <param name="container"><see cref="global::SimpleInjector.Container"/> to register into</param> /// <param name="resolveCallback"><see cref="Func{T}"/> that resolves the type</param> /// <param name="lifecycle"><see cref="BindingLifecycle">Lifecycle</see> of the binding</param> public static void Register <T>(this global::SimpleInjector.Container container, Func <Type> resolveCallback, BindingLifecycle lifecycle) { container.Register(typeof(T), resolveCallback, lifecycle); }
/// <summary> /// Register a binding of a type to a callback that can resolve an instance of the type with a given lifecycle /// </summary> /// <typeparam name="T">Type to register</typeparam> /// <param name="container"><see cref="global::SimpleInjector.Container"/> to register into</param> /// <param name="resolveCallback"><see cref="Func{T}"/> that resolves the type by returning an instance</param> /// <param name="lifecycle"><see cref="BindingLifecycle">Lifecycle</see> of the binding</param> public static void Register <T>(this global::SimpleInjector.Container container, Func <T> resolveCallback, BindingLifecycle lifecycle) { Func <Type> typeResolver = () => { return(resolveCallback.Invoke().GetType()); }; container.Register(typeof(T), typeResolver, lifecycle); }
public Container(global::SimpleInjector.Container container) { _container = container; }
public void SimpleInjectorResolveSingleInstance() { var container = new global::SimpleInjector.Container(); var registered = new Registered(); container.RegisterSingle(typeof(Registered), registered); var resolver = new SimpleInjectorDependencyResolver(container); var resolved = resolver.GetInstance(typeof (Registered)); Assert.That(resolved, Is.EqualTo(registered)); }
public ContainerHolder(global::SimpleInjector.Container container) { ExistingContainer = container; }
/// <summary> /// Use the a pre-configured SimpleInjector contains /// </summary> /// <param name="customizations"></param> /// <param name="container">The existing container to use.</param> public static void UseExistingContainer(this ContainerCustomizations customizations, global::SimpleInjector.Container container) { if (!container.Options.AllowOverridingRegistrations) { throw new ArgumentException("Invalid container configuration - must set Options.AllowOverridingRegistrations to true"); } if (!(container.Options.DefaultScopedLifestyle is AsyncScopedLifestyle)) { throw new ArgumentException("Invalid container configuration - must set DefaultScopedLifestyle to AsyncScopedLifestyle"); } if (!(container.Options.PropertySelectionBehavior is ImplicitPropertyInjectionExtensions.ImplicitPropertyInjectionBehavior)) { throw new ArgumentException("Invalid container - must set properties to be autowired (by calling Options.AutoWirePropertiesImplicitly())"); } customizations.Settings.Set <ContainerHolder>(new ContainerHolder(container)); }
public MessageEmitter(global::SimpleInjector.Container container) { this.container = container; }
static void Test() { var dry = new DryIoc.Container(); dry.Register <IMetricSubmitter, EnrichMetricsDecorator>( setup: new DecoratorSetup(z => { return(z.Parent.ImplementationType == typeof(SingleWorker)); }, order: 0, useDecorateeReuse: false)); dry.Register <IMetricSubmitter, DefaultMetricSubmitter>(Reuse.Singleton); dry.Register <SingleWorker>(Reuse.Singleton); dry.Register <ScopedWorker>(Reuse.Singleton); var worker = dry.Resolve <SingleWorker>(); Console.WriteLine(worker); var worker2 = dry.Resolve <ScopedWorker>(); Console.WriteLine(worker2); var container = new global::SimpleInjector.Container(); container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle(); container.ForConsumer <BConsumer>() .RegisterSingleton <AInterface, BImplementation>(); container.ForConsumer <AConsumer>() .Register <AInterface, AImplementation>(Lifestyle.Singleton); container.RegisterSingleton <AConsumer>(); container.RegisterDecorator( typeof(AInterface), typeof(AInterfaceDecorator), Lifestyle.Singleton, z => { return(true); }); container.RegisterDecorator( typeof(AInterface), typeof(BInterfaceDecorator), Lifestyle.Singleton, z => { return(true); }); container.Register <SingleWorker>(Lifestyle.Singleton); container.Register <ScopedWorker>(Lifestyle.Scoped); container.RegisterDecorator <IMetricSubmitter, EnrichMetricsDecorator>(); container.RegisterConditional <IMetricSubmitter, ProxyMetricSubmitter>( Lifestyle.Singleton, z => z.Consumer.ImplementationType == typeof(SingleWorker)); container.Verify(); container.GetInstance <SingleWorker>(); using (AsyncScopedLifestyle.BeginScope(container)) { container.GetInstance <ScopedWorker>(); } container.GetInstance <AConsumer>(); container.GetInstance <AConsumer>(); container.GetInstance <BConsumer>(); container.GetInstance <BConsumer>(); }