/// <summary>
/// Scans for types using the provided scanner.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="scanner">The scanner.</param>
public static void Scan(this GenericApplicationContext context, AssemblyObjectDefinitionScanner scanner)
{
var registry = context.ObjectFactory as IObjectDefinitionRegistry;
scanner.ScanAndRegisterTypes(registry);
AttributeConfigUtils.RegisterAttributeConfigProcessors(registry);
}
/// <summary>
/// Configures the scanner.
/// </summary>
/// <param name="parserContext">The parser context.</param>
/// <param name="element">The element.</param>
/// <returns></returns>
protected virtual AssemblyObjectDefinitionScanner ConfigureScanner(ParserContext parserContext, XmlElement element)
{
var scanner = new AssemblyObjectDefinitionScanner();
ParseBaseAssembliesAttribute(scanner, element);
ParseNameGeneratorAttribute(scanner, element);
ParseTypeFilters(scanner, element);
scanner.Defaults = parserContext.ParserHelper.Defaults;
return scanner;
}
/// <summary>
/// Scans for types that satisfy specified predicates located in the specified scan path.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyScanPath">The assembly scan path.</param>
/// <param name="assemblyPredicate">The assembly predicate.</param>
/// <param name="typePredicate">The type predicate.</param>
public static void Scan(this AbstractApplicationContext context, string assemblyScanPath, Predicate<Assembly> assemblyPredicate,
Predicate<Type> typePredicate)
{
//create a scanner instance using the scan path
var scanner = new AssemblyObjectDefinitionScanner(assemblyScanPath);
//configure the scanner per the provided constraints
scanner.WithAssemblyFilter(assemblyPredicate).WithIncludeFilter(typePredicate);
//pass the scanner to primary Scan method to actually do the work
Scan(context, scanner);
}
public void _TestSetup()
{
_scanner = new AssemblyObjectDefinitionScanner();
}
private void ParseTypeFilters(AssemblyObjectDefinitionScanner scanner, XmlElement element)
{
foreach (XmlNode node in element.ChildNodes)
{
if (node.Name.Contains(INCLUDE_FILTER_ELEMENT))
scanner.WithIncludeFilter(CreateTypeFilter(node));
else if (node.Name.Contains(EXCLUDE_FILTER_ELEMENT))
scanner.WithExcludeFilter(CreateTypeFilter(node));
}
}
private void ParseNameGeneratorAttribute(AssemblyObjectDefinitionScanner scanner, XmlElement element)
{
var nameGeneratorString = element.GetAttribute(NAME_GENERATOR_ATTRIBUTE);
var nameGenerator = CustomTypeFactory.GetNameGenerator(nameGeneratorString);
if (nameGenerator != null)
scanner.ObjectNameGenerator = nameGenerator;
}
private void ParseBaseAssembliesAttribute(AssemblyObjectDefinitionScanner scanner, XmlElement element)
{
var baseAssemblies = element.GetAttribute(BASE_ASSEMBLIES_ATTRIBUTE);
if (string.IsNullOrEmpty(baseAssemblies))
return;
foreach (var baseAssembly in baseAssemblies.Split(','))
{
scanner.WithAssemblyFilter(assy => assy.FullName.StartsWith(baseAssembly));
}
}
public void _TestSetup()
{
_context = new CodeConfigApplicationContext();
_scanner = new AssemblyObjectDefinitionScanner();
}
/// <summary>
/// Configures the scanner.
/// </summary>
/// <param name="parserContext">The parser context.</param>
/// <param name="element">The element.</param>
/// <returns></returns>
protected virtual AssemblyObjectDefinitionScanner ConfigureScanner(ParserContext parserContext, XmlElement element)
{
XmlReaderContext readerContext = parserContext.ReaderContext;
bool useDefaultFilters = true;
if (element.HasAttribute("use-default-filters"))
{
useDefaultFilters = bool.Parse(element.GetAttribute("use-default-filters"));
}
AssemblyObjectDefinitionScanner scanner = new AssemblyObjectDefinitionScanner();
return scanner;
}
public void _TestSetup()
{
_scanner = new AssemblyObjectDefinitionScanner();
}
public void _SetUp()
{
_scanner = new AssemblyObjectDefinitionScanner();
_context = new CodeConfigApplicationContext();
}
private void ParseTypeFilters(AssemblyObjectDefinitionScanner scanner, XmlElement element)
{
foreach (XmlNode node in element.ChildNodes)
{
if (node.Name.Contains(INCLUDE_FILTER_ELEMENT))
{
var filter = CreateTypeFilter(node);
Logger.Debug(m => m("Inlude Filter: {0}", filter));
scanner.WithIncludeFilter(filter);
}
else if (node.Name.Contains(EXCLUDE_FILTER_ELEMENT))
{
var filter = CreateTypeFilter(node);
Logger.Debug(m => m("Exclude Filter: {0}", filter));
scanner.WithExcludeFilter(filter);
}
}
}
public void Can_Filter_For_Specific_Types_With_Multiple_Include_Filters()
{
var scanner = new AssemblyObjectDefinitionScanner();
scanner.WithIncludeFilter(type => type.FullName.Contains(typeof(TheImportedConfigurationClass).Name));
scanner.WithIncludeFilter(type => type.FullName.Contains(typeof(TheConfigurationClass).Name));
_context.Scan(scanner);
_context.Refresh();
AssertExpectedObjectsAreRegisteredWith(_context);
}
public void Scanner()
{
AssemblyObjectDefinitionScanner scanner = new AssemblyObjectDefinitionScanner();
scanner.AssemblyHavingType<TheConfigurationClass>();
}
/// <summary>
/// Scans for types using the provided scanner.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="scanner">The scanner.</param>
public static void Scan(this AbstractApplicationContext context, AssemblyObjectDefinitionScanner scanner)
{
scanner.ScanAndRegisterTypes((IObjectDefinitionRegistry)context.ObjectFactory);
}
