public IEnumerable <IComponentRegistration> RegistrationsFor(Service service,
Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
IServiceWithType serviceWithType = service as IServiceWithType;
if (serviceWithType == null || !serviceWithType.ServiceType.IsGenericType)
{
yield break;
}
if (serviceWithType.ServiceType.GetGenericTypeDefinition() != typeof(Func <>))
{
yield break;
}
Type elementType = serviceWithType.ServiceType.GetGenericArguments()[0];
Type fixedFactoryType = typeof(FixedFactory <>).MakeGenericType(elementType);
Service fixedFactoryService = serviceWithType.ChangeType(fixedFactoryType);
MethodInfo getInstanceMethod = typeof(FixedFactory <>).MakeGenericType(elementType).GetMethod("GetInstance");
foreach (IComponentRegistration registration in registrationAccessor(fixedFactoryService))
{
yield return(RegistrationBuilder.ForDelegate(typeof(Func <>).MakeGenericType(elementType), (c, p) =>
{
// /!\ disposal of this object is not managed
Object fixedFactory = c.ResolveComponent(registration, p);
return getInstanceMethod.CreateDelegate(typeof(Func <>)
.MakeGenericType(elementType), fixedFactory);
})
.As(service)
.Targeting(registration)
.CreateRegistration());
}
}
static IComponentRegistration BuildRegistration <TSettings>() where TSettings : ISettings, new()
{
return(RegistrationBuilder
.ForDelegate((c, p) =>
{
int currentSiteId = 0;
ISiteContext storeContext;
if (c.TryResolve <ISiteContext>(out storeContext))
{
var store = storeContext.CurrentSite;
currentSiteId = store.Id;
//uncomment the code below if you want load settings per store only when you have two stores installed.
//var currentSiteId = c.Resolve<ISiteService>().GetAllSites().Count > 1
// c.Resolve<ISiteContext>().CurrentSite.Id : 0;
////although it's better to connect to your database and execute the following SQL:
//DELETE FROM [Setting] WHERE [SiteId] > 0
return c.Resolve <ISettingService>().LoadSetting <TSettings>(currentSiteId);
}
// Unit tests
return new TSettings();
})
.InstancePerRequest()
.CreateRegistration());
}
/// <summary>
/// Registers aggregation decorator (decorator that will broadcast all calls to all decorated instances)
/// for the services of type <typeparamref name="TService" />.
/// </summary>
/// <typeparam name="TService">Type of the decorated services.</typeparam>
/// <param name="builder">Container builder.</param>
/// <param name="decoratorFactory">Factory delegate that can create new instances of the aggregate decorator.</param>
/// <returns>Registration builder to continue the registration.</returns>
public static IRegistrationBuilder <TService, SimpleActivatorData, SingleRegistrationStyle> RegisterAggregationDecorator <TService>(
this ContainerBuilder builder, Func <IComponentContext, IEnumerable <TService>, TService> decoratorFactory)
{
Guard.NotNull("builder", builder);
Guard.NotNull("decoratorFactory", decoratorFactory);
var originalKey = Guid.NewGuid();
var registrationBuilder = RegistrationBuilder.ForDelegate((c, p) => decoratorFactory(c, c.ResolveKeyed <IEnumerable <TService> >(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);
}
/// <summary>
/// Retrieve a registration for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor"></param>
/// <returns>
/// Registrations for the service.
/// </returns>
public IEnumerable <IComponentRegistration> RegistrationsFor
(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (!(service is IServiceWithType typedService) ||
!typedService.ServiceType.IsInterface ||
IsGenericListOrCollectionInterface(typedService.ServiceType) ||
(typedService.ServiceType.IsGenericType && typedService.ServiceType.GetGenericTypeDefinition() == typeof(IPipelineBehavior <,>)) ||
typedService.ServiceType.IsArray ||
typeof(IStartable).IsAssignableFrom(typedService.ServiceType))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var registrations = registrationAccessor(service);
var componentRegistrations = registrations as IComponentRegistration[] ?? registrations.ToArray();
if (componentRegistrations.Any())
{
return(componentRegistrations);
}
var rb = RegistrationBuilder.ForDelegate((c, p) => Substitute.For(new[] { typedService.ServiceType }, null))
.As(service)
.InstancePerLifetimeScope();
return(new[] { rb.CreateRegistration() });
}
/// <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>
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
// There are other registration exists in the container
if (registrationAccessor(service).Any())
{
return(Enumerable.Empty <IComponentRegistration>());
}
var swt = service as IServiceWithType;
if (swt == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
object instance = CMS.Core.Service.ResolveOptional(swt.ServiceType);
if (instance == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
// Register the instance in the container
return(new[] { RegistrationBuilder.ForDelegate(swt.ServiceType, (c, p) => instance).CreateRegistration() });
}
/// <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>
/// <remarks>
/// If the source is queried for service s, and it returns a component that implements both s and s', then it
/// will not be queried again for either s or s'. This means that if the source can return other implementations
/// of s', it should return these, plus the transitive closure of other components implementing their
/// additional services, along with the implementation of s. It is not an error to return components
/// that do not implement <paramref name="service" />.
/// </remarks>
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <ServiceRegistration> > registrationAccessor)
{
var swt = service as IServiceWithType;
if (swt == null || !swt.ServiceType.IsGenericType)
{
yield break;
}
var def = swt.ServiceType.GetGenericTypeDefinition();
if (def != typeof(DbSet <>))
{
yield break;
}
// if you have one `IDBContext` registeration you don't need the
// foreach over the registrationAccessor(dbContextServices)
yield return(RegistrationBuilder.ForDelegate((c, p) =>
{
var dBContext = c.Resolve <TContext>();
var m = dBContext.GetType().GetMethod(nameof(DbContext.Set), new Type[] { });
var method =
m.MakeGenericMethod(swt.ServiceType.GetGenericArguments());
return method.Invoke(dBContext, null);
})
.As(service)
.CreateRegistration());
}
static IComponentRegistration BuildRegistration <TSettings>() where TSettings : ISettings, new()
{
return(RegistrationBuilder
.ForDelegate((c, p) => c.Resolve <IConfigurationProvider <TSettings> >().Settings)
.InstancePerHttpRequest()
.CreateRegistration());
}
/// <summary>
/// Retrieve a registration for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor"></param>
/// <returns>
/// Registrations for the service.
/// </returns>
public IEnumerable <IComponentRegistration> RegistrationsFor
(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
var typedService = service as IServiceWithType;
if (typedService == null ||
!typedService.ServiceType.IsInterface ||
IsGenericListOrCollectionInterface(typedService.ServiceType) ||
typedService.ServiceType.IsArray ||
typeof(IStartable).IsAssignableFrom(typedService.ServiceType))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var rb = RegistrationBuilder.ForDelegate((c, p) => Substitute.For(new[] { typedService.ServiceType }, null))
.As(service)
.InstancePerLifetimeScope();
return(new[] { rb.CreateRegistration() });
}
private static IComponentRegistration BuildRegistration <TSettings>() where TSettings : ISettings, new()
{
return(RegistrationBuilder
.ForDelegate((c, p) => { return c.Resolve <ISettingService>().LoadSetting <TSettings>(); })
.InstancePerLifetimeScope()
.CreateRegistration());
}
/// <summary>
/// Retrieve a registration for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor"></param>
/// <returns>
/// Registrations for the service.
/// </returns>
public IEnumerable <IComponentRegistration> RegistrationsFor
(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
var typedService = service as IServiceWithType;
if (typedService == null ||
!typedService.ServiceType.IsInterface() ||
typedService.ServiceType.IsGenericType() &&
typedService.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable <>) ||
typedService.ServiceType.IsArray ||
typedService.ServiceType.CanBeCastTo <IStartable>())
{
return(Enumerable.Empty <IComponentRegistration>());
}
var rb = RegistrationBuilder.ForDelegate <object>((c, p) => _mockFactory.CreateMock(typedService.ServiceType))
.As(service)
.InstancePerLifetimeScope();
return(new[] { rb.CreateRegistration() });
}
static IComponentRegistration BuildRegistration <TSettings>() where TSettings : ISettings, new()
{
try
{
return(RegistrationBuilder
.ForDelegate((c, p) =>
{
//var currentsiteId = c.Resolve<ISiteContext>().CurrentSite.Id;
var currentsiteId = 1;
//uncomment the code below if you want load settings per site only when you have two sites installed.
//var currentsiteId = c.Resolve<IsiteService>().GetAllsites().Count > 1
// c.Resolve<IsiteContext>().Currentsite.Id : 0;
//although it's better to connect to your database and execute the following SQL:
//DELETE FROM [Setting] WHERE [siteId] > 0
return c.Resolve <ISettingService>().LoadSetting <TSettings>(currentsiteId);
})
.InstancePerLifetimeScope()
.CreateRegistration());
}
catch (Exception ex)
{
return(null);
}
}
public IEnumerable <IComponentRegistration> RegistrationsFor(
Service service,
Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
var swt = service as IServiceWithType;
if (swt == null)
{
yield break;
}
var existingReg = registrationAccessor(service);
if (existingReg.Any())
{
yield break;
}
var reg = RegistrationBuilder.ForDelegate((c, p) =>
{
var createMethod =
typeof(MockFactory).GetMethod("Create", Type.EmptyTypes).MakeGenericMethod(swt.ServiceType);
return(((Mock)createMethod.Invoke(this.MockFactory, null)).Object);
}).As(swt.ServiceType).CreateRegistration();
yield return(reg);
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
IServiceWithType typedService = service as IServiceWithType;
if (typedService == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
if (!(typedService.ServiceType.IsGenericType && typedService.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable <>)))
{
return(Enumerable.Empty <IComponentRegistration>());
}
Type elementType = typedService.ServiceType.GetGenericArguments()[0];
Service elementService = typedService.ChangeType(elementType);
Type collectionType = typeof(List <>).MakeGenericType(elementType);
IComponentRegistration registration = RegistrationBuilder.ForDelegate(collectionType, (c, p) =>
{
IEnumerable <IComponentRegistration> registrations = c.ComponentRegistry.RegistrationsFor(elementService);
IEnumerable <Object> elements = registrations.Select(cr => c.ResolveComponent(cr, p));
// get distinct elements by type
Array array = elements.GroupBy(o => o.GetType()).Select(o => o.First()).ToArray();
Array array2 = Array.CreateInstance(elementType, array.Length);
array.CopyTo(array2, 0);
Object collection = Activator.CreateInstance(collectionType, new Object[] { array2 });
return(collection);
}).As(service)
.CreateRegistration();
return(new IComponentRegistration[] { registration });
}
/// <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 seenRegistrations = new HashSet <IComponentRegistration>();
var seenServices = new HashSet <Service>();
var lastRunServices = new List <Service> {
service
};
while (lastRunServices.Any())
{
var nextService = lastRunServices.First();
lastRunServices.Remove(nextService);
seenServices.Add(nextService);
foreach (var registration in _registry.RegistrationsFor(nextService).Where(r => !r.IsAdapting()))
{
if (seenRegistrations.Contains(registration))
{
continue;
}
seenRegistrations.Add(registration);
lastRunServices.AddRange(registration.Services.Where(s => !seenServices.Contains(s)));
var r = registration;
yield return(RegistrationBuilder.ForDelegate(r.Activator.LimitType, (c, p) => c.ResolveComponent(r, p))
.Targeting(r)
.As(r.Services.ToArray())
.ExternallyOwned()
.CreateRegistration());
}
}
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service,
Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
// there are other registration exists in the container
if (registrationAccessor(service).Any())
{
return(Enumerable.Empty <IComponentRegistration>());
}
var swt = service as IServiceWithType;
if (swt == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
// try to get an instance from the IServiceProvider
var instance = serviceProvider.GetService(swt.ServiceType);
if (instance == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
// register the instance in the container
return(new[]
{
RegistrationBuilder.ForDelegate(swt.ServiceType,
(c, p) => instance)
.CreateRegistration()
});
}
private void RegisterServices(ContainerBuilder builder, IServiceCollection services)
{
ServiceRegistrationActionList actionList = null;
var serviceDescriptor = services.FirstOrDefault(d => d.ServiceType == typeof(ServiceRegistrationActionList));
if (serviceDescriptor != null)
{
actionList = (ServiceRegistrationActionList)serviceDescriptor.ImplementationInstance;
}
if (actionList == null)
{
actionList = new ServiceRegistrationActionList();
services.AddSingleton(actionList);
}
foreach (var service in services)
{
if (service.ImplementationType != null)
{
// Test if the an open generic type is being registered
var serviceTypeInfo = service.ServiceType.GetTypeInfo();
if (serviceTypeInfo.IsGenericTypeDefinition)
{
builder
.RegisterGeneric(service.ImplementationType)
.As(service.ServiceType)
.ConfigureLifecycle(service.Lifetime)
.ConfigureConventions(actionList);
}
else
{
builder
.RegisterType(service.ImplementationType)
.As(service.ServiceType)
.ConfigureLifecycle(service.Lifetime)
.ConfigureConventions(actionList);
}
}
else if (service.ImplementationFactory != null)
{
var registration = RegistrationBuilder.ForDelegate(service.ServiceType, (context, parameters) =>
{
var serviceProvider = context.Resolve <IServiceProvider>();
return(service.ImplementationFactory(serviceProvider));
})
.ConfigureLifecycle(service.Lifetime)
.CreateRegistration();
//TODO: ConfigureAbpConventions ?
builder.RegisterComponent(registration);
}
else
{
builder
.RegisterInstance(service.ImplementationInstance)
.As(service.ServiceType)
.ConfigureLifecycle(service.Lifetime);
}
}
}
static IComponentRegistration CreateMetaRegistration <T>(Service providedService, IComponentRegistration valueRegistration) where T : class
{
var rb = RegistrationBuilder.ForDelegate(
(c, p) => {
var workContextAccessor = c.Resolve <IWorkContextAccessor>();
return(new Work <T>(w => {
var workContext = workContextAccessor.GetContext();
if (workContext == null)
{
return default(T);
}
var workValues = workContext.Resolve <WorkValues <T> >();
T value;
if (!workValues.Values.TryGetValue(w, out value))
{
value = (T)workValues.ComponentContext.ResolveComponent(valueRegistration, p);
workValues.Values[w] = value;
}
return value;
}));
})
.As(providedService)
.Targeting(valueRegistration);
return(rb.CreateRegistration());
}
/// <summary>
/// Helper method to return registrations.
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <returns></returns>
static IComponentRegistration CreateOrderedRegistration <TService>()
{
return(RegistrationBuilder
.ForDelegate((c, ps) => c.ResolveOrdered <TService>(ps))
.ExternallyOwned()
.CreateRegistration());
}
public IEnumerable <IComponentRegistration> RegistrationsFor
(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
var typedService = service as TypedService;
if (typedService == null ||
!typedService.ServiceType.IsInterface ||
typedService.ServiceType.IsGenericType && typedService.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable <>) ||
typedService.ServiceType.IsArray ||
typeof(IStartable).IsAssignableFrom(typedService.ServiceType))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var rb = RegistrationBuilder.ForDelegate((c, p) => CreateMock(c, typedService))
.As(service)
.InstancePerLifetimeScope();
return(new[] { rb.CreateRegistration() });
}
static IComponentRegistration BuildRegistration<TSettings>()
where TSettings : ISettings {
return RegistrationBuilder
.ForDelegate((c, p) =>
c.Resolve<IConfigurationProvider<TSettings>>().Settings)
.CreateRegistration();
}
/// <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)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (registrationAccessor == null)
{
throw new ArgumentNullException(nameof(registrationAccessor));
}
var ts = service as IServiceWithType;
if (ts != null && ts.ServiceType.IsDelegate())
{
var resultType = ts.ServiceType.FunctionReturnType();
var resultTypeService = ts.ChangeType(resultType);
return(registrationAccessor(resultTypeService)
.Select(r =>
{
var factory = new FactoryGenerator(ts.ServiceType, r, ParameterMapping.Adaptive);
var rb = RegistrationBuilder.ForDelegate(ts.ServiceType, factory.GenerateFactory)
.InstancePerLifetimeScope()
.ExternallyOwned()
.As(service)
.Targeting(r);
return rb.CreateRegistration();
}));
}
return(Enumerable.Empty <IComponentRegistration>());
}
IEnumerable<IComponentRegistration> IRegistrationSource.RegistrationsFor(
Service service,
Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor) {
var swt = service as IServiceWithType;
if (swt == null)
yield break;
var st = swt.ServiceType;
if (st.IsGenericType && st.GetGenericTypeDefinition() == typeof(Mock<>)) {
yield return RegistrationBuilder.ForType(st)
.SingleInstance()
.WithParameter("behavior", _behavior)
.CreateRegistration();
}
else if (st.IsInterface) {
if (st.IsGenericType && st.GetGenericTypeDefinition() == typeof(IEnumerable<>)) {
yield break;
}
if (_ignore.Contains(st)) {
yield break;
}
yield return RegistrationBuilder.ForDelegate(
(ctx, p) => {
Trace.WriteLine(string.Format("Mocking {0}", st));
var mt = typeof(Mock<>).MakeGenericType(st);
var m = (Mock)ctx.Resolve(mt);
return m.Object;
})
.As(service)
.SingleInstance()
.CreateRegistration();
}
}
public static IComponentRegistration CreateSingletonRegistration <T>(T instance)
{
return(RegistrationBuilder
.ForDelegate((c, p) => instance)
.SingleInstance()
.CreateRegistration());
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
var serviceWithType = service as IServiceWithType;
if (serviceWithType == null)
{
yield break;
}
var serviceType = serviceWithType.ServiceType;
if (!serviceType.IsInterface || !typeof(IEventHandler).IsAssignableFrom(serviceType) || serviceType == typeof(IEventHandler))
{
yield break;
}
var interfaceProxyType = _proxyBuilder.CreateInterfaceProxyTypeWithoutTarget(
serviceType,
new Type[0],
ProxyGenerationOptions.Default);
var rb = RegistrationBuilder
.ForDelegate((ctx, parameters) => {
var interceptors = new IInterceptor[] { new EventsInterceptor(ctx.Resolve <IEventBus>()) };
var args = new object[] { interceptors, null };
return(Activator.CreateInstance(interfaceProxyType, args));
})
.As(service);
yield return(rb.CreateRegistration());
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
var typedService = service as TypedService;
if (typedService == null ||
typedService.ServiceType.IsGenericType && typedService.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable <>) ||
typedService.ServiceType.IsArray ||
typeof(IStartable).IsAssignableFrom(typedService.ServiceType))
{
yield break;
}
if (typedService.ServiceType == this.ResolvedType)
{
foreach (var reg in concretesSource.RegistrationsFor(service, registrationAccessor))
{
yield return(reg);
}
}
else
{
var rb = RegistrationBuilder.ForDelegate((c, p) => CreateMock(c, typedService))
.As(service)
.InstancePerLifetimeScope();
yield return(rb.CreateRegistration());
}
}
/// <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)
{
if (registrationAccessor == null)
{
throw new ArgumentNullException(nameof(registrationAccessor));
}
var typedService = service as TypedService;
if (typedService == null || typedService.ServiceType == typeof(string))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var typeInfo = typedService.ServiceType.GetTypeInfo();
if (typedService.ServiceType == RelaxedAutoFakeCreator.SUTType ||
(typeInfo.IsClass && typeInfo.IsAbstract) ||
typeInfo.IsInterface ||
(typeInfo.IsGenericType && typedService.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable <>)) ||
typedService.ServiceType.IsArray ||
registrationAccessor(service).Any() ||
!(typeInfo.DeclaredMethods.Any(x => x.IsVirtual) || typeInfo.DeclaredProperties.Any(x =>
x.GetMethod?.IsVirtual != true || x.SetMethod?.IsVirtual != true)))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var rb = RegistrationBuilder.ForDelegate((c, p) => this.CreateFake(typedService))
.As(service)
.InstancePerLifetimeScope();
return(new[] { rb.CreateRegistration() });
}
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");
}
if (_registrationData.Services.Contains(service))
{
return(registrationAccessor(_activatorData.FromService)
.Select(r =>
{
var rb = RegistrationBuilder
.ForDelegate((c, p) => _activatorData.Adapter(c, p, c.ResolveComponent(service, r, Enumerable.Empty <Parameter>())))
.Targeting(r);
rb.RegistrationData.CopyFrom(_registrationData, true);
return rb.CreateRegistration();
}));
}
return(new IComponentRegistration[0]);
}
/// <summary>
/// Retrieves registration for an unregistered service that is to be used by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor">A function that returns existing registrations for a service.</param>
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
// Checks if the container already contains an existing registration for the requested service
if (registrationAccessor(service).Any())
{
return(Enumerable.Empty <IComponentRegistration>());
}
// Checks if the required service carries valid type information
if (!(service is IServiceWithType swt))
{
return(Enumerable.Empty <IComponentRegistration>());
}
// Gets an instance of the requested service using CMS.Core.API
object instance = null;
if (CMS.Core.Service.IsRegistered(swt.ServiceType))
{
instance = CMS.Core.Service.Resolve(swt.ServiceType);
}
if (instance == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
// Registers the service instance in the container
return(new[] { RegistrationBuilder.ForDelegate(swt.ServiceType, (c, p) => instance).CreateRegistration() });
}
/// <summary>
/// Retrieve a registration for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor"></param>
/// <returns>
/// Registrations for the service.
/// </returns>
public IEnumerable <IComponentRegistration> RegistrationsFor
(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
var typedService = service as TypedService;
if (typedService == null ||
!typedService.ServiceType.IsInterface ||
typeof(IEnumerable).IsAssignableFrom(typedService.ServiceType) ||
typeof(IStartable).IsAssignableFrom(typedService.ServiceType))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var rb = RegistrationBuilder.ForDelegate((c, p) =>
{
var specificCreateMethod =
_createMethod.MakeGenericMethod(new[] { typedService.ServiceType });
var mock = (Mock)specificCreateMethod.Invoke(c.Resolve <MockRepository>(), null);
return(mock.Object);
})
.As(service)
.InstancePerLifetimeScope();
return(new[] { rb.CreateRegistration() });
}
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (registrationAccessor(service).Any())
{
return(Enumerable.Empty <IComponentRegistration>());
}
if (!(service is IServiceWithType swt))
{
return(Enumerable.Empty <IComponentRegistration>());
}
object instance = null;
if (CMS.Core.Service.IsRegistered(swt.ServiceType))
{
instance = CMS.Core.Service.Resolve(swt.ServiceType);
}
if (instance == null)
{
return(Enumerable.Empty <IComponentRegistration>());
}
return(new[]
{
RegistrationBuilder.ForDelegate(swt.ServiceType, (c, p) => instance).CreateRegistration()
});
}
