public override IComponentRegistry Register(Type dependencyType, Type implementationType, Lifestyle lifestyle)
{
Guard.AgainstNull(dependencyType, "dependencyType");
Guard.AgainstNull(implementationType, "implementationType");
base.Register(dependencyType, implementationType, lifestyle);
try
{
switch (lifestyle)
{
case Lifestyle.Transient:
{
_container.Register(dependencyType, implementationType, global::SimpleInjector.Lifestyle.Transient);
break;
}
default:
{
_container.Register(dependencyType, implementationType, global::SimpleInjector.Lifestyle.Singleton);
break;
}
}
}
catch (Exception ex)
{
throw new TypeRegistrationException(ex.Message, ex);
}
return(this);
}
public Container Resolver()
{
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Include;
_container.Register <IServicoAplicacaoVeiculo, ServicoAplicacaoVeiculo>();
_container.Register <IServicoVeiculo, ServicoVeiculo>();
_container.Register <IRepositorioVeiculo, RepositorioVeiculo>();
_container.Verify();
return(_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 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 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");
});
}
/// <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 void Bind(Type service, Func <Type> resolveCallback)
{
_container.Register(service, resolveCallback);
}
/// <inheritdoc/>
public void Bind(Type service, Func <Type> resolveCallback)
{
_container.Register(service, resolveCallback, DefaultLifecycle);
}
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>();
}