public void WhenInitializedWithInstance_ThatInstanceIsReturnedFromActivateInstance()
{
object instance = new object();
ProvidedInstanceActivator target = new ProvidedInstanceActivator(instance);
var actual = target.ActivateInstance(Factory.EmptyContainer, Factory.NoParameters);
Assert.AreSame(instance, actual);
}
public void ActivatingAProvidedInstanceTwice_RaisesException()
{
object instance = new object();
ProvidedInstanceActivator target =
new ProvidedInstanceActivator(instance);
target.ActivateInstance(Factory.EmptyContainer, Factory.NoParameters);
Assert.Throws <InvalidOperationException>(() =>
target.ActivateInstance(Factory.EmptyContainer, Factory.NoParameters));
}
RegisterInstance <T>(this ContainerBuilder builder, T instance)
where T : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var activator = new ProvidedInstanceActivator(instance);
var rb = new RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>(
new TypedService(typeof(T)),
new SimpleActivatorData(activator),
new SingleRegistrationStyle());
rb.SingleInstance();
rb.RegistrationData.DeferredCallback = builder.RegisterCallback(cr =>
{
if (!(rb.RegistrationData.Lifetime is RootScopeLifetime) ||
rb.RegistrationData.Sharing != InstanceSharing.Shared)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, RegistrationExtensionsResources.InstanceRegistrationsAreSingleInstanceOnly, instance));
}
activator.DisposeInstance = rb.RegistrationData.Ownership == InstanceOwnership.OwnedByLifetimeScope;
// https://github.com/autofac/Autofac/issues/1102
// Single instance registrations with any custom activation phases (i.e. activation handlers) need to be auto-activated,
// so that other behaviour (such as OnRelease) that expects 'normal' object lifetime behaviour works as expected.
if (rb.ResolvePipeline.Middleware.Any(s => s.Phase == PipelinePhase.Activation))
{
var autoStartService = rb.RegistrationData.Services.First();
var activationRegistration = new RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>(
new AutoActivateService(),
new SimpleActivatorData(new DelegateActivator(typeof(T), (c, p) => c.ResolveService(autoStartService))),
new SingleRegistrationStyle());
RegistrationBuilder.RegisterSingleComponent(cr, activationRegistration);
}
RegistrationBuilder.RegisterSingleComponent(cr, rb);
});
return(rb);
}
public void WhenInitializedWithInstance_ThatInstanceIsReturnedFromActivateInstance()
{
object instance = new object();
ProvidedInstanceActivator target = new ProvidedInstanceActivator(instance);
var container = Factory.CreateEmptyContainer();
var invoker = target.GetPipelineInvoker(container.ComponentRegistry);
var actual = invoker(container, Factory.NoParameters);
Assert.Same(instance, actual);
}
public void ActivatingAProvidedInstanceTwice_RaisesException()
{
object instance = new object();
ProvidedInstanceActivator target =
new ProvidedInstanceActivator(instance);
var container = Factory.CreateEmptyContainer();
var invoker = target.GetPipelineInvoker(container.ComponentRegistry);
invoker(container, Factory.NoParameters);
Assert.Throws <InvalidOperationException>(() =>
invoker(container, Factory.NoParameters));
}
public static IRegistrationBuilder <object, SimpleActivatorData, SingleRegistrationStyle> RegisterInstance(IComponentRegistry cr, Type returnType, object instance, string key)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var activator = new ProvidedInstanceActivator(instance);
var instanceType = instance.GetType();
var rb = RegistrationBuilder.ForDelegate(instanceType, ((context, parameters) => instance));
if (returnType != instanceType)
{
if (!string.IsNullOrEmpty(key))
{
rb.Keyed(key, returnType).Named("`1System.Collections.Generic.IEnumerable`1" + returnType.FullName, returnType);
}
else
{
rb.As(returnType).Named("`1System.Collections.Generic.IEnumerable`1" + returnType.FullName, returnType);
}
}
else
{
if (!string.IsNullOrEmpty(key))
{
rb.Keyed(key, instanceType).Named("`1System.Collections.Generic.IEnumerable`1" + instanceType.FullName, instanceType);
}
else
{
rb.As(instanceType).Named("`1System.Collections.Generic.IEnumerable`1" + instanceType.FullName, instanceType);
}
}
rb.SingleInstance();
if (!(rb.RegistrationData.Lifetime is RootScopeLifetime) ||
rb.RegistrationData.Sharing != InstanceSharing.Shared)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "The instance registration `{0}` can support SingleInstance() sharing only", instance));
}
activator.DisposeInstance = rb.RegistrationData.Ownership == InstanceOwnership.OwnedByLifetimeScope;
RegistrationBuilder.RegisterSingleComponent(cr, rb);
return(rb);
}
/// <summary>
/// Installs a proxy factory.
/// </summary>
/// <typeparam name="T">The type of the proxy factory.</typeparam>
/// <returns>
/// A container with an installed proxy factory.
/// </returns>
public override Caliburn.Core.InversionOfControl.IContainer WithProxyFactory <T>()
{
Register(new[] { new Singleton {
Service = typeof(IProxyFactory), Implementation = typeof(T)
} });
var factory = this.GetInstance <IProxyFactory>();
Container.ComponentRegistry.Registered += (s, e) =>
{
var implementation = e.ComponentRegistration.Activator.LimitType;
if (!implementation.ShouldCreateProxy())
{
return;
}
e.ComponentRegistration.Preparing += (sender, args) =>
{
var registration = args.Component as ComponentRegistration;
if (registration != null)
{
var instance = factory.CreateProxy(implementation,
implementation.GetAttributes <IBehavior>(true).ToArray(),
DetermineConstructorArgs(implementation));
var activator = new ProvidedInstanceActivator(instance);
registration.Activator = activator;
}
};
};
return(this);
}
public static IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> RegisterInstance <T>(this ContainerBuilder builder, T instance) where T : class
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
ProvidedInstanceActivator activator = new ProvidedInstanceActivator(instance);
RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> rb = new RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>(new TypedService(typeof(T)), new SimpleActivatorData(activator), new SingleRegistrationStyle());
rb.SingleInstance();
builder.RegisterCallback(delegate(IComponentRegistry cr) {
if (!(rb.RegistrationData.Lifetime is RootScopeLifetime) || (rb.RegistrationData.Sharing != InstanceSharing.Shared))
{
throw new InvalidOperationException(string.Format(RegistrationExtensionsResources.InstanceRegistrationsAreSingleInstanceOnly, instance));
}
activator.DisposeInstance = rb.RegistrationData.Ownership == InstanceOwnership.OwnedByLifetimeScope;
RegistrationBuilder.RegisterSingleComponent <T, SimpleActivatorData, SingleRegistrationStyle>(cr, rb);
});
return(rb);
}
