public void Cant_have_two_instances_of_any_facility_type()
{
kernel.AddFacility <StartableFacility>();
var exception = Assert.Throws <ArgumentException>(() => kernel.AddFacility <StartableFacility>());
Assert.AreEqual(
"Facility of type 'StartableFacility' has already been registered with the container. Only one facility of a given type can exist in the container.",
exception.Message);
}
/// <summary>
/// Executes task.
/// </summary>
/// <param name="application">The application.</param>
/// <param name="kernel">IoC container.</param>
public void Execute(IApplication application, IKernel kernel)
{
var facilityConfig = GetFacilityConfig(application);
kernel.ConfigurationStore.AddFacilityConfiguration("nhibernate.facility", facilityConfig);
kernel.AddFacility("nhibernate.facility", new NHibernateFacility(new NHibernateConfigurator(application, kernel)));
}
/// <summary>
/// Registers the facility to the container
/// </summary>
/// <param name="kernel"></param>
public void Register(IKernel kernel)
{
var facilityConfiguration = configuration.Build();
string facilityId = facilityConfiguration.Attributes["id"];
kernel.ConfigurationStore.AddFacilityConfiguration(facilityId, facilityConfiguration);
kernel.AddFacility<NHibernateFacility>(facilityId);
}
/// <summary>
/// Executes task.
/// </summary>
/// <param name="application">The application.</param>
/// <param name="kernel">IoC container.</param>
public void Execute(IApplication application, IKernel kernel)
{
var facilityConfig = GetFacilityConfig(application);
kernel.ConfigurationStore.AddFacilityConfiguration("nhibernate.facility", facilityConfig);
kernel.AddFacility("nhibernate.facility", new NHibernateFacility(new NHibernateConfigurator(application, kernel)));
}
public void Setup()
{
kernel = new DefaultKernel();
kernel.AddFacility <MethodValidatorFacility>();
kernel.Register(Component.For <IOrderService>().ImplementedBy <OrderService>());
//Add the WindsorContainer so we have an IProxyFactory instance
WindsorContainer container = new WindsorContainer(kernel, new DefaultComponentInstaller());
}
public void Setup()
{
kernel = new DefaultKernel();
kernel.AddFacility<MethodValidatorFacility>();
kernel.Register(Component.For<IOrderService>().ImplementedBy<OrderService>());
//Add the WindsorContainer so we have an IProxyFactory instance
WindsorContainer container = new WindsorContainer(kernel, new DefaultComponentInstaller());
}
/// <summary>
/// Initializes a new instance of the <see cref="CastleAspectContainer"/> class.
/// </summary>
/// <param name="container">The container.</param>
public CastleAspectContainer(IKernel container)
{
Proxy = new MasterProxy {Container = new WindsorServiceLocatorAdapter(container)};
_kernel = container;
_kernel.Register(Component.For(GetType()).Named("CastleAspectContainer").Instance(this));
_kernel.Register(Component.For(Proxy.GetType())/*.Named("MasterProxy")*/.Instance(Proxy));
_kernel.AddFacility<CastleAspectFacility>();
_kernel.Register(Component.For<PseudoInterceptor>());
}
/// <summary>
/// Initializes a new instance of the <see cref="CastleAspectContainer"/> class.
/// </summary>
/// <param name="container">The container.</param>
public CastleAspectContainer(IKernel container)
{
Proxy = new MasterProxy();
_kernel = container;
_kernel.Register(Component.For(this.GetType()).Named("CastleAspectContainer").Instance(this));
_kernel.Register(Component.For(Proxy.GetType()).Named("MasterProxy").Instance(Proxy));
_kernel.AddFacility<CastleAspectFacility>();
_kernel.Register(Component.For<PseudoInterceptor>());
}
/// <inheritdoc />
public override void BindAspects(IComponentsStore settings)
{
_kernel.Register(Component.For <IComponentsStore>().Instance(settings));
_kernel.Register(
Component.For(typeof(WeavedInterceptor <,>))
.ImplementedBy(typeof(WeavedInterceptor <,>)));
_kernel.AddFacility(new WindsorAspectFacility(settings));
}
/// <summary>
/// Initializes a new instance of the <see cref="CastleAspectContainer"/> class.
/// </summary>
/// <param name="container">The container.</param>
public CastleAspectContainer(IKernel container)
{
Proxy = new MasterProxy {
Container = new WindsorServiceLocatorAdapter(container)
};
_kernel = container;
_kernel.Register(Component.For(GetType()).Named("CastleAspectContainer").Instance(this));
_kernel.Register(Component.For(Proxy.GetType()) /*.Named("MasterProxy")*/.Instance(Proxy));
_kernel.AddFacility <CastleAspectFacility>();
_kernel.Register(Component.For <PseudoInterceptor>());
}
public virtual void Register(IKernel kernel)
{
kernel.AddFacility<TypedFactoryFacility>();
kernel.Register(Component.For<IViewModelFactory>().AsFactory());
kernel.Register(Component.For<IDialogFactory>().AsFactory());
kernel.Register(AllTypes.FromAssemblyContaining<ViewModelRegistration>()
.Where(t => t.Namespace == "Rhino.Licensing.AdminTool.Factories")
.WithService.FirstInterfaceOnClass());
}
public static IKernel AddAspectCoreFacility(this IKernel Kernel, IAspectConfiguration configuration, Action <IAspectConfiguration> configure = null)
{
if (Kernel == null)
{
throw new ArgumentNullException(nameof(Kernel));
}
var config = configuration ?? new AspectConfiguration();
configure?.Invoke(config);
Kernel.AddFacility(new AspectCoreFacility(config));
return(Kernel);
}
public virtual void Register(IKernel kernel)
{
kernel.AddFacility <TypedFactoryFacility>();
kernel.Register(Component.For <IViewModelFactory>().AsFactory());
kernel.Register(Component.For <IDialogFactory>().AsFactory());
kernel.Register(AllTypes.FromAssemblyContaining <ViewModelRegistration>()
.Where(t => t.Namespace == "Rhino.Licensing.AdminTool.Factories")
.WithService.FirstInterfaceOnClass());
}
public void UsingAttributes()
{
String xml =
"<configuration>" +
" <facilities>"+
" <facility id=\"batchregistration\">"+
" <assemblyBatch name=\"Castle.Facilities.BatchRegistration.Tests\" useAttributes=\"true\" />"+
" </facility>"+
" </facilities>"+
"</configuration>";
XmlInterpreter interpreter = new XmlInterpreter(new StaticContentResource(xml));
interpreter.ProcessResource(interpreter.Source, _kernel.ConfigurationStore);
_kernel.AddFacility("batchregistration", new BatchRegistrationFacility());
Assert.IsTrue(_kernel.HasComponent("comp1"));
Assert.IsTrue(_kernel.HasComponent("comp2"));
Assert.IsTrue(_kernel.HasComponent(typeof(Component1)));
Assert.IsTrue(_kernel.HasComponent(typeof(Component2)));
}
public void Init()
{
_kernel = new DefaultKernel();
IConfiguration confignode = new MutableConfiguration("facility");
IConfiguration facilityConf = confignode.Children.Add(new MutableConfiguration(FacilityKey));
_kernel.ConfigurationStore.AddFacilityConfiguration(FacilityKey, confignode);
_facility = new HiperFacility();
Assert.IsFalse(_facility.Initialized);
_kernel.AddFacility(FacilityKey, _facility);
}
public void Init()
{
_kernel = new DefaultKernel();
IConfiguration confignode = new MutableConfiguration("facility");
IConfiguration facilityConf = confignode.Children.Add(new MutableConfiguration(FacilityKey));
_kernel.ConfigurationStore.AddFacilityConfiguration(FacilityKey, confignode);
_facility = new HiperFacility();
Assert.IsFalse(_facility.Initialized);
_kernel.AddFacility(FacilityKey, _facility);
}
public static IKernel AddAspectCoreFacility(this IKernel Kernel, Action <IAspectConfiguration> configure = null)
{
if (Kernel == null)
{
throw new ArgumentNullException(nameof(Kernel));
}
var config = new AspectConfiguration();
configure?.Invoke(config);
if (Kernel.GetFacilities().All(x => !(x.GetType() == typeof(AspectCoreFacility))))
{
Kernel.AddFacility(new AspectCoreFacility(config));
}
return(Kernel);
}
protected void AddFacility <T>(IKernel kernel) where T : IFacility, new()
{
if (kernel == null)
{
throw new ArgumentNullException("kernel");
}
IFacility[] facilities = kernel.GetFacilities();
if (facilities != null && facilities.Any(f => f.GetType() == typeof(T)))
{
return;
}
kernel.AddFacility <T>();
}
public void SetUp()
{
kernel = new DefaultKernel();
kernel.AddFacility <StartableFacility>();
kernel.Register(
Component.For <StartableDisposableAndInitializableComponent>()
.LifeStyle.Transient
);
component = kernel.Resolve <StartableDisposableAndInitializableComponent>();
component.DoSomething();
kernel.ReleaseComponent(component);
calledMethods = component.calledMethods;
}
public void TestWithSnapshot()
{
IKernel kernel = CreateConfiguredSnapshotKernel();
kernel.AddFacility("prevalence", new PrevalenceFacility());
// Lookup for the engine
object engineService = kernel["engineid"];
Assert.IsNotNull(engineService);
Assert.IsTrue(engineService is PrevalenceEngine);
// Lookup for the system
object system = kernel["systemid"];
Assert.IsNotNull(system);
Assert.IsTrue(system is UserDatabase);
// Lookup for SnapshotTaker
object snapshotTaker = kernel[PrevalenceFacility.SnapShotTakerComponentPropertyKey];
Assert.IsNotNull(snapshotTaker);
Assert.IsTrue(snapshotTaker is SnapshotTaker);
//Cleanup Policy
object policy = kernel[PrevalenceFacility.CleanupPolicyComponentPropertyKey];
Assert.IsNotNull(policy);
Assert.IsTrue(policy is ICleanUpPolicy);
((UserDatabase)system).Init();;
kernel.Dispose();
bool snapshoted = false;
foreach (string file in Directory.GetFiles(_storageDir))
{
if (Path.GetExtension(file).Equals(".snapshot"))
{
snapshoted = true;
}
}
Assert.IsTrue(snapshoted);
}
public void SetUp()
{
kernel = new DefaultKernel();
kernel.AddFacility<StartableFacility>();
kernel.Register(
Component.For<StartableDisposableAndInitializableComponent>()
.LifeStyle.Transient
);
component = kernel.Resolve<StartableDisposableAndInitializableComponent>();
component.DoSomething();
kernel.ReleaseComponent(component);
calledMethods = component.calledMethods;
}
public void TestUsage()
{
IKernel kernel = CreateConfiguredKernel();
kernel.AddFacility("prevalence", new PrevalenceFacility());
// Lookup for the engine
object engineService = kernel["engineid"];
Assert.IsNotNull(engineService);
Assert.IsTrue(engineService is PrevalenceEngine);
// Lookup for the system
object system = kernel["systemid"];
Assert.IsNotNull(system);
Assert.IsTrue(system is UserDatabase);
}
public void Register()
{
if (_extensions != null)
{
foreach (var extension in _extensions)
{
extension.Apply(this);
}
}
var instance = ObtainFacilityInstance();
if (_configuration != null)
{
kernel.ConfigurationStore.AddFacilityConfiguration(_key, _configuration);
}
kernel.AddFacility(instance);
}
public Facility Register()
{
if (_extensions != null)
{
foreach (IFacilityExtension extension in _extensions)
{
extension.Apply(this);
}
}
IFacility instance = ObtainFacilityInstance();
if (_configuration != null)
{
kernel.ConfigurationStore.AddFacilityConfiguration(_key, _configuration);
}
kernel.AddFacility(_key, instance);
return(this);
}
/// <summary>
/// Registers a facility within the kernel.
/// </summary>
/// <param name="key"></param>
/// <param name="facility"></param>
public virtual void AddFacility(String key, IFacility facility)
{
_kernel.AddFacility(key, facility);
}
public virtual IWindsorContainer AddFacility(String idInConfiguration, IFacility facility)
{
kernel.AddFacility(idInConfiguration, facility);
return(this);
}
public void Init()
{
facility = new FactorySupportFacility();
kernel = new DefaultKernel();
kernel.AddFacility("factory.support", facility);
}
public void SetUp()
{
kernel = new DefaultKernel();
kernel.AddFacility<FactorySupportFacility>();
}
public void Startable_with_throwing_property_dependency()
{
HasThrowingPropertyDependency.InstancesStarted = 0;
HasThrowingPropertyDependency.InstancesCreated = 0;
kernel.AddFacility <StartableFacility>();
kernel.Register(
Component.For <ThrowsInCtor>(),
Component.For <HasThrowingPropertyDependency>()
.StartUsingMethod(x => x.Start)
);
Assert.AreEqual(1, HasThrowingPropertyDependency.InstancesCreated);
Assert.AreEqual(1, HasThrowingPropertyDependency.InstancesStarted);
}
public static void RegisterFrameworkContainer(this IKernel container)
{
container.AddFacility(new MediatorFacility());
}
/// <summary>
/// Registers a facility within the container.
/// </summary>
/// <param name = "facility"></param>
public IWindsorContainer AddFacility(IFacility facility)
{
kernel.AddFacility(facility);
return(this);
}
