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>();
}
