public void Install(IWindsorContainer container, IConfigurationStore store)
{
string codeBase = Assembly.GetExecutingAssembly().CodeBase;
UriBuilder uri = new UriBuilder(codeBase);
string path = Uri.UnescapeDataString(uri.Path);
path = Uri.UnescapeDataString(Path.GetDirectoryName(path));
var filter = new AssemblyFilter(path);
container.Register(
Component.For <LogInterceptor>());
container.Register(
Component.For <TimerInterceptor>());
container.Kernel.ComponentRegistered += KernelOnComponentRegistered;
container.Register(
Classes.
FromAssemblyInDirectory(filter).
BasedOn <IMyService>().
WithServiceAllInterfaces().
LifestyleTransient()
);
}
public static void Init()
{
AssemblyFilter assemblyFilter = new AssemblyFilter(AppDomain.CurrentDomain.BaseDirectory);
_Container.Register(
Component.For <IWindsorContainer>().Instance(_Container).LifestyleSingleton(),
//Classes.FromAssemblyContaining(typeof(ISession)).BasedOn<ISession>().WithService.FromInterface(typeof(ISession)).LifestyleSingleton(),
Classes.FromAssemblyInDirectory(assemblyFilter).AllowMultipleMatches().BasedOn <ISecurityChecker>().WithService.FromInterface(typeof(ISecurityChecker)).LifestyleSingleton(),
Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <IControl>().WithService.FromInterface(typeof(IControl)).LifestyleTransient(), // transient must come before singletons !!!
Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <IWindow>().WithService.FromInterface(typeof(IWindow)).LifestyleSingleton(),
Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <IControlViewModel>().WithService.FromInterface(typeof(IControlViewModel)).LifestyleTransient(), // transient must come before singletons !!!
Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <IWindowViewModel>().WithService.FromInterface(typeof(IWindowViewModel)).LifestyleSingleton()
//Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn<IRegistrar>().WithService.FromInterface(typeof(IRegistrar)).LifestyleSingleton().AllowMultipleMatches()
);
//var otherRegisterars = _Container.ResolveAll<IRegistrar>(new Dictionary<string, IWindsorContainer>() { { "container", _Container } }).ToList();
Console.WriteLine("** Dumping bootstrapper :");
foreach (var handler in _Container.Kernel.GetAssignableHandlers(typeof(object)))
{
foreach (var service in handler.ComponentModel.Services)
{
Console.WriteLine("** {0} => {1}", service.FullName, handler.ComponentModel.Implementation.FullName);
}
}
//otherRegisterars.ForEach(x => Console.WriteLine($"IRegistrar: {x.GetType().FullName}"));
//otherRegisterars.ForEach(x => x.Init());
}
public void No_Match_When_Empty_And_Name_Is_Null()
{
var filter = new AssemblyFilter();
bool result = filter.Match(null);
Assert.IsFalse(result);
}
private void RegisterExtensions(IWindsorContainer container)
{
var extensionsPath = Server.MapPath("~/bin");
var extensionAssemblyFilter = new AssemblyFilter(extensionsPath, "*.Migration.dll");
container.Register(
AllTypes.FromAssemblyInDirectory(extensionAssemblyFilter)
.BasedOn<IRepository>()
.ConfigureFor<IRepository>(
registration => {
registration.LifeStyle.Is(LifestyleType.Transient);
registration.Named(registration.Implementation.Name);
})
.WithService
.Select(new[] {typeof(IRepository)}),
AllTypes.FromAssemblyInDirectory(extensionAssemblyFilter)
.BasedOn<IServiceLocator>()
.ConfigureFor<IServiceLocator>(
registration =>
{
registration.LifeStyle.Is(LifestyleType.Transient);
registration.Named(registration.Implementation.Name);
})
.WithService.Select(new[] {typeof(IServiceLocator)}),
Component.For<SearchHub>()
.ImplementedBy<SearchHub>()
.LifeStyle.Is(LifestyleType.PerWebRequest)
);
}
public void No_Match_When_No_Name_Is_Added()
{
var filter = new AssemblyFilter();
bool result = filter.Match(typeof(string).Assembly.FullName);
Assert.IsFalse(result);
}
private static IEnumerable<Type> GetAllLoadedTypes(AssemblyFilter assemblyFilter = null)
{
return AppDomain.CurrentDomain
.GetAssemblies()
.Where(x => assemblyFilter(x))
.SelectMany(x => x.GetExportedTypes());
}
public void ToStringTest(bool expectedMatch, Type type)
{
string assemblyName = type.Assembly.GetName().Name;
AssemblyFilter<ITestDescriptor> filter = new AssemblyFilter<ITestDescriptor>(
new EqualityFilter<string>(assemblyName));
Assert.AreEqual("Assembly(Equality('" + assemblyName + "'))", filter.ToString());
}
public void ToStringTest(bool expectedMatch, Type type)
{
string assemblyName = type.Assembly.GetName().Name;
AssemblyFilter <ITestDescriptor> filter = new AssemblyFilter <ITestDescriptor>(
new EqualityFilter <string>(assemblyName));
Assert.AreEqual("Assembly(Equality('" + assemblyName + "'))", filter.ToString());
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
AssemblyFilter assemblyFilter = new AssemblyFilter(_assemblyDirectoryName, mask: _mask);
container.Register(Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn()
.Configure(p => p.LifestyleScoped()
));
}
/// <summary>
/// Find dll files in a directory and its sub directories.
/// </summary>
/// <param name="path">The directory to search in.</param>
/// <returns>A List of paths to found Assemblies.</returns>
public static List <string> GetAssemblies(string path, AssemblyFilter assemblyFilter)
{
List <string> assemblies = new List <string>();
GetAssemblies(assemblies, path, assemblyFilter);
return(assemblies);
}
public static IWindsorContainer AddService(this IWindsorContainer container)
{
var filterByAssembly = new AssemblyFilter(Path.Combine(PlatformServices.Default.Application.ApplicationBasePath));
container.Register(Classes.FromAssemblyNamed("Service")
.Where(t => t.Name.EndsWith("Service")).WithServiceAllInterfaces().LifestyleScoped());
return(container);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
AssemblyFilter library = new AssemblyFilter(@"C:\scratch\MinusEight.Portal.UI\Library\");
container.Register(Classes.FromAssemblyInDirectory(library)
.BasedOn<IController>()
.LifestyleTransient());
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
AssemblyFilter assemblyFilter = new AssemblyFilter(AppDomain.CurrentDomain.BaseDirectory + "/bin");
container.Register(Classes.FromAssemblyInDirectory(assemblyFilter)
.BasedOn <IService>()
.WithServiceFirstInterface()
.LifestyleTransient());
}
/// <summary>
/// Implementation registers all MVC Controllers (IController).
/// </summary>
/// <param name="container"> windsor container. </param>
/// <param name="store"> Configuration store. </param>
public void Install(IWindsorContainer container, IConfigurationStore store)
{
var directoryfilter = new AssemblyFilter("bin");
if (container == null)
{
return;
}
//// Resolve all Mappings
container.Register(Classes.FromAssemblyInDirectory(directoryfilter)
.Where(x => x.IsPublic && x.Namespace != null && x.Namespace.EndsWith("Mapping", StringComparison.Ordinal))
.WithService.DefaultInterfaces()
.LifestyleTransient());
//// Resolve all repositories
container.Register(
Classes.FromAssemblyInDirectory(directoryfilter)
.Where(x => x.IsPublic && x.Namespace != null && x.Namespace.EndsWith("ObjectContext", StringComparison.Ordinal))
.WithService.DefaultInterfaces()
.LifestyleTransient());
//// Resolve all repositories
container.Register(
Classes.FromAssemblyInDirectory(directoryfilter)
.Where(x => x.IsPublic && x.Namespace != null && x.Namespace.EndsWith("Repository", StringComparison.Ordinal))
.WithService.DefaultInterfaces()
.LifestyleTransient());
//// Resolve all business layers
container.Register(
Classes.FromAssemblyInDirectory(directoryfilter)
.Where(x => x.IsPublic && x.Namespace != null && x.Namespace.EndsWith("Business", StringComparison.Ordinal))
.WithService.DefaultInterfaces()
.LifestyleTransient());
//// Resolve all database connection manager
container.Register(
Classes.FromAssemblyInDirectory(directoryfilter)
.Where(x => x.IsPublic && x.Namespace != null && x.Namespace.EndsWith("ConnectionManager", StringComparison.Ordinal))
.WithService.DefaultInterfaces()
.LifestyleTransient());
//// Resolve all Operation manager
container.Register(
Classes.FromAssemblyInDirectory(directoryfilter)
.Where(x => x.IsPublic && x.Namespace != null && x.Namespace.EndsWith("OperationManager", StringComparison.Ordinal))
.WithService.DefaultInterfaces()
.LifestyleTransient());
//// Resolve Basic Controller
container.Register(Classes.FromThisAssembly().BasedOn<IController>().LifestylePerWebRequest());
//// Resolve WebAPI
container.Register(Classes.FromThisAssembly().BasedOn<ApiController>().LifestylePerWebRequest());
}
public static void GetAssemblies(List <string> assemblies, string path, AssemblyFilter assemblyFilter)
{
var assemblyFiles = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);
foreach (var assembly in assemblyFiles)
{
AssemblyDefinition assemblyDefinition;
try
{
assemblyDefinition = Mono.Cecil.AssemblyDefinition.ReadAssembly(assembly);
}
catch (Exception e)
{
LogUtility.LogDebug(e.Message);
continue;
}
string name = assemblyDefinition.Name.Name;
if (name == "ModTool" || name.StartsWith("ModTool."))
{
if ((assemblyFilter & AssemblyFilter.ModToolAssemblies) != 0)
{
assemblies.Add(assembly);
}
continue;
}
if (name.Contains("Mono.Cecil"))
{
if ((assemblyFilter & AssemblyFilter.ModToolAssemblies) != 0)
{
assemblies.Add(assembly);
}
continue;
}
if (CodeSettings.apiAssemblies.Contains(name))
{
if ((assemblyFilter & AssemblyFilter.ApiAssemblies) != 0)
{
assemblies.Add(assembly);
}
continue;
}
if ((assemblyFilter & AssemblyFilter.ModAssemblies) != 0)
{
assemblies.Add(assembly);
}
}
}
public void Match_When_Valid_Name_Is_Added()
{
var filter = new AssemblyFilter();
filter.AddFilter("mscorlib");
bool result = filter.Match(typeof(string).Assembly.FullName);
Assert.IsTrue(result);
}
/// <summary>Prepares to register types from assemblies found in a given directory that meet additional optional restrictions.</summary>
/// <param name = "filter"> </param>
/// <returns> </returns>
public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
var assemblies = ReflectionUtil.GetAssemblies(filter);
return(new FromAssemblyDescriptor(assemblies, Filter));
}
public void No_Match_When_Valid_And_Name_Is_Null()
{
var filter = new AssemblyFilter();
filter.AddFilter("mscorlib");
bool result = filter.Match(null);
Assert.IsFalse(result);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
AssemblyFilter library = new AssemblyFilter(@"C:\scratch\MinusEight.Portal.UI\Library\");
container.Register(Classes.FromAssemblyInDirectory(library)
.BasedOn<IService>()
.WithService.FirstInterface()
.LifestylePerWebRequest());
}
private static void Bootstrap()
{
var directoryFilter = new AssemblyFilter(HostingEnvironment.MapPath("~/Plugins"));
container = new WindsorContainer()
.Install(new AssemblyInstaller())
.Install(FromAssembly.InDirectory(directoryFilter));
var controllerFactory = new WindsorControllerFactory(container.Kernel);
ControllerBuilder.Current.SetControllerFactory(controllerFactory);
}
/// <summary>
/// Scans assemblies in directory specified by <paramref name = "filter" /> for types implementing <see cref = "IWindsorInstaller" />, instantiates using given <see cref = "InstallerFactory" /> and
/// returns so that <see cref = "IWindsorContainer.Install" /> can install them.
/// </summary>
/// <param name = "filter"> </param>
/// <param name = "installerFactory"> </param>
/// <returns> </returns>
public static IWindsorInstaller InDirectory(AssemblyFilter filter, InstallerFactory installerFactory)
{
var assemblies = new HashSet <Assembly>(ReflectionUtil.GetAssemblies(filter));
var installer = new CompositeInstaller();
foreach (var assembly in assemblies)
{
installer.Add(Instance(assembly, installerFactory));
}
return(installer);
}
public static void Bootstrap()
{
if (!bootstrapped)
{
WindsorContainer = new WindsorContainer();
var assemblFilter = new AssemblyFilter(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin"));
Descriptor = Classes.FromAssemblyInDirectory(assemblFilter);
WindsorContainer.Install(FromAssembly.InDirectory(assemblFilter));
bootstrapped = true;
}
}
public static void GetAssemblies(List <string> assemblies, string path, AssemblyFilter assemblyFilter)
{
var assemblyFiles = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);
foreach (var assembly in assemblyFiles)
{
AssemblyDefinition assemblyDefinition;
try
{
assemblyDefinition = Mono.Cecil.AssemblyDefinition.ReadAssembly(assembly);
}
catch
{
continue;
}
if (assemblyDefinition.Name.FullName.Contains("ModTool"))
{
if ((assemblyFilter & AssemblyFilter.ModToolAssemblies) != 0)
{
assemblies.Add(assembly);
}
continue;
}
if (assemblyDefinition.Name.FullName.Contains("Mono.Cecil"))
{
if ((assemblyFilter & AssemblyFilter.ModToolAssemblies) != 0)
{
assemblies.Add(assembly);
}
continue;
}
if (CodeSettings.apiAssemblies.Contains(assemblyDefinition.Name.Name))
{
if ((assemblyFilter & AssemblyFilter.ApiAssemblies) != 0)
{
assemblies.Add(assembly);
}
continue;
}
if ((assemblyFilter & AssemblyFilter.ModAssemblies) != 0)
{
assemblies.Add(assembly);
}
}
}
public void No_Match_When_Name_Is_Added_And_List_Is_Cleared()
{
var filter = new AssemblyFilter();
filter.AddFilter("mscorlib");
filter.Clear();
bool result = filter.Match(typeof(string).Assembly.FullName);
Assert.IsFalse(result);
}
private static void Bootstrap()
{
var directoryFilter = new AssemblyFilter(HostingEnvironment.MapPath("~/Plugins"));
container = new WindsorContainer()
.Install(new AssemblyInstaller())
.Install(FromAssembly.InDirectory(directoryFilter));
var controllerFactory = new WindsorControllerFactory(container.Kernel);
ControllerBuilder.Current.SetControllerFactory(controllerFactory);
}
public static void RegisterAllPluginsInDirectory(this IWindsorContainer container, AssemblyFilter filter)
{
var assemblies = AllTypes.FromAssemblyInDirectory(filter);
container.Register(assemblies.BasedOn<INotificationRegistration>().Configure(c => c.LifeStyle.Transient));
var registrations = container.ResolveAll<INotificationRegistration>();
foreach (var registration in registrations)
foreach (var component in registration.RegisterComponents())
container.Register(Component.For(component.GetType()).Instance(component));
container.Register(assemblies.BasedOn<AbstractNotificationSystem>().Configure(c => c.LifeStyle.Transient));
}
public static IWindsorContainer AddMediator(this IWindsorContainer container)
{
container.Register(Component.For <IMediator>().ImplementedBy <Mediator>().LifestyleTransient());
container.Register(Component.For <InnerInstanceFactory>()
.UsingFactoryMethod <InnerInstanceFactory>(k => t => k.Resolve(t)));
container.Register(Component.For <PreInstanceFactory>()
.UsingFactoryMethod <PreInstanceFactory>(k => t =>
{
if (k.HasComponent(t))
{
return(k.Resolve(t));
}
return(null);
}));
container.Register(Component.For <PostInstanceFactory>()
.UsingFactoryMethod <PostInstanceFactory>(k => t =>
{
if (k.HasComponent(t))
{
return(k.Resolve(t));
}
return(null);
}));
var filterByAssembly = new AssemblyFilter(Path.Combine(PlatformServices.Default.Application.ApplicationBasePath));
var assembly = Classes.FromAssemblyInDirectory(filterByAssembly);
container.Register(assembly.BasedOn(typeof(IPreProcessor <>))
.WithServiceAllInterfaces().LifestyleTransient());
container.Register(
assembly.BasedOn(typeof(IPostProcessor <>)).WithServiceAllInterfaces().LifestyleTransient());
container.Register(assembly
.BasedOn(typeof(IAsyncCommandHandler <,>))
.Configure(f => f.IsFallback())
.WithService.AllInterfaces()
.LifestyleTransient());
container.Register(assembly
.BasedOn(typeof(IAsyncQueryHandler <,>))
.Configure(f => f.IsFallback())
.WithService.AllInterfaces()
.LifestyleTransient());
return(container);
}
private static void InitializeCastle()
{
var currentAssembly = System.Reflection.Assembly.GetExecutingAssembly();
var codeBaseAbsolutePathUri = new Uri(currentAssembly.GetName().CodeBase).AbsolutePath;
var path = Uri.UnescapeDataString(System.IO.Path.GetDirectoryName(codeBaseAbsolutePathUri));
var filter = new AssemblyFilter(path);
var castle = new WindsorContainer();
castle.AddFacility <TypedFactoryFacility>();
castle.Install(FromAssembly.InDirectory(filter));
container = castle;
}
private void AddInstaller(IConfiguration installer, Dictionary <Type, IWindsorInstaller> cache,
IConversionManager conversionManager, ICollection <Assembly> assemblies)
{
var typeName = installer.Attributes["type"];
if (string.IsNullOrEmpty(typeName) == false)
{
var type = conversionManager.PerformConversion <Type>(typeName);
AddInstaller(cache, type);
return;
}
assemblyName = installer.Attributes["assembly"];
if (string.IsNullOrEmpty(assemblyName) == false)
{
var assembly = ReflectionUtil.GetAssemblyNamed(assemblyName);
if (assemblies.Contains(assembly))
{
return;
}
assemblies.Add(assembly);
GetAssemblyInstallers(cache, assembly);
return;
}
var directory = installer.Attributes["directory"];
var mask = installer.Attributes["fileMask"];
var token = installer.Attributes["publicKeyToken"];
Debug.Assert(directory != null, "directory != null");
var assemblyFilter = new AssemblyFilter(directory, mask);
if (token != null)
{
assemblyFilter.WithKeyToken(token);
}
foreach (var assembly in ReflectionUtil.GetAssemblies(assemblyFilter))
{
if (assemblies.Contains(assembly))
{
continue;
}
assemblies.Add(assembly);
GetAssemblyInstallers(cache, assembly);
}
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
AssemblyFilter assemblyFilter = new AssemblyFilter(_assemblyDirectoryName, mask: _mask);
container.Register(
Classes.FromAssemblyInDirectory(assemblyFilter)
.BasedOn <ISingletonDependecy>()
.WithServiceSelect(ServiceSelector).LifestyleSingleton()
);
container.Register(Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <IScopedDependency>()
.WithServiceSelect(ServiceSelector).LifestyleScoped()
);
container.Register(Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <ITransactionDependecy>()
.WithServiceSelect(ServiceSelector).Configure(p => p.LifestyleScoped()));
container.Register(Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <ITransientDependecy>()
.WithServiceSelect(ServiceSelector).Configure(p => p.LifestyleTransient()));
}
protected override void Init()
{
var filter = new AssemblyFilter(AppDomain.CurrentDomain.BaseDirectory, "QuadAuto.Server.*.dll");
var x =
AllTypes.FromAssemblyInDirectory(filter).BasedOn<IConsumer>().WithServiceSelect(
(t, b) => new[] {t, typeof (IConsumer)});
Kernel.Register(x);
var y =
AllTypes.FromThisAssembly().BasedOn<IConsumer>().WithServiceSelect(
(t, b) => new[] {t, typeof (IConsumer)});
Kernel.Register(y);
Kernel.Register(Component.For<IServiceBus>().UsingFactoryMethod(ConfigureServiceBus));
}
protected override void Init()
{
var filter = new AssemblyFilter(AppDomain.CurrentDomain.BaseDirectory, "QuadAuto.Server.*.dll");
var x =
AllTypes.FromAssemblyInDirectory(filter).BasedOn <IConsumer>().WithServiceSelect(
(t, b) => new[] { t, typeof(IConsumer) });
Kernel.Register(x);
var y =
AllTypes.FromThisAssembly().BasedOn <IConsumer>().WithServiceSelect(
(t, b) => new[] { t, typeof(IConsumer) });
Kernel.Register(y);
Kernel.Register(Component.For <IServiceBus>().UsingFactoryMethod(ConfigureServiceBus));
}
public void FromAssemblyMatchingNamed_should_be_instantiatable_with_assemblyPrefix_and_assemblyFilter()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
const string assemblyPrefix = "Fluent";
var assemblyFilter = new AssemblyFilter(AppDomain.CurrentDomain.GetActualDomainPath());
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
FromAssemblyDefiner instance = AssemblyScanner.FromAssemblyMatchingNamed(assemblyPrefix, assemblyFilter);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
instance.Should().NotBeNull();
}
protected override void Init()
{
if (!Kernel.GetFacilities()
.Any(z => z.GetType().Equals(typeof (TypedFactoryFacility))))
Kernel.AddFacility<TypedFactoryFacility>();
var filter = new AssemblyFilter(AppDomain.CurrentDomain.BaseDirectory, "QuadAuto.Server.*.dll");
Kernel.Register(
Classes.FromAssemblyInDirectory(filter).BasedOn<IConsumer>().WithService.Self().WithService.
FromInterface(
typeof (IConsumer)).Configure(c => c.Properties(PropertyFilter.RequireBase)));
Kernel.Register(
Classes.FromThisAssembly().BasedOn<IConsumer>().WithService.Self().WithService.FromInterface(
typeof (IConsumer)).Configure(c => c.Properties(PropertyFilter.RequireBase)));
Kernel.Register(Component.For<IServiceBus>().UsingFactoryMethod(ConfigureServiceBus));
}
//variable lari doldurmak için
public static void Bootstrap()
{
if (!bootstrapped)
{
WindsorContainer = new WindsorContainer();
//bin içindeki dll leri alıyoruz.
//ana dizindeki bin klasöründeki dll leri aldık
var assemblyFilter = new AssemblyFilter(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin"));
//filter ile belirtilen dosyadaki bütün class ları doldur
Descriptor = Classes.FromAssemblyInDirectory(assemblyFilter);
//instal et assembly filter icindeki dll leri
WindsorContainer.Install(FromAssembly.InDirectory(assemblyFilter));
bootstrapped = true;
}
}
private static void RegisterControllerActivator(IWindsorContainer container)
{
GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerActivator),
new WindsorCompositionRoot(container));
container.Register(
Classes.FromAssemblyContaining <ILoggingService>()
.BasedOn <IService>()
.WithService.FirstInterface().LifestyleTransient());
container.Register(
Classes.FromAssemblyContaining <ILoggingService>()
.BasedOn <IHelper>()
.WithService.FirstInterface().LifestyleSingleton());
container.Register(
Classes.FromAssemblyContaining <IAPIConfigurationHelper>()
.BasedOn <IService>()
.WithService.FirstInterface().LifestyleTransient());
container.Register(
Classes.FromAssemblyContaining <IAPIConfigurationHelper>()
.BasedOn <IHelper>()
.WithService.FirstInterface().LifestyleSingleton());
var filter = new AssemblyFilter(HttpRuntime.BinDirectory, "CodingChallenge.*.dll");
container.Register(
Classes.FromAssemblyInDirectory(filter)
.BasedOn <IValidationService>()
.WithService.FirstInterface().LifestyleTransient());
container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel, true));
Mapper.Initialize(m =>
{
m.ConstructServicesUsing(container.Resolve);
m.AddProfile <APIMappingProfile>();
});
Mapper.AssertConfigurationIsValid();
}
protected override void Init()
{
if (!Kernel.GetFacilities()
.Any(z => z.GetType().Equals(typeof(TypedFactoryFacility))))
{
Kernel.AddFacility <TypedFactoryFacility>();
}
var filter = new AssemblyFilter(AppDomain.CurrentDomain.BaseDirectory, "QuadAuto.Server.*.dll");
Kernel.Register(
Classes.FromAssemblyInDirectory(filter).BasedOn <IConsumer>().WithService.Self().WithService.
FromInterface(
typeof(IConsumer)).Configure(c => c.Properties(PropertyFilter.RequireBase)));
Kernel.Register(
Classes.FromThisAssembly().BasedOn <IConsumer>().WithService.Self().WithService.FromInterface(
typeof(IConsumer)).Configure(c => c.Properties(PropertyFilter.RequireBase)));
Kernel.Register(Component.For <IServiceBus>().UsingFactoryMethod(ConfigureServiceBus));
}
// Private Helpers
private static void RegisterByConvention(Container container, AssemblyFilter assemblyFilter, Convention implementationFilter, Convention decoratorFilter, Lifestyle lifestyle)
{
var types = GetAllLoadedTypes(assemblyFilter);
var registrations = from service in types
let implementations = from implementation in types
where implementation.IsConcreteTypeThatImplements(service)
&& implementationFilter(service, implementation)
select implementation
let decorators = from decorator in types
where decorator.IsConcreteTypeThatImplements(service)
&& decoratorFilter(service, decorator)
select decorator
where service.IsInterface
&& !container.HasAlreadyRegistered(service)
select new
{
Service = service,
Implementations = implementations,
Decorators = decorators
};
foreach (var registration in registrations)
{
if (registration.Implementations.Count() == 1)
{
container.Register(registration.Service, registration.Implementations.First(), lifestyle);
}
else if (registration.Implementations.Count() > 1)
{
container.RegisterCollection(registration.Service, registration.Implementations);
}
foreach (var decorator in registration.Decorators)
{
container.RegisterDecorator(registration.Service, decorator);
}
}
}
public static IEnumerable<Assembly> FindAssemblies(AssemblyLoadFailure loadFailure, bool includeExeFiles, AssemblyFilter filter)
{
var assemblyPath = AppDomain.CurrentDomain.BaseDirectory;
var binPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
if (string.IsNullOrEmpty(binPath))
{
return FindAssemblies(assemblyPath, loadFailure, includeExeFiles, filter);
}
if (Path.IsPathRooted(binPath))
{
return FindAssemblies(binPath, loadFailure, includeExeFiles, filter);
}
string[] binPaths = binPath.Split(';');
return binPaths.SelectMany(bin =>
{
var path = Path.Combine(assemblyPath, bin);
return FindAssemblies(path, loadFailure, includeExeFiles, filter);
});
}
static void Main(string[] args)
{
string pluginsFolder = Path.GetFullPath(@"..\..\..\Plugins");
AssemblyFilter assemblyFilter = new AssemblyFilter(pluginsFolder);
var rootContainer = new WindsorContainer();
rootContainer.Register(Component.For <MyRootService>());
rootContainer.Register(Classes.FromAssemblyInDirectory(assemblyFilter).BasedOn <IDemoPlugin>().WithService.FromInterface());
IDemoPlugin[] plugins = rootContainer.ResolveAll <IDemoPlugin>();
Console.WriteLine($"In folder {pluginsFolder} found {plugins.Length} plugins.");
foreach (IDemoPlugin plugin in plugins)
{
plugin.Run(null);
}
rootContainer.Resolve <MyRootService>().Run("root");
WindsorContainer childContainer = new WindsorContainer();
childContainer.Register(Component.For <MyChildService>());
rootContainer.AddChildContainer(childContainer);
childContainer.Resolve <MyRootService>().Run("child");
childContainer.Resolve <MyChildService>().Run("child");
try
{
Console.WriteLine("trying to resolve MyChildContainer in root container...");
rootContainer.Resolve <MyChildService>().Run("root");
}
catch (Exception e)
{
Console.WriteLine($"Cannot resolve in root: {e.Message}");
}
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
}
public static IEnumerable <Assembly> FindAssemblies(string assemblyPath, AssemblyLoadFailure loadFailure, bool includeExeFiles, AssemblyFilter filter)
{
LogContext.Debug?.Log("Scanning assembly directory: {Path}", assemblyPath);
IEnumerable <string> dllFiles = Directory.EnumerateFiles(assemblyPath, "*.dll", SearchOption.AllDirectories).ToList();
IEnumerable <string> files = dllFiles;
if (includeExeFiles)
{
IEnumerable <string> exeFiles = Directory.EnumerateFiles(assemblyPath, "*.exe", SearchOption.AllDirectories).ToList();
files = dllFiles.Concat(exeFiles);
}
foreach (var file in files)
{
var name = Path.GetFileNameWithoutExtension(file);
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
var filterName = Path.GetFileName(file);
if (!filter(filterName))
{
LogContext.Debug?.Log("Filtered assembly: {File}", file);
continue;
}
Assembly assembly = null;
try
{
assembly = Assembly.ReflectionOnlyLoad(name);
}
catch (BadImageFormatException exception)
{
LogContext.Warning?.Log(exception, "Assembly Scan failed: {Name}", name);
continue;
}
catch (Exception originalException)
{
try
{
assembly = Assembly.ReflectionOnlyLoad(file);
}
catch (Exception)
{
loadFailure(file, originalException);
}
}
if (assembly != null)
{
Assembly loadedAssembly = null;
try
{
loadedAssembly = Assembly.Load(name);
}
catch (BadImageFormatException exception)
{
LogContext.Warning?.Log(exception, "Assembly Scan failed: {Name}", name);
continue;
}
catch (Exception originalException)
{
try
{
loadedAssembly = Assembly.Load(file);
}
catch (Exception)
{
loadFailure(file, originalException);
}
}
if (loadedAssembly != null)
{
yield return(loadedAssembly);
}
}
}
}
public static IEnumerable <Assembly> FindAssemblies(AssemblyLoadFailure loadFailure, bool includeExeFiles, AssemblyFilter filter)
{
var assemblyPath = AppDomain.CurrentDomain.BaseDirectory;
var binPath = string.Empty;
if (string.IsNullOrEmpty(binPath))
{
return(FindAssemblies(assemblyPath, loadFailure, includeExeFiles, filter));
}
if (Path.IsPathRooted(binPath))
{
return(FindAssemblies(binPath, loadFailure, includeExeFiles, filter));
}
string[] binPaths = binPath.Split(';');
return(binPaths.SelectMany(bin =>
{
var path = Path.Combine(assemblyPath, bin);
return FindAssemblies(path, loadFailure, includeExeFiles, filter);
}));
}
private void AddInstaller(IConfiguration installer, Dictionary<Type, IWindsorInstaller> cache,
IConversionManager conversionManager, ICollection<Assembly> assemblies)
{
var typeName = installer.Attributes["type"];
if (string.IsNullOrEmpty(typeName) == false)
{
var type = conversionManager.PerformConversion<Type>(typeName);
AddInstaller(cache, type);
return;
}
assemblyName = installer.Attributes["assembly"];
if (string.IsNullOrEmpty(assemblyName) == false)
{
var assembly = ReflectionUtil.GetAssemblyNamed(assemblyName);
if (assemblies.Contains(assembly))
{
return;
}
assemblies.Add(assembly);
GetAssemblyInstallers(cache, assembly);
return;
}
var directory = installer.Attributes["directory"];
var mask = installer.Attributes["fileMask"];
var token = installer.Attributes["publicKeyToken"];
Debug.Assert(directory != null, "directory != null");
var assemblyFilter = new AssemblyFilter(directory, mask);
if (token != null)
{
assemblyFilter.WithKeyToken(token);
}
foreach (var assembly in ReflectionUtil.GetAssemblies(assemblyFilter))
{
if (assemblies.Contains(assembly))
{
continue;
}
assemblies.Add(assembly);
GetAssemblyInstallers(cache, assembly);
}
}
public void Can_Determine_Class_Name()
{
var reflectionHelper = new AssemblyFilter(typeof(Animal).Assembly);
Assert.That(reflectionHelper.Types.Contains(typeof(Animal)));
}
/// <summary>
/// registers all the hubs in the assemblies specified by the filter
/// </summary>
/// <param name="filter">The filter.</param>
public HubsInstallers(AssemblyFilter filter)
{
_descriptor = AllTypes.FromAssemblyInDirectory(filter);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="filter"></param>
public AllHttpModulesRegistry(AssemblyFilter filter) {
Filter = filter;
}
public static IEnumerable<Assembly> FindAssemblies(string assemblyPath, AssemblyLoadFailure loadFailure, bool includeExeFiles, AssemblyFilter filter)
{
if (_log.IsDebugEnabled)
_log.Debug($"Scanning assembly directory: {assemblyPath}");
IEnumerable<string> dllFiles = Directory.EnumerateFiles(assemblyPath, "*.dll", SearchOption.AllDirectories).ToList();
IEnumerable<string> files = dllFiles;
if (includeExeFiles)
{
IEnumerable<string> exeFiles = Directory.EnumerateFiles(assemblyPath, "*.exe", SearchOption.AllDirectories).ToList();
files = dllFiles.Concat(exeFiles);
}
foreach (var file in files)
{
var name = Path.GetFileNameWithoutExtension(file);
if (string.IsNullOrWhiteSpace(name))
continue;
var filterName = Path.GetFileName(file);
if (!filter(filterName))
{
if (_log.IsDebugEnabled)
_log.Debug($"Filtered assembly: {file}");
continue;
}
Assembly assembly = null;
try
{
assembly = Assembly.ReflectionOnlyLoad(name);
}
catch (BadImageFormatException exception)
{
_log.Debug($"Bad Image Format: {name}", exception);
continue;
}
catch (Exception originalException)
{
try
{
assembly = Assembly.ReflectionOnlyLoad(file);
}
catch (Exception)
{
loadFailure(file, originalException);
}
}
if (assembly != null)
{
Assembly loadedAssembly = null;
try
{
loadedAssembly = Assembly.Load(name);
}
catch (BadImageFormatException exception)
{
_log.Debug($"Bad Image Format: {name}", exception);
continue;
}
catch (Exception originalException)
{
try
{
loadedAssembly = Assembly.Load(file);
}
catch (Exception)
{
loadFailure(file, originalException);
}
}
if (loadedAssembly != null)
yield return loadedAssembly;
}
}
}
