public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (registrationAccessor == null)
{
throw new ArgumentNullException(nameof(registrationAccessor));
}
Type constructedImplementationType;
IEnumerable <Service> services;
if (OpenGenericServiceBinder.TryBindServiceType(service, _registrationData.Services, _activatorData.ImplementationType, out constructedImplementationType, out services))
{
var swt = (IServiceWithType)service;
var fromService = _activatorData.FromService.ChangeType(swt.ServiceType);
return(registrationAccessor(fromService)
.Select(cr => RegistrationBuilder.CreateRegistration(
Guid.NewGuid(),
_registrationData,
new ReflectionActivator(
constructedImplementationType,
_activatorData.ConstructorFinder,
_activatorData.ConstructorSelector,
AddDecoratedComponentParameter(swt.ServiceType, cr, _activatorData.ConfiguredParameters),
_activatorData.ConfiguredProperties),
services)));
}
return(Enumerable.Empty <IComponentRegistration>());
}
private static IRegistrationBuilder <TService, SimpleActivatorData, SingleRegistrationStyle> RegisterDecorator <TDecorationTarget, TService>(
ContainerBuilder builder, Func <IComponentContext, TDecorationTarget, TService> decoratorFactory)
{
Guard.NotNull("builder", builder);
Guard.NotNull("decoratorFactory", decoratorFactory);
var originalKey = Guid.NewGuid();
var registrationBuilder = RegistrationBuilder.ForDelegate((c, p) => decoratorFactory(c, c.ResolveKeyed <TDecorationTarget>(originalKey))).As <TService>();
builder.RegisterCallback(cr =>
{
Guard.NotNull("componentRegistry", cr);
var service = new TypedService(typeof(TService));
var originalRegistrations = cr.RegistrationsFor(service);
// Register original component as keyed
foreach (var originalRegistration in originalRegistrations)
{
cr.Register(RegistrationBuilder.CreateRegistration(
Guid.NewGuid(),
CopyRegistrationData(originalRegistration),
originalRegistration.Activator,
new[] { new KeyedService(originalKey, typeof(TService)) }));
}
// Override default registration with decorator
RegistrationBuilder.RegisterSingleComponent <TService, SimpleActivatorData, SingleRegistrationStyle>(cr, registrationBuilder);
});
return(registrationBuilder);
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
if (registrationAccessor == null)
{
throw new ArgumentNullException("registrationAccessor");
}
Type constructedImplementationType;
IEnumerable <Service> services;
if (OpenGenericServiceBinder.TryBindServiceType(service, _registrationData.Services, _activatorData.ImplementationType, out constructedImplementationType, out services))
{
yield return(RegistrationBuilder.CreateRegistration(
Guid.NewGuid(),
_registrationData,
new ReflectionActivator(
constructedImplementationType,
_activatorData.ConstructorFinder,
_activatorData.ConstructorSelector,
_activatorData.ConfiguredParameters,
_activatorData.ConfiguredProperties),
services));
}
}
private static IComponentRegistration CreateRegistrationForNonHistoryObject <T>(Service providedService)
{
var rb = RegistrationBuilder.ForType(typeof(ValueHistory <T>))
.As(providedService);
return(RegistrationBuilder.CreateRegistration(rb));
}
/// <summary>
/// Retrieve registrations for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor">A function that will return existing registrations for a service.</param>
/// <returns>
/// Registrations providing the service.
/// </returns>
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
var ts = service as TypedService;
if (ts != null && !ts.ServiceType.IsAbstract && ts.ServiceType.IsClass)
{
var rb = RegistrationBuilder.ForType(ts.ServiceType);
return(new[] { RegistrationBuilder.CreateRegistration(rb) });
}
return(Enumerable.Empty <IComponentRegistration>());
}
private static IComponentRegistration CreateRegistrationForHistoryObject <T>(
Service providedService) where T : class, IAmHistoryEnabled
{
var rb = RegistrationBuilder.ForDelegate(
(c, p) =>
{
var timeline = c.Resolve <ITimeline>();
return(new HistoryObjectListHistory <T>(id => timeline.IdToObject <T>(id)));
})
.As(providedService);
return(RegistrationBuilder.CreateRegistration(rb));
}
public static void AsExternalService <TLimit, TActivatorData, TRegistrationStyle>(
this IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> builder)
where TActivatorData : IConcreteActivatorData
where TRegistrationStyle : SingleRegistrationStyle
{
var registration = RegistrationBuilder.CreateRegistration(builder);
var serviceType = (registration.Services.FirstOrDefault() as TypedService)?.ServiceType;
if (serviceType != null)
{
var serviceBinding = new ServiceBindingInfo
{
ServiceType = serviceType,
IsExternal = true
};
builder.SingleInstance();
builder.ExternallyOwned();
builder.WithMetadata(nameof(ServiceBindingInfo), serviceBinding);
}
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service,
Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
var serviceWithType = service as IServiceWithType;
if (serviceWithType != null)
{
object instance;
if (_core.TryResolve(serviceWithType.ServiceType, out instance))
{
var data = new RegistrationData(service)
{
Sharing = InstanceSharing.Shared,
Lifetime = new RootScopeLifetime()
};
yield return
(RegistrationBuilder.CreateRegistration(Guid.NewGuid(), data,
new ProvidedInstanceActivator(instance), new[] { service }));
}
}
}
/// <inheritdoc/>
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <ServiceRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (registrationAccessor == null)
{
throw new ArgumentNullException(nameof(registrationAccessor));
}
if (OpenGenericServiceBinder.TryBindOpenGenericDelegate(service, _registrationData.Services, _activatorData.Factory, out var constructedFactory, out Service[]? services))
{
// Pass the pipeline builder from the original registration to the 'CreateRegistration'.
// So the original registration will contain all of the pipeline stages originally added, plus anything we want to add.
yield return(RegistrationBuilder.CreateRegistration(
Guid.NewGuid(),
_registrationData,
new DelegateActivator(typeof(object), constructedFactory),
_existingPipelineBuilder,
services));
}
}
