public void Test_KernelRegister11()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var descriptor = new FromAssemblyDescriptor(context.Assembly, Classes.MyFilter);
var result = new BasedOnDescriptor(new List <Type> {
typeof(AbpDbContext)
}, descriptor, Classes.MyFilter);
descriptor.Criterias.Add(result);
var kernel = new DefaultKernel();
foreach (var type in descriptor.GetTypes(kernel))
{
foreach (var criteria in descriptor.Criterias)
{
if (criteria.TryRegister(type, kernel))
{
break;
}
}
}
}
public void Test_KernelRegister12()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var descriptor = new FromAssemblyDescriptor(context.Assembly, Classes.MyFilter);
var result = new BasedOnDescriptor(new List <Type> {
typeof(AbpDbContext)
}, descriptor, Classes.MyFilter);
descriptor.Criterias.Add(result);
var kernel = new DefaultKernel();
var types = descriptor.GetTypes(kernel).ToList();
foreach (var type in types)
{
foreach (var criteria in descriptor.Criterias)
{
try
{
if (criteria.TryRegister(type, kernel))
{
break;
}
}
catch
{
Console.WriteLine(type.Assembly.FullName + @"---" + type.Name);
throw new NullReferenceException("aaa");
}
}
}
}
private static BasedOnDescriptor ApplyLifestyle(BasedOnDescriptor registration, Lifestyle lifestyle)
{
if (lifestyle.Name == Lifestyle.Singleton.Name)
{
return(registration.LifestyleSingleton());
}
if (lifestyle.Name == Lifestyle.Transient.Name)
{
return(registration.LifestyleTransient());
}
if (lifestyle.Name == Lifestyle.PerWebRequest.Name)
{
return(registration.LifestylePerWebRequest());
}
if (lifestyle.Name == Lifestyle.Unmanaged.Name)
{
return(registration.LifestyleCustom <UnmanagedLifestyleManager>());
}
if (lifestyle.Name == Lifestyle.Default.Name)
{
return(registration.LifestyleSingleton());
}
if (lifestyle.Name == Lifestyle.ProviderDefault.Name)
{
return(registration);
}
throw new ArgumentException(string.Format("Unknown lifestyle : {0}", lifestyle), "lifestyle");
}
public BasedOnDescriptor BasedOn(Type basedOn)
{
BasedOnDescriptor item = new BasedOnDescriptor(basedOn, this, this.additionalFilters);
this.criterias.Add(item);
return(item);
}
public BasedOnDescriptor Where(Predicate <Type> accepted)
{
BasedOnDescriptor item = new BasedOnDescriptor(typeof(object), this, this.additionalFilters).If(accepted);
this.criterias.Add(item);
return(item);
}
/// <summary>
/// Registers the specified type <c>T</c> for all implementation of <paramref name="assembly" />.
/// </summary>
/// <typeparam name="T"> The type to register </typeparam>
/// <param name="assembly"> The assembly. </param>
/// <param name="lifeCycle"> The life cycle. </param>
/// <remarks>
/// Singleton should be the default lifecycle.
/// </remarks>
public void Register <T>(Assembly assembly, LifeCycle lifeCycle)
{
BasedOnDescriptor set = Classes.FromAssembly(assembly).BasedOn <T>().WithServiceAllInterfaces().Unless(cd => cd.IsAbstract);
switch (lifeCycle)
{
case LifeCycle.PerWebRequest:
set.Configure(cd => cd.LifeStyle.Is(LifestyleType.PerWebRequest));
break;
case LifeCycle.Transient:
set.Configure(cd => cd.LifeStyle.Is(LifestyleType.Transient));
break;
case LifeCycle.Thread:
set.Configure(cd => cd.LifeStyle.Is(LifestyleType.Thread));
break;
default:
set.Configure(cd => cd.LifeStyle.Is(LifestyleType.Singleton));
break;
}
this.Container.Register(set);
}
/// <summary>
/// Configures the plugin.
/// </summary>
/// <param name = "basedOnDescriptor">The based on descriptor.</param>
/// <param name = "service">The service.</param>
/// <returns></returns>
public static BasedOnDescriptor ConfigurePlugin(this BasedOnDescriptor basedOnDescriptor, Type service)
{
if (basedOnDescriptor == null)
{
throw new ArgumentNullException("basedOnDescriptor");
}
basedOnDescriptor
.Configure(configurer =>
{
var attributes = configurer.Implementation.GetCustomAttributes(true);
string name = attributes
.OfType <PluginAttribute>()
.Select(controllerAttribute => controllerAttribute.Name)
.FirstOrDefault();
if (name == null)
{
return;
}
configurer.Named(GetPluginName(null, service, name));
});
return(basedOnDescriptor);
}
public static BasedOnDescriptor ApplyLifeStyle(this BasedOnDescriptor lifeStyle, BootstrapperSettings settings)
{
if (settings.Platform == Platform.Web)
{
return(lifeStyle.LifestylePerWebRequest());
}
return(lifeStyle.LifestyleSingleton());
}
public static BasedOnDescriptor DefaultIs(this BasedOnDescriptor extended, Type implementationType)
{
var result = extended.ConfigureIf(
registration => registration.Implementation == implementationType,
registration => registration.IsDefault()
);
return(result);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
BasedOnDescriptor registrations = Castle.MicroKernel.Registration.Classes.FromAssemblyInDirectory(new AssemblyFilter(WindowsServiceSystemCore.ComponentsPath))
.BasedOn <IComponent>()
.WithService.FromInterface()
.LifestyleSingleton();
container.Register(registrations);
}
/// <summary>
/// Configures the plugin.
/// </summary>
/// <param name = "basedOnDescriptor">The based on descriptor.</param>
/// <param name = "lifestyleType">Type of the lifestyle.</param>
/// <param name = "service">The service.</param>
/// <returns></returns>
public static BasedOnDescriptor ConfigurePlugin(this BasedOnDescriptor basedOnDescriptor, LifestyleType lifestyleType,
Type service)
{
if (basedOnDescriptor == null)
{
throw new ArgumentNullException("basedOnDescriptor");
}
return(basedOnDescriptor.ConfigurePlugin(service).ConfigureLifeStyle(lifestyleType));
}
public static BasedOnDescriptor StartIfNecessary(this BasedOnDescriptor descriptor)
{
return(descriptor.Configure(x =>
{
if (x.Implementation.ShouldStartComponent())
{
x.Start();
}
}));
}
public static void RegisterDependency(this IWindsorContainer container, Assembly assembly)
{
BasedOnDescriptor singletonDescriptor = Classes.FromAssembly(assembly).BasedOn <ISingletonDependency>().WithServiceAllInterfaces().LifestyleSingleton();
container.Register(singletonDescriptor);
BasedOnDescriptor transientDescriptor = Classes.FromAssembly(assembly).BasedOn <ITransientDependency>().WithServiceAllInterfaces().LifestyleTransient();
container.Register(transientDescriptor);
}
public static BasedOnDescriptor ConfigureMessageDeferringSelector(this BasedOnDescriptor descriptor, Func <Type, bool> selector)
{
Guard.IsNotNull(selector, "selector");
descriptor
.ConfigureIf(x => selector(x.Implementation),
c => c.Interceptors <MessageDeferringSagaInterceptor>()
);
return(descriptor);
}
/// <summary>
/// If the plugin exists.
/// </summary>
/// <param name = "basedOnDescriptor">The based on descriptor.</param>
/// <returns></returns>
public static BasedOnDescriptor IfPluginExists(this BasedOnDescriptor basedOnDescriptor)
{
if (basedOnDescriptor == null)
{
throw new ArgumentNullException("basedOnDescriptor");
}
basedOnDescriptor.If(type => type.GetCustomAttributes(typeof(PluginAttribute), true).Any());
return(basedOnDescriptor);
}
/// <summary>
/// Configures the life style.
/// </summary>
/// <param name = "basedOnDescriptor">The based on descriptor.</param>
/// <param name = "lifestyleType">Type of the lifestyle.</param>
/// <returns></returns>
public static BasedOnDescriptor ConfigureLifeStyle(this BasedOnDescriptor basedOnDescriptor, LifestyleType lifestyleType)
{
if (basedOnDescriptor == null)
{
throw new ArgumentNullException("basedOnDescriptor");
}
basedOnDescriptor
.Configure(configurer => { configurer.LifeStyle.Is(lifestyleType); });
return(basedOnDescriptor);
}
/// <summary>
/// Configures the plugin with the service full name.
/// </summary>
/// <param name = "basedOnDescriptor">The based on descriptor.</param>
/// <returns></returns>
public static BasedOnDescriptor ConfigurePluginAsServiceType(this BasedOnDescriptor basedOnDescriptor)
{
if (basedOnDescriptor == null)
{
throw new ArgumentNullException("basedOnDescriptor");
}
basedOnDescriptor
.Configure(configurer => { configurer.Named(GetPluginName(null, configurer.ServiceType, configurer.Implementation.FullName)); });
return(basedOnDescriptor);
}
void RegisterAssemblyClasses(IWindsorContainer container)
{
BasedOnDescriptor descriptor =
Classes.FromAssemblyContaining(GetType())
.Pick()
.WithService.DefaultInterfaces()
.LifestyleTransient()
.If(t => !t.Namespace.Contains("Sample"))
.Configure(c => c.Properties(PropertyFilter.IgnoreAll));
container.Register(descriptor);
}
public static BasedOnDescriptor ConfigureSpecial(this BasedOnDescriptor baseOnDescriptor, IIocManager _iIocManager, string ModuleID)
{
return(baseOnDescriptor.ConfigureIf(t => typeof(IFeature).IsAssignableFrom(t.Implementation), t =>
{
t.DependsOn(Castle.MicroKernel.Registration.Dependency.OnValue("Feature", new Lazy <FeatureDescriptor>(
() =>
{
return _iIocManager.Resolve <IExtensionManager>().AvailableFeatures()
.FirstOrDefault(f => f.Id == ModuleID);
})));
}));
}
public static BasedOnDescriptor ConfigureSagaWithCreatedOnHandling(this BasedOnDescriptor descriptor, Func <Type, bool> selector)
{
Guard.IsNotNull(selector, "selector");
descriptor
.ConfigureIf(x => selector(x.Implementation),
c => c.Interceptors <SagaWithCreatedOnInterceptor>()
.Proxy.Hook(r => r.Service <SagaWithCreatedOnHandlerProxyGenerationHook>())
);
return(descriptor);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(Component.For <IActionInvoker>().ImplementedBy <WindsorActionInvoker>().LifeStyle.Transient);
var assemblies = container.Resolve <Assembly[]>();
foreach (var assembly in assemblies)
{
BasedOnDescriptor descriptor = Classes.FromAssembly(assembly).BasedOn <IController>().If(c => c.Name.EndsWith("Controller")).LifestylePerWebRequest();
container.Register(descriptor);
}
ControllerBuilder.Current.SetControllerFactory(new MvcControllerFactory(container));
}
public static BasedOnDescriptor Expose(this BasedOnDescriptor descriptor, Action <Type> expose)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
if (expose == null)
{
throw new ArgumentNullException("expose");
}
return(descriptor.If((Type x) => {
expose(x);
return true;
}));
}
public void Test_KernelRegister7()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var descriptor = new FromAssemblyDescriptor(context.Assembly, Classes.MyFilter);
var result = new BasedOnDescriptor(new List <Type> {
typeof(AbpDbContext)
}, descriptor, Classes.MyFilter);
var kernel = new DefaultKernel();
Assert.AreEqual(result.FromDescriptor, descriptor);
((IRegistration)result).Register(kernel);
}
public void Test_KernelRegister13()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var descriptor = new FromAssemblyDescriptor(context.Assembly, Classes.MyFilter);
var result = new BasedOnDescriptor(new List <Type> {
typeof(AbpDbContext)
}, descriptor, Classes.MyFilter);
descriptor.Criterias.Add(result);
var kernel = new DefaultKernel();
result.TryRegister(typeof(MyDbContext), kernel);
}
/// <summary>
/// Installs any component with any interface in a <see cref="Library" /> and registers the component under all interfaces it implements.
/// </summary>
public void Install([NotNull] IWindsorContainer container, [NotNull] IConfigurationStore store)
{
Fail.IfArgumentNull(container, nameof(container));
Assembly assemblyToScan = this.assembly.OrFail(nameof(this.assembly));
BasedOnDescriptor allClassesWithAnyInterface = Classes
.FromAssembly(assemblyToScan)
.Pick()
.If(this.ShouldRegisterComponent)
.WithService.Select(this.GetComponentInterfaces())
.Configure(this.ConfigureComponent)
;
container.Register(allClassesWithAnyInterface);
}
public void Test_KernelRegister16()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var descriptor = new FromAssemblyDescriptor(context.Assembly, Classes.MyFilter);
var result = new BasedOnDescriptor(new List <Type> {
typeof(AbpDbContext)
}, descriptor, Classes.MyFilter);
descriptor.Criterias.Add(result);
var kernel = new DefaultKernel();
Type[] baseTypes;
var type = typeof(MyDbContext);
Assert.IsTrue(result.Accepts(type, out baseTypes));
Assert.AreEqual(baseTypes.Length, 1);
var defaults = CastleComponentAttribute.GetDefaultsFor(type);
Assert.IsNotNull(defaults);
var serviceTypes = result.WithService.GetServices(type, baseTypes);
Assert.AreEqual(serviceTypes.Count, 0);
Assert.AreEqual(defaults.Services.Length, 1);
serviceTypes = defaults.Services;
Assert.AreEqual(serviceTypes.ElementAt(0), typeof(MyDbContext));
var registration = Component.For(serviceTypes);
registration.ImplementedBy(type);
result.Configuration?.Invoke(registration);
Assert.IsNull(registration.Name);
Assert.IsNull(defaults.Name);
registration.RegisterOptionally();
var token = kernel.OptimizeDependencyResolution();
var services = registration.FilterServices(kernel);
Assert.AreEqual(services.Length, 1);
Assert.AreEqual(services[0], typeof(MyDbContext));
var builder = kernel.ComponentModelBuilder;
var customContributors = registration.GetContributors(services);
var componentModel = builder.BuildModel(customContributors);
token?.Dispose();
}
/// <summary>
/// Installs all MVC controllers form a <see cref="Library" /> in Windsor engine.
/// </summary>
public void Install([NotNull] IWindsorContainer container, [NotNull] IConfigurationStore store)
{
Fail.IfArgumentNull(container, nameof(container));
Fail.IfArgumentNull(store, nameof(store));
Assembly assembly = this.library.GetAssembly();
BasedOnDescriptor allControllers = Classes
.FromAssembly(assembly)
.BasedOn <Controller>()
.WithServiceSelf()
.Configure(c => c.Named(c.Implementation.Name)
.LifestyleTransient()
);
container.Register(allControllers);
}
private static IRegistrar ApplyLifetime(BasedOnDescriptor basedOnDescriptor, ServiceLifetime lifetime)
{
switch (lifetime)
{
case ServiceLifetime.Singleton:
return(basedOnDescriptor.LifestyleSingleton());
case ServiceLifetime.Scoped:
return(basedOnDescriptor.LifestyleScoped());
case ServiceLifetime.Transient:
return(basedOnDescriptor.LifestyleTransient());
default:
throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, null);
}
}
public static BasedOnDescriptor ToWindsorLifeTime(this BasedOnDescriptor container, LifeTime lifeTime)
{
switch (lifeTime)
{
case LifeTime.Singleton:
return(container.LifestyleSingleton());
case LifeTime.PerWebRequest:
return(container.LifestylePerWebRequest());
case LifeTime.PerThread:
return(container.LifestylePerThread());
default:
return(container.LifestyleTransient());
}
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
Action <ComponentRegistration> action = null;
foreach (Assembly assembly in this._scanAssemblies.Distinct <Assembly>())
{
IWindsorContainer windsorContainer = container;
IRegistration[] registrationArray = new IRegistration[1];
BasedOnDescriptor basedOnDescriptor = Classes.FromAssembly(assembly).BasedOn <Task>().Unless(new Predicate <Type>(this._ignoreTasks.Contains <Type>)).Unless(new Predicate <Type>(this._addTasks.Contains <Type>));
Action <ComponentRegistration> action1 = action;
if (action1 == null)
{
Action <ComponentRegistration> action2 = (ComponentRegistration x) => {
string str = x.Implementation.TaskName();
if (container.Kernel.HasComponent(str))
{
throw new TaskWithSameNameAlreadyRegistredException(x.Implementation);
}
x.Named(str);
};
Action <ComponentRegistration> action3 = action2;
action = action2;
action1 = action3;
}
registrationArray[0] = basedOnDescriptor.Configure(action1).WithServiceDefaultInterfaces();
windsorContainer.Register(registrationArray);
}
foreach (Type type in this._addTasks.Except <Type>(this._ignoreTasks).Distinct <Type>())
{
try
{
container.Register(new IRegistration[] { Component.For <ITask>().ImplementedBy(type).Named(type.TaskName()) });
}
catch (ComponentRegistrationException componentRegistrationException)
{
throw new TaskWithSameNameAlreadyRegistredException(type, componentRegistrationException);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceDescriptor"/> class.
/// </summary>
/// <param name="baseOnDescritor">The base on descritor.</param>
public ServiceDescriptor(BasedOnDescriptor baseOnDescritor)
{
_baseOnDescritor = baseOnDescritor;
}
