private void Apply(ComponentModel model, object key, object value, ServiceOverride @override)
{
if (value is string)
{
ApplySimpleReference(model, key, (String)value);
}
else if (value is IEnumerable<String>)
{
ApplyReferenceList(model, key, (IEnumerable<String>)value, @override);
}
}
public void Two_satisfiable_constructors_equal_number_of_inline_parameters_pick_one_with_more_service_overrides()
{
Container.Register(Component.For <ICommon>().ImplementedBy <CommonImpl1>().Named("Mucha"),
Component.For <ICustomer>().ImplementedBy <CustomerImpl>().Named("Stefan"),
Component.For <HasTwoConstructors>().Named("first")
.DependsOn(ServiceOverride.ForKey("customer").Eq("Stefan")),
Component.For <HasTwoConstructors>().Named("second")
.DependsOn(ServiceOverride.ForKey("common").Eq("Mucha")));
var first = Container.Resolve <HasTwoConstructors>("first");
var second = Container.Resolve <HasTwoConstructors>("second");
Assert.IsNotNull(first.Customer);
Assert.IsNotNull(second.Common);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(
Component.For <IEmptyService>().ImplementedBy <EmptyServiceA>().Named("foo"),
Component.For <IEmptyService>().ImplementedBy <EmptyServiceB>().Named("bar"),
Component.For <IEmptyService>().ImplementedBy <EmptyServiceDecoratorViaProperty>().Named("baz"),
Component.For <ArrayDepAsConstructor>().Named("InjectAll"),
Component.For <ArrayDepAsConstructor>().Named("InjectFooOnly")
.DependsOn(ServiceOverride.ForKey("services").Eq(new[] { "foo" })),
Component.For <ArrayDepAsConstructor>().Named("InjectFooAndBarOnly")
.DependsOn(ServiceOverride.ForKey("services").Eq(new[] { "foo", "bar" })),
Component.For <ListDepAsConstructor>().Named("InjectAllList"),
Component.For <ListDepAsConstructor>().Named("InjectFooOnlyList")
.DependsOn(ServiceOverride.ForKey("services").Eq(new[] { "foo" })),
Component.For <ListDepAsConstructor>().Named("InjectFooAndBarOnlyList")
.DependsOn(ServiceOverride.ForKey("services").Eq(new[] { "foo", "bar" })));
}
private void ApplyReferenceList(ComponentModel model, object name, IEnumerable<String> items, ServiceOverride serviceOverride)
{
var list = new MutableConfiguration("list");
if (serviceOverride != null && serviceOverride.Type != null)
{
list.Attributes.Add("type", serviceOverride.Type.AssemblyQualifiedName);
}
foreach (var item in items)
{
var reference = ReferenceExpressionUtil.BuildReference(item);
list.Children.Add(new MutableConfiguration("item", reference));
}
AddParameter(model, GetNameString(name), list);
}
public void Resolving_Named_Component_With_ServiceOverride()
{
var collection = new ServiceCollection();
var serviceProvider = CreateServiceProvider(collection);
var windsorContainer = serviceProvider.GetService <IWindsorContainer>();
windsorContainer.Register(
Component.For <MyTestClass3>().Named("CustomTestClass"),
Component.For <MyTestClass2>().ImplementedBy <MyTestClass2>()
.DependsOn(ServiceOverride.ForKey("myTestClass3").Eq("CustomTestClass"))
);
var test1 = serviceProvider.GetService <MyTestClass2>();
Assert.NotNull(test1);
}
public void Install(IWindsorContainer container)
{
container.AddFacility <EventPublisherFacility>();
container.AddFacility <StartableFacility>();
container.AddFacility <DockingFacility>();
container.AddFacility <MenuFacility>();
container.AddComponent("applicationShell", typeof(IApplicationShell), typeof(ApplicationShell));
container.AddComponent("presenter.factory", typeof(IPresenterFactory), typeof(PresenterFactory));
container.Register(
Component.For <IImageSource>().ImplementedBy <ResourceManagerImageSource>().Named("imageSource.res"));
container.Register(
Component.For <IImageFactory>()
.ImplementedBy <ImageFactory>()
.ServiceOverrides(
ServiceOverride.ForKey("sources").Eq <IImageSource>("imageSource.res")));
// todo: refactor to register all views and presenters declaratively.
container.Register(
Component.For <IOutputView>().ImplementedBy <OutputView>(),
Component.For <IOutputPresenter>().ImplementedBy <OutputPresenter>(),
Component.For <IProjectExplorerView>().ImplementedBy <ProjectExplorerView>(),
Component.For <IProjectExplorerPresenter>().ImplementedBy <ProjectExplorerPresenter>(),
Component.For <IPropertyGridView>().ImplementedBy <PropertyGridView>(),
Component.For <IPropertyGridPresenter>().ImplementedBy <PropertyGridPresenter>(),
Component.For <IToolBoxView>().ImplementedBy <ToolBoxView>(),
Component.For <IToolBoxPresenter>().ImplementedBy <ToolBoxPresenter>());
container.Register(
Component
.For <IMenuPresenter>()
.ImplementedBy <MenuStripPresenter>()
.Parameters(
Parameter
.ForKey("menu")
.Eq("${" + MainMenuToolStripKey + "}")));
container.Register(AllTypes.Of <AbstractCommand>().FromAssembly(typeof(AbstractCommand).Assembly));
container.Register(
Component.For <DockedWindowsMenuModel>());
}
private void Apply(ComponentModel model, object key, object value, ServiceOverride @override)
{
if (value is string)
{
ApplySimpleReference(model, key, (String)value);
}
else if (value is IEnumerable <String> )
{
ApplyReferenceList(model, key, (IEnumerable <String>)value, @override);
}
if (value is Type)
{
ApplySimpleReference(model, key, ((Type)value).FullName);
}
else if (value is IEnumerable <Type> )
{
ApplyReferenceList(model, key, ((IEnumerable <Type>)value).Select(t => t.FullName), @override);
}
}
/// <summary>
/// Registers a new core in the container.
/// This method is meant to be used after the facility initialization
/// </summary>
/// <param name="core"></param>
private void RegisterCore(SolrCore core)
{
var coreConnectionId = core.Id + typeof(SolrConnection);
if (core.PostConnection)
{
Kernel.Register(
Component.For <ISolrConnection>().ImplementedBy <PostSolrConnection>()
.Named(coreConnectionId)
.DependsOn(Dependency.OnValue("serverURL", core.Url))
);
}
else
{
Kernel.Register(Component.For <ISolrConnection>().ImplementedBy <SolrConnection>()
.Named(coreConnectionId)
.Parameters(Parameter.ForKey("serverURL").Eq(core.Url)));
}
var ISolrQueryExecuter = typeof(ISolrQueryExecuter <>).MakeGenericType(core.DocumentType);
var SolrQueryExecuter = typeof(SolrQueryExecuter <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrQueryExecuter).ImplementedBy(SolrQueryExecuter)
.Named(core.Id + SolrQueryExecuter)
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(coreConnectionId)));
var ISolrBasicOperations = typeof(ISolrBasicOperations <>).MakeGenericType(core.DocumentType);
var ISolrBasicReadOnlyOperations = typeof(ISolrBasicReadOnlyOperations <>).MakeGenericType(core.DocumentType);
var SolrBasicServer = typeof(SolrBasicServer <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrBasicOperations, ISolrBasicReadOnlyOperations)
.ImplementedBy(SolrBasicServer)
.Named(core.Id + SolrBasicServer)
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(coreConnectionId),
ServiceOverride.ForKey("queryExecuter").Eq(core.Id + SolrQueryExecuter)));
var ISolrOperations = typeof(ISolrOperations <>).MakeGenericType(core.DocumentType);
var SolrServer = typeof(SolrServer <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrOperations).ImplementedBy(SolrServer)
.Named(core.Id)
.ServiceOverrides(ServiceOverride.ForKey("basicServer").Eq(core.Id + SolrBasicServer)));
}
private void Apply(ComponentModel model, Object dependencyKey, Object dependencyValue, ServiceOverride @override)
{
if (dependencyValue is String)
{
ApplySimpleReference(model, dependencyKey, (String)dependencyValue);
}
else if (dependencyValue is IEnumerable<String>)
{
ApplyReferenceList(model, dependencyKey, (IEnumerable<String>)dependencyValue, @override);
}
else if (dependencyValue is Type)
{
ApplySimpleReference(model, dependencyKey, ComponentName.DefaultNameFor((Type)dependencyValue));
}
else if (dependencyValue is IEnumerable<Type>)
{
ApplyReferenceList(model, dependencyKey, ((IEnumerable<Type>)dependencyValue).Select(ComponentName.DefaultNameFor), @override);
}
}
private void Apply(ComponentModel model, object dependencyKey, object value, ServiceOverride @override)
{
if (value is string)
{
ApplySimpleReference(model, dependencyKey, (String)value);
}
else if (value is IEnumerable<String>)
{
ApplyReferenceList(model, dependencyKey, (IEnumerable<String>)value, @override);
}
if (value is Type)
{
ApplySimpleReference(model, dependencyKey, ((Type)value).FullName);
}
else if (value is IEnumerable<Type>)
{
ApplyReferenceList(model, dependencyKey, ((IEnumerable<Type>)value).Select(t => t.FullName), @override);
}
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
ServiceOverride dependency = Property.ForKey <ISessionFactory>().Is("AgentSessionFactory");
container
.AddFacility <PersistenceFacility>()
.Register
(
Component
.For <IRepository>()
.ImplementedBy <NHibernateRepository>()
.Named(AGENT_REPOSITORY)
.DependsOn(dependency)
.LifestyleTransient()
)
.Register(Component.For <IProductRepository>().ImplementedBy <ProductRepository>().LifestyleTransient())
.Register(Component.For <IInventoryRepository>().ImplementedBy <InventoryRepository>().LifestyleTransient())
.Register(Component.For <IUnitOfWork>().ImplementedBy <SimpleUnitOfWork>().LifestylePerWebRequest());
}
/// <summary>
/// Performs the installation in the <see cref="T:Castle.Windsor.IWindsorContainer" />.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="store">The configuration store.</param>
public void Install(IWindsorContainer container, IConfigurationStore store)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
GatewayServiceMapper.Register();
const string GatewaysContextLocatorName = "GatewaysContextLocator";
const string ContextLocatorFieldName = "contextLocator";
container.Register(
Component.For <Func <GatewaysContext> >().Instance(() => new GatewaysContext())
.Named(GatewaysContextLocatorName));
container.Register(
Component.For <IGatewaysDataService>().ImplementedBy <GatewaysDataService>()
.DependsOn(ServiceOverride.ForKey(ContextLocatorFieldName).Eq(GatewaysContextLocatorName)));
}
public void Typed_arguments_work_for_open_generic_ServiceOverrides_closed_service_preferred_over_open_service()
{
Kernel.Register(
Component.For(typeof(IGeneric <>)).ImplementedBy(typeof(GenericImpl1 <>)).Named("default"),
Component.For(typeof(IGeneric <>)).ImplementedBy(typeof(GenericImpl2 <>)).Named("non-default-open")
.DependsOn(Property.ForKey("value").Eq(1)),
Component.For(typeof(IGeneric <>)).ImplementedBy(typeof(GenericImpl2 <>)).Named("non-default-int")
.DependsOn(Property.ForKey("value").Eq(2)),
Component.For(typeof(UsesIGeneric <>))
.ServiceOverrides(ServiceOverride.ForKey(typeof(IGeneric <>)).Eq("non-default-open"),
ServiceOverride.ForKey(typeof(IGeneric <int>)).Eq("non-default-int"))
);
var withString = Kernel.Resolve <UsesIGeneric <string> >();
var withInt = Kernel.Resolve <UsesIGeneric <int> >();
Assert.IsInstanceOf <GenericImpl2 <string> >(withString.Dependency);
Assert.AreEqual(1, (withString.Dependency as GenericImpl2 <string>).Value);
Assert.IsInstanceOf <GenericImpl2 <int> >(withInt.Dependency);
Assert.AreEqual(2, (withInt.Dependency as GenericImpl2 <int>).Value);
}
public static void RegisterMethodLogInterceptor(this IWindsorContainer container, string name, ILogListener logListener)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException();
}
if (logListener == null)
{
throw new ArgumentException();
}
container.Register(
Component.For <MethodLogInterceptor>().Named(name).DependsOn(ServiceOverride.ForKey <ILogger>().Eq($"{name}Logger")).DependsOn(ServiceOverride.ForKey <IMethodLogMessageFactory>().Eq($"{name}ElapsedMethodLogMessageFactory")),
Component.For <ILogger>().UsingFactoryMethod(kernel => CreateLogger(kernel, $"{name}LogListener")).Named($"{name}Logger"),
Component.For <ILogListener>().Instance(logListener).Named($"{name}LogListener").LifestyleSingleton(),
Component.For <IMethodLogMessageFactory>().ImplementedBy <ElapsedMethodLogMessageFactory>().Named($"{name}ElapsedMethodLogMessageFactory").DependsOn(ServiceOverride.ForKey <IMethodLogMessageFactory>().Eq($"{name}MethodLogMessageFactory")),
Component.For <IMethodLogMessageFactory>().ImplementedBy <MethodLogMessageFactory>().Named($"{name}MethodLogMessageFactory").DependsOn(ServiceOverride.ForKey <ILogValueMapper>().Eq($"{name}LogValueMapper"), ServiceOverride.ForKey <ILogMessageSettings>().Eq($"{name}LogMessageSettings")),
Component.For <ILogMessageSettings>().ImplementedBy <LogMessageSettings>().Named($"{name}LogMessageSettings"),
Component.For <ILogValueMapper>().ImplementedBy <LogValueMapper>().Named($"{name}LogValueMapper").DependsOn(ServiceOverride.ForKey <ILogValueMapperConfigurator>().Eq($"{name}LogValueMapperConfigurator")),
Component.For <ILogValueMapperConfigurator>().ImplementedBy <DefaultLogValueMapperConfigurator>().Named($"{name}LogValueMapperConfigurator"));
}
/// <summary>
/// Registers a new core in the container.
/// This method is meant to be used after the facility initialization
/// </summary>
/// <param name="core"></param>
private void RegisterCore(SolrCore core)
{
var coreConnectionId = core.Id + typeof(SolrConnection);
var solrConnection = new SolrConnection(core.Url);
Kernel.Register(
Component.For <ISolrConnection>()
.ImplementedBy <PostSolrConnection>()
.Named(coreConnectionId)
.DependsOn(
Property.ForKey("conn").Eq(solrConnection),
Property.ForKey("serverURL").Eq(core.Url)));
var ISolrQueryExecuter = typeof(ISolrQueryExecuter <>).MakeGenericType(core.DocumentType);
var SolrQueryExecuter = typeof(SolrQueryExecuter <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrQueryExecuter).ImplementedBy(SolrQueryExecuter)
.Named(core.Id + SolrQueryExecuter)
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(coreConnectionId)));
var ISolrBasicOperations = typeof(ISolrBasicOperations <>).MakeGenericType(core.DocumentType);
var ISolrBasicReadOnlyOperations = typeof(ISolrBasicReadOnlyOperations <>).MakeGenericType(core.DocumentType);
var SolrBasicServer = typeof(SolrBasicServer <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrBasicOperations, ISolrBasicReadOnlyOperations)
.ImplementedBy(SolrBasicServer)
.Named(core.Id + SolrBasicServer)
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(coreConnectionId),
ServiceOverride.ForKey("queryExecuter").Eq(core.Id + SolrQueryExecuter)));
var ISolrOperations = typeof(ISolrOperations <>).MakeGenericType(core.DocumentType);
var SolrServer = typeof(SolrServer <>).MakeGenericType(core.DocumentType);
Kernel.Register(Component.For(ISolrOperations).ImplementedBy(SolrServer)
.Named(core.Id)
.ServiceOverrides(ServiceOverride.ForKey("basicServer").Eq(core.Id + SolrBasicServer)));
}
public void MultiCore()
{
const string core0url = "http://localhost:8983/solr/core0";
const string core1url = "http://localhost:8983/solr/core1";
var solrFacility = new SolrNetFacility(core0url);
var container = new WindsorContainer();
container.AddFacility("solr", solrFacility);
// override core1 components
const string core1Connection = "core1.connection";
container.Register(Component.For <ISolrConnection>().ImplementedBy <SolrConnection>().Named(core1Connection)
.Parameters(Parameter.ForKey("serverURL").Eq(core1url)));
container.Register(Component.For(typeof(ISolrBasicOperations <Core1Entity>), typeof(ISolrBasicReadOnlyOperations <Core1Entity>))
.ImplementedBy <SolrBasicServer <Core1Entity> >()
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(core1Connection)));
container.Register(Component.For <ISolrQueryExecuter <Core1Entity> >().ImplementedBy <SolrQueryExecuter <Core1Entity> >()
.ServiceOverrides(ServiceOverride.ForKey("connection").Eq(core1Connection)));
// assert that everything is correctly wired
container.Kernel.DependencyResolving += (client, model, dep) => {
if (model.TargetType == typeof(ISolrConnection))
{
if (client.Service == typeof(ISolrBasicOperations <Core1Entity>) || client.Service == typeof(ISolrQueryExecuter <Core1Entity>))
{
Assert.AreEqual(core1url, ((SolrConnection)dep).ServerURL);
}
if (client.Service == typeof(ISolrBasicOperations <Document>) || client.Service == typeof(ISolrQueryExecuter <Document>))
{
Assert.AreEqual(core0url, ((SolrConnection)dep).ServerURL);
}
}
};
container.Resolve <ISolrOperations <Core1Entity> >();
container.Resolve <ISolrOperations <Document> >();
}
public void AddComponent_GenericListServiceOverrides_WorksFine()
{
Kernel.Register(
Component.For <ICommon>()
.Named("common1")
.ImplementedBy <CommonImpl1>(),
Component.For <ICommon>()
.Named("common2")
.ImplementedBy <CommonImpl2>(),
Component.For <ClassWithListConstructor>()
.DependsOn(
ServiceOverride.ForKey("services").Eq <ICommon>("common1", "common2")
)
);
var common1 = Kernel.Resolve <ICommon>("common1");
var common2 = Kernel.Resolve <ICommon>("common2");
var component = Kernel.Resolve <ClassWithListConstructor>();
Assert.AreEqual(2, component.Services.Count);
Assert.AreSame(common1, component.Services[0]);
Assert.AreSame(common2, component.Services[1]);
}
public static void RegisterHashCodeMethodLogAsyncInterceptor <TLogListenerFactory>(this IWindsorContainer container, string name, string loggerName) where TLogListenerFactory : ILogListenerFactory, new()
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException();
}
if (string.IsNullOrEmpty(loggerName))
{
throw new ArgumentException();
}
container.Register(
Component.For <MethodLogAsyncInterceptor>().Named(name).DependsOn(ServiceOverride.ForKey <ILogger>().Eq($"{name}Logger")).DependsOn(ServiceOverride.ForKey <IMethodLogMessageFactory>().Eq($"{name}ElapsedMethodLogMessageFactory")),
Component.For <ILogger>().UsingFactoryMethod(kernel => CreateLogger(kernel, $"{name}LogListener")).Named($"{name}Logger"),
Component.For <ILogListenerFactory>().ImplementedBy <TLogListenerFactory>().Named($"{name}LogListenerFactory"),
Component.For <ILogListener>().UsingFactoryMethod(kernel => kernel.Resolve <ILogListenerFactory>($"{name}LogListenerFactory").CreateLogListener(loggerName)).Named($"{name}LogListener").LifestyleSingleton(),
Component.For <IMethodLogMessageFactory>().ImplementedBy <ElapsedMethodLogMessageFactory>().Named($"{name}ElapsedMethodLogMessageFactory").DependsOn(ServiceOverride.ForKey <IMethodLogMessageFactory>().Eq($"{name}HashCodeMethodLogMessageFactory")),
Component.For <IMethodLogMessageFactory>().ImplementedBy <HashCodeMethodLogMessageFactory>().Named($"{name}HashCodeMethodLogMessageFactory").DependsOn(ServiceOverride.ForKey <IMethodLogMessageFactory>().Eq($"{name}MethodLogMessageFactory")),
Component.For <IMethodLogMessageFactory>().ImplementedBy <MethodLogMessageFactory>().Named($"{name}MethodLogMessageFactory").DependsOn(ServiceOverride.ForKey <ILogValueMapper>().Eq($"{name}LogValueMapper"), ServiceOverride.ForKey <ILogMessageSettings>().Eq($"{name}LogMessageSettings")),
Component.For <ILogMessageSettings>().ImplementedBy <HashCodeLogMessageSettings>().Named($"{name}LogMessageSettings"),
Component.For <ILogValueMapper>().ImplementedBy <LogValueMapper>().Named($"{name}LogValueMapper").DependsOn(ServiceOverride.ForKey <ILogValueMapperConfigurator>().Eq($"{name}LogValueMapperConfigurator")),
Component.For <ILogValueMapperConfigurator>().ImplementedBy <DefaultLogValueMapperConfigurator>().Named($"{name}LogValueMapperConfigurator"));
}
/// <summary>
/// Performs the installation in the <see cref="T:Castle.Windsor.IWindsorContainer" />.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="store">The configuration store.</param>
public void Install(IWindsorContainer container, IConfigurationStore store)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
UserServiceMapper.Register();
container.Register(
Component.For <IPasswordEncoder>().ImplementedBy <PasswordEncoder>());
const string UsersContextLocatorName = "UsersContextLocator";
const string ContextLocatorFieldName = "contextLocator";
container.Register(
Component.For <Func <UsersContext> >().Instance(() => new UsersContext())
.Named(UsersContextLocatorName));
container.Register(
Component.For <IUsersDataService>().ImplementedBy <UsersDataService>()
.DependsOn(ServiceOverride.ForKey(ContextLocatorFieldName).Eq(UsersContextLocatorName)));
}
public void Typed_arguments_work_for_closed_generic_ServiceOverrides()
{
Kernel.Register(Component.For <IGeneric <string> >().ImplementedBy <GenericImpl1 <string> >().Named("default"),
Component.For <IGeneric <string> >().ImplementedBy <GenericImpl2 <string> >().Named("non-default"),
Component.For <UsesIGeneric <string> >().ServiceOverrides(ServiceOverride.ForKey <IGeneric <string> >().Eq("non-default")));
var item = Kernel.Resolve <UsesIGeneric <string> >();
Assert.IsInstanceOf <GenericImpl2 <string> >(item.Dependency);
}
private void Apply(ComponentModel model, Object dependencyKey, Object dependencyValue, ServiceOverride @override)
{
if (dependencyValue is String)
{
ApplySimpleReference(model, dependencyKey, (String)dependencyValue);
}
else if (dependencyValue is IEnumerable <String> )
{
ApplyReferenceList(model, dependencyKey, (IEnumerable <String>)dependencyValue, @override);
}
else if (dependencyValue is Type)
{
ApplySimpleReference(model, dependencyKey, ComponentName.DefaultNameFor((Type)dependencyValue));
}
else if (dependencyValue is IEnumerable <Type> )
{
ApplyReferenceList(model, dependencyKey, ((IEnumerable <Type>)dependencyValue).Select(ComponentName.DefaultNameFor), @override);
}
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
bool securityTrimmingEnabled = false;
bool enableLocalization = true;
string absoluteFileName = HostingEnvironment.MapPath("~/Mvc.sitemap");
TimeSpan absoluteCacheExpiration = TimeSpan.FromMinutes(5);
string[] includeAssembliesForScan = new string[] { "$AssemblyName$" };
// Configure Windsor to resolve arrays in constructors
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
var currentAssembly = this.GetType().Assembly;
var siteMapProviderAssembly = typeof(SiteMaps).Assembly;
var allAssemblies = new Assembly[] { currentAssembly, siteMapProviderAssembly };
var excludeTypes = new Type[] {
typeof(SiteMapNodeVisibilityProviderStrategy),
typeof(SiteMapXmlReservedAttributeNameProvider),
typeof(SiteMapBuilderSetStrategy),
typeof(ControllerTypeResolverFactory),
typeof(SiteMapNodeUrlResolver)
};
var multipleImplementationTypes = new Type[] {
typeof(ISiteMapNodeUrlResolver),
typeof(ISiteMapNodeVisibilityProvider),
typeof(IDynamicNodeProvider)
};
// Single implementations of interface with matching name (minus the "I").
CommonConventions.RegisterDefaultConventions(
(interfaceType, implementationType) => container.Register(Component.For(interfaceType).ImplementedBy(implementationType).LifestyleSingleton()),
new Assembly[] { siteMapProviderAssembly },
allAssemblies,
excludeTypes,
string.Empty);
// Multiple implementations of strategy based extension points
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => container.Register(Component.For(interfaceType).ImplementedBy(implementationType).LifestyleSingleton()),
multipleImplementationTypes,
allAssemblies,
new Type[0],
"^Composite");
// Registration of internal controllers
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => container.Register(Component.For(implementationType).ImplementedBy(implementationType).LifestyleTransient()),
new Type[] { typeof(IController) },
new Assembly[] { siteMapProviderAssembly },
new Type[0],
string.Empty);
// Visibility Providers
container.Register(Component.For <ISiteMapNodeVisibilityProviderStrategy>().ImplementedBy <SiteMapNodeVisibilityProviderStrategy>()
.DependsOn(Dependency.OnValue("defaultProviderName", string.Empty)));
// Pass in the global controllerBuilder reference
container.Register(Component.For <ControllerBuilder>().Instance(ControllerBuilder.Current));
container.Register(Component.For <IControllerBuilder>().ImplementedBy <ControllerBuilderAdaptor>());
container.Register(Component.For <IBuildManager>().ImplementedBy <BuildManagerAdaptor>());
container.Register(Component.For <IControllerTypeResolverFactory>().ImplementedBy <ControllerTypeResolverFactory>()
.DependsOn(Dependency.OnValue("areaNamespacesToIgnore", new string[0])));
// Configure Security
// First registration wins - we must do the outer one first
container.Register(Component.For <IAclModule>().ImplementedBy <CompositeAclModule>()
.DependsOn(Dependency.OnComponentCollection <IEnumerable <IAclModule> >(typeof(AuthorizeAttributeAclModule), typeof(XmlRolesAclModule))));
container.Register(Component.For <IAclModule>().ImplementedBy <AuthorizeAttributeAclModule>());
container.Register(Component.For <IAclModule>().ImplementedBy <XmlRolesAclModule>());
// Setup cache
#if NET35
container.Register(Component.For(typeof(ICacheProvider <>)).ImplementedBy(typeof(AspNetCacheProvider <>)));
container.Register(Component.For <ICacheDependency>().ImplementedBy <AspNetFileCacheDependency>().Named("cacheDependency1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
#else
container.Register(Component.For <System.Runtime.Caching.ObjectCache>().Instance(System.Runtime.Caching.MemoryCache.Default));
container.Register(Component.For(typeof(ICacheProvider <>)).ImplementedBy(typeof(RuntimeCacheProvider <>)));
container.Register(Component.For <ICacheDependency>().ImplementedBy <RuntimeFileCacheDependency>().Named("cacheDependency1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
#endif
container.Register(Component.For <ICacheDetails>().ImplementedBy <CacheDetails>().Named("cacheDetails1")
.DependsOn(Dependency.OnValue("absoluteCacheExpiration", absoluteCacheExpiration))
.DependsOn(Dependency.OnValue("slidingCacheExpiration", TimeSpan.MinValue))
.DependsOn(ServiceOverride.ForKey <ICacheDependency>().Eq("cacheDependency1"))
);
// Configure the visitors
container.Register(Component.For <ISiteMapNodeVisitor>().ImplementedBy <UrlResolvingSiteMapNodeVisitor>());
// Register the sitemap builder
container.Register(Component.For <IXmlSource>().ImplementedBy <FileXmlSource>().Named("xmlSource1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
container.Register(Component.For <ISiteMapXmlReservedAttributeNameProvider>().ImplementedBy <SiteMapXmlReservedAttributeNameProvider>()
.DependsOn(Dependency.OnValue("attributesToIgnore", new string[0])));
container.Register(Component.For <ISiteMapBuilder>().ImplementedBy <CompositeSiteMapBuilder>().Named("builder1")
.DependsOn(Dependency.OnComponentCollection <ISiteMapBuilder[]>("xmlSiteMapBuilder1", "reflectionSiteMapBuilder1", "visitingSiteMapBuilder1")));
container.Register(Component.For <ISiteMapBuilder>().ImplementedBy <XmlSiteMapBuilder>().Named("xmlSiteMapBuilder1")
.DependsOn(Dependency.OnValue <ISiteMapXmlReservedAttributeNameProvider>(container.Resolve <ISiteMapXmlReservedAttributeNameProvider>()))
.DependsOn(ServiceOverride.ForKey <IXmlSource>().Eq("xmlSource1"))
);
container.Register(Component.For <ISiteMapBuilder>().ImplementedBy <ReflectionSiteMapBuilder>().Named("reflectionSiteMapBuilder1")
.DependsOn(Dependency.OnValue("includeAssemblies", includeAssembliesForScan))
.DependsOn(Dependency.OnValue("excludeAssemblies", new string[0]))
);
container.Register(Component.For <ISiteMapBuilder>().ImplementedBy <VisitingSiteMapBuilder>().Named("visitingSiteMapBuilder1"));
// Configure the builder sets
container.Register(Component.For <ISiteMapBuilderSet>().ImplementedBy <SiteMapBuilderSet>().Named("siteMapBuilderSet1")
.DependsOn(Dependency.OnValue("instanceName", "default"))
.DependsOn(Dependency.OnValue("securityTrimmingEnabled", securityTrimmingEnabled))
.DependsOn(Dependency.OnValue("enableLocalization", enableLocalization))
.DependsOn(ServiceOverride.ForKey <ISiteMapBuilder>().Eq("builder1"))
.DependsOn(ServiceOverride.ForKey <ICacheDetails>().Eq("cacheDetails1"))
);
container.Register(Component.For <ISiteMapBuilderSetStrategy>().ImplementedBy <SiteMapBuilderSetStrategy>()
.DependsOn(Dependency.OnComponentCollection <ISiteMapBuilderSet[]>("siteMapBuilderSet1")));
}
private void ApplyReferenceList(ComponentModel model, object key, IEnumerable <String> items, ServiceOverride serviceOverride)
{
var list = new MutableConfiguration("list");
if (serviceOverride != null && serviceOverride.Type != null)
{
list.Attributes.Add("type", serviceOverride.Type.AssemblyQualifiedName);
}
foreach (var item in items)
{
var reference = ReferenceExpressionUtil.BuildReference(item);
list.Children.Add(new MutableConfiguration("item", reference));
}
AddParameter(model, GetKeyString(key), list);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
bool enableLocalization = true;
string absoluteFileName = HostingEnvironment.MapPath("~/Mvc.sitemap");
TimeSpan absoluteCacheExpiration = TimeSpan.FromMinutes(5);
bool visibilityAffectsDescendants = true;
bool useTitleIfDescriptionNotProvided = true;
#if Demo
// Settings for MvcMusicStore demo: don't copy into your project
bool securityTrimmingEnabled = true;
string[] includeAssembliesForScan = new string[] { "Mvc Music Store" };
#else
bool securityTrimmingEnabled = false;
string[] includeAssembliesForScan = new string[] { "$AssemblyName$" };
#endif
// Configure Windsor to resolve arrays in constructors
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
var currentAssembly = this.GetType().Assembly;
var siteMapProviderAssembly = typeof(SiteMaps).Assembly;
var allAssemblies = new Assembly[] { currentAssembly, siteMapProviderAssembly };
var excludeTypes = new Type[] {
// Use this array to add types you wish to explicitly exclude from convention-based
// auto-registration. By default all types that either match I[TypeName] = [TypeName] or
// I[TypeName] = [TypeName]Adapter will be automatically wired up as long as they don't
// have the [ExcludeFromAutoRegistrationAttribute].
//
// If you want to override a type that follows the convention, you should add the name
// of either the implementation name or the interface that it inherits to this list and
// add your manual registration code below. This will prevent duplicate registrations
// of the types from occurring.
// Example:
// typeof(SiteMap),
// typeof(SiteMapNodeVisibilityProviderStrategy)
typeof(SiteMapNodeUrlResolver)
};
var multipleImplementationTypes = new Type[] {
typeof(ISiteMapNodeUrlResolver),
typeof(ISiteMapNodeVisibilityProvider),
typeof(IDynamicNodeProvider)
};
// Matching type name (I[TypeName] = [TypeName]) or matching type name + suffix Adapter (I[TypeName] = [TypeName]Adapter)
// and not decorated with the [ExcludeFromAutoRegistrationAttribute].
CommonConventions.RegisterDefaultConventions(
(interfaceType, implementationType) => container.Register(Component.For(interfaceType).ImplementedBy(implementationType).LifestyleSingleton()),
new Assembly[] { siteMapProviderAssembly },
allAssemblies,
excludeTypes,
string.Empty);
// Multiple implementations of strategy based extension points (and not decorated with [ExcludeFromAutoRegistrationAttribute]).
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => container.Register(Component.For(interfaceType).ImplementedBy(implementationType).LifestyleSingleton()),
multipleImplementationTypes,
allAssemblies,
new Type[0],
string.Empty);
// Registration of internal controllers
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => container.Register(Component.For(implementationType).ImplementedBy(implementationType).LifestyleTransient()),
new Type[] { typeof(IController) },
new Assembly[] { siteMapProviderAssembly },
new Type[0],
string.Empty);
// Visibility Providers
container.Register(Component.For <ISiteMapNodeVisibilityProviderStrategy>().ImplementedBy <SiteMapNodeVisibilityProviderStrategy>()
.DependsOn(Dependency.OnValue("defaultProviderName", string.Empty)));
// Pass in the global controllerBuilder reference
container.Register(Component.For <ControllerBuilder>().Instance(ControllerBuilder.Current));
container.Register(Component.For <IControllerTypeResolverFactory>().ImplementedBy <ControllerTypeResolverFactory>()
.DependsOn(Dependency.OnValue("areaNamespacesToIgnore", new string[0])));
// Configure Security
// First registration wins - we must do the outer one first
container.Register(Component.For <IAclModule>().ImplementedBy <CompositeAclModule>()
.DependsOn(Dependency.OnComponentCollection <IEnumerable <IAclModule> >(typeof(AuthorizeAttributeAclModule), typeof(XmlRolesAclModule))));
container.Register(Component.For <IAclModule>().ImplementedBy <AuthorizeAttributeAclModule>());
container.Register(Component.For <IAclModule>().ImplementedBy <XmlRolesAclModule>());
// Setup cache
#if NET35
container.Register(Component.For(typeof(ICacheProvider <>)).ImplementedBy(typeof(AspNetCacheProvider <>)));
container.Register(Component.For <ICacheDependency>().ImplementedBy <AspNetFileCacheDependency>().Named("cacheDependency1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
#else
container.Register(Component.For <System.Runtime.Caching.ObjectCache>().Instance(System.Runtime.Caching.MemoryCache.Default));
container.Register(Component.For(typeof(ICacheProvider <>)).ImplementedBy(typeof(RuntimeCacheProvider <>)));
container.Register(Component.For <ICacheDependency>().ImplementedBy <RuntimeFileCacheDependency>().Named("cacheDependency1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
#endif
container.Register(Component.For <ICacheDetails>().ImplementedBy <CacheDetails>().Named("cacheDetails1")
.DependsOn(Dependency.OnValue("absoluteCacheExpiration", absoluteCacheExpiration))
.DependsOn(Dependency.OnValue("slidingCacheExpiration", TimeSpan.MinValue))
.DependsOn(ServiceOverride.ForKey <ICacheDependency>().Eq("cacheDependency1"))
);
// Configure the visitors
container.Register(Component.For <ISiteMapNodeVisitor>().ImplementedBy <UrlResolvingSiteMapNodeVisitor>());
// Prepare for the sitemap node providers
container.Register(Component.For <IXmlSource>().ImplementedBy <FileXmlSource>().Named("xmlSource1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
container.Register(Component.For <IReservedAttributeNameProvider>().ImplementedBy <ReservedAttributeNameProvider>()
.DependsOn(Dependency.OnValue("attributesToIgnore", new string[0])));
// Register the sitemap node providers
container.Register(Component.For <ISiteMapNodeProvider>().ImplementedBy <CompositeSiteMapNodeProvider>().Named("siteMapNodeProvider1")
.DependsOn(Dependency.OnComponentCollection <ISiteMapNodeProvider[]>("xmlSiteMapNodeProvider1", "reflectionSiteMapNodeProvider1")));
container.Register(Component.For <ISiteMapNodeProvider>().ImplementedBy <XmlSiteMapNodeProvider>().Named("xmlSiteMapNodeProvider1")
.DependsOn(Dependency.OnValue("includeRootNode", true))
.DependsOn(Dependency.OnValue("useNestedDynamicNodeRecursion", false))
.DependsOn(ServiceOverride.ForKey <IXmlSource>().Eq("xmlSource1"))
);
container.Register(Component.For <ISiteMapNodeProvider>().ImplementedBy <ReflectionSiteMapNodeProvider>().Named("reflectionSiteMapNodeProvider1")
.DependsOn(Dependency.OnValue("includeAssemblies", includeAssembliesForScan))
.DependsOn(Dependency.OnValue("excludeAssemblies", new string[0]))
);
// Register the sitemap builders
container.Register(Component.For <ISiteMapBuilder>().ImplementedBy <SiteMapBuilder>().Named("builder1")
.DependsOn(ServiceOverride.ForKey <ISiteMapNodeProvider>().Eq("siteMapNodeProvider1"))
);
// Configure the builder sets
container.Register(Component.For <ISiteMapBuilderSet>().ImplementedBy <SiteMapBuilderSet>().Named("siteMapBuilderSet1")
.DependsOn(Dependency.OnValue("instanceName", "default"))
.DependsOn(Dependency.OnValue("securityTrimmingEnabled", securityTrimmingEnabled))
.DependsOn(Dependency.OnValue("enableLocalization", enableLocalization))
.DependsOn(Dependency.OnValue("visibilityAffectsDescendants", visibilityAffectsDescendants))
.DependsOn(Dependency.OnValue("useTitleIfDescriptionNotProvided", useTitleIfDescriptionNotProvided))
.DependsOn(ServiceOverride.ForKey <ISiteMapBuilder>().Eq("builder1"))
.DependsOn(ServiceOverride.ForKey <ICacheDetails>().Eq("cacheDetails1"))
);
container.Register(Component.For <ISiteMapBuilderSetStrategy>().ImplementedBy <SiteMapBuilderSetStrategy>()
.DependsOn(Dependency.OnComponentCollection <ISiteMapBuilderSet[]>("siteMapBuilderSet1")));
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
const bool enableLocalization = true;
var absoluteFileName = HostingEnvironment.MapPath("~/Sitemap/Mvc.sitemap");
var absoluteCacheExpiration = TimeSpan.FromMinutes(5);
const bool visibilityAffectsDescendants = true;
const bool useTitleIfDescriptionNotProvided = true;
const bool securityTrimmingEnabled = false;
string[] includeAssembliesForScan = { "MusicStore.WebUI" };
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
var currentAssembly = GetType().Assembly;
var siteMapProviderAssembly = typeof(SiteMaps).Assembly;
var dynamicNodeAssembly = typeof(GenreDynamicNodeProvider).Assembly;
var allAssemblies = new[] { currentAssembly, siteMapProviderAssembly, dynamicNodeAssembly };
var excludeTypes = new[] { typeof(SiteMapNodeUrlResolver) };
var multipleImplementationTypes = new[]
{ typeof(ISiteMapNodeUrlResolver), typeof(ISiteMapNodeVisibilityProvider), typeof(IDynamicNodeProvider) };
CommonConventions.RegisterDefaultConventions(
(interfaceType, implementationType) =>
container.Register(Component.For(interfaceType).ImplementedBy(implementationType).LifestyleSingleton()),
new[] { siteMapProviderAssembly }, allAssemblies, excludeTypes, string.Empty);
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) =>
container.Register(Component.For(interfaceType).ImplementedBy(implementationType).LifestyleSingleton()),
multipleImplementationTypes, allAssemblies, new Type[0], string.Empty);
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) =>
container.Register(Component.For(implementationType).ImplementedBy(implementationType).LifestyleTransient()),
new[] { typeof(IController) }, new[] { siteMapProviderAssembly }, new Type[0], string.Empty);
container.Register(
Component.For <ISiteMapNodeVisibilityProviderStrategy>()
.ImplementedBy <SiteMapNodeVisibilityProviderStrategy>()
.DependsOn(Dependency.OnValue("defaultProviderName", string.Empty)));
container.Register(Component.For <ControllerBuilder>().Instance(ControllerBuilder.Current));
container.Register(
Component.For <IControllerTypeResolverFactory>()
.ImplementedBy <ControllerTypeResolverFactory>()
.DependsOn(Dependency.OnValue("areaNamespacesToIgnore", new string[0])));
container.Register(
Component.For <IAclModule>()
.ImplementedBy <CompositeAclModule>()
.DependsOn(Dependency.OnComponentCollection <IEnumerable <IAclModule> >(typeof(AuthorizeAttributeAclModule),
typeof(XmlRolesAclModule))));
container.Register(Component.For <IAclModule>().ImplementedBy <AuthorizeAttributeAclModule>());
container.Register(Component.For <IAclModule>().ImplementedBy <XmlRolesAclModule>());
container.Register(Component.For <ObjectCache>().Instance(MemoryCache.Default));
container.Register(Component.For(typeof(ICacheProvider <>)).ImplementedBy(typeof(RuntimeCacheProvider <>)));
container.Register(
Component.For <ICacheDependency>()
.ImplementedBy <RuntimeFileCacheDependency>()
.Named("cacheDependency1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
container.Register(
Component.For <ICacheDetails>()
.ImplementedBy <CacheDetails>()
.Named("cacheDetails1")
.DependsOn(Dependency.OnValue("absoluteCacheExpiration", absoluteCacheExpiration))
.DependsOn(Dependency.OnValue("slidingCacheExpiration", TimeSpan.MinValue))
.DependsOn(ServiceOverride.ForKey <ICacheDependency>().Eq("cacheDependency1")));
container.Register(Component.For <ISiteMapNodeVisitor>().ImplementedBy <UrlResolvingSiteMapNodeVisitor>());
container.Register(
Component.For <IXmlSource>()
.ImplementedBy <FileXmlSource>()
.Named("xmlSource1")
.DependsOn(Dependency.OnValue("fileName", absoluteFileName)));
container.Register(
Component.For <IReservedAttributeNameProvider>()
.ImplementedBy <ReservedAttributeNameProvider>()
.DependsOn(Dependency.OnValue("attributesToIgnore", new string[0])));
container.Register(
Component.For <ISiteMapNodeProvider>()
.ImplementedBy <CompositeSiteMapNodeProvider>()
.Named("siteMapNodeProvider1")
.DependsOn(Dependency.OnComponentCollection <ISiteMapNodeProvider[]>("xmlSiteMapNodeProvider1",
"reflectionSiteMapNodeProvider1")));
container.Register(
Component.For <ISiteMapNodeProvider>()
.ImplementedBy <XmlSiteMapNodeProvider>()
.Named("xmlSiteMapNodeProvider1")
.DependsOn(Dependency.OnValue("includeRootNode", true))
.DependsOn(Dependency.OnValue("useNestedDynamicNodeRecursion", false))
.DependsOn(ServiceOverride.ForKey <IXmlSource>().Eq("xmlSource1")));
container.Register(
Component.For <ISiteMapNodeProvider>()
.ImplementedBy <ReflectionSiteMapNodeProvider>()
.Named("reflectionSiteMapNodeProvider1")
.DependsOn(Dependency.OnValue("includeAssemblies", includeAssembliesForScan))
.DependsOn(Dependency.OnValue("excludeAssemblies", new string[0])));
container.Register(
Component.For <ISiteMapBuilder>()
.ImplementedBy <SiteMapBuilder>()
.Named("builder1")
.DependsOn(ServiceOverride.ForKey <ISiteMapNodeProvider>().Eq("siteMapNodeProvider1")));
container.Register(
Component.For <ISiteMapBuilderSet>()
.ImplementedBy <SiteMapBuilderSet>()
.Named("siteMapBuilderSet1")
.DependsOn(Dependency.OnValue("instanceName", "default"))
.DependsOn(Dependency.OnValue("securityTrimmingEnabled", securityTrimmingEnabled))
.DependsOn(Dependency.OnValue("enableLocalization", enableLocalization))
.DependsOn(Dependency.OnValue("visibilityAffectsDescendants", visibilityAffectsDescendants))
.DependsOn(Dependency.OnValue("useTitleIfDescriptionNotProvided", useTitleIfDescriptionNotProvided))
.DependsOn(ServiceOverride.ForKey <ISiteMapBuilder>().Eq("builder1"))
.DependsOn(ServiceOverride.ForKey <ICacheDetails>().Eq("cacheDetails1")));
container.Register(
Component.For <ISiteMapBuilderSetStrategy>()
.ImplementedBy <SiteMapBuilderSetStrategy>()
.DependsOn(Dependency.OnComponentCollection <ISiteMapBuilderSet[]>("siteMapBuilderSet1")));
}
