private void ScanAllModulesForAllModulesPrecommitStrategies(IAssemblyScanner assemblyScanner)
{
// Add all Pre-Commit Processors (these kick in just as you
// Commit a DbContext, and ensure specific fields are
// automatically filled in)
assemblyScanner.AddAllTypesOf <IDbCommitPreCommitProcessingStrategy>();
}
private void ScanTypes(IAssemblyScanner scanner)
{
scanner.AssembliesFromApplicationBaseDirectory();
scanner.AddAllTypesOf <ITask>();
// Logging
For <ILogger>().Use(x => _logger);
// Powershell
For <IPowershellRunner>().Use <PowershellRunner>();
For <IFileProvider>().Use <FileProvider>();
// YAML
For <IConfigFileReader>().Use <ConfigFileReader>();
For <Dictionary <string, ITask> >().Use("TasksAsDictionary", context =>
{
return(TasksAsDictionary(context.GetAllInstances <ITask>()));
});
For <IYamlConfigParser>().Use("IYamlConfigParser", context =>
{
var configFileReader = context.GetInstance <IConfigFileReader>();
var tasks = context.GetInstance <Dictionary <string, ITask> >();
return(new YamlConfigParser(configFileReader, tasks, _logger));
});
}
private static void AddDataDependency(IAssemblyScanner scan)
{
scan.AssemblyContainingType <IDbContext>();
scan.AssemblyContainingType <IServiceContext <Service::ICommercialContract> >();
scan.AssemblyContainingType <IRepository <Kind> >();
scan.AssemblyContainingType <IRepository <State> >();
scan.AssemblyContainingType <IRepository <Country> >();
scan.AssemblyContainingType <IRepository <User> >();
scan.AssemblyContainingType <ICategoryRepository>();
scan.AssemblyContainingType <IRoleRepository>();
scan.AssemblyContainingType <Data.Services.IAreaService>();
scan.AssemblyContainingType <Data.Services.ICityService>();
scan.AssemblyContainingType <Data.Services.IAdDetailsService>();
scan.AssemblyContainingType <Data.Services.IAdService>();
scan.AssemblyContainingType <Data.Services.ICommercialService>();
scan.AssemblyContainingType <Data.Services.IMembershipService>();
scan.AssemblyContainingType <IAdContext>();
scan.AssemblyContainingType <IAdDetailsContext>();
scan.AssemblyContainingType <ICategoryContext>();
scan.AssemblyContainingType <IAreaContext>();
scan.AssemblyContainingType <ICityContext>();
scan.AssemblyContainingType <IMembershipContext>();
scan.AssemblyContainingType <IRoleContext>();
scan.AssemblyContainingType <ICommercialContext>();
scan.AssemblyContainingType <IDataContext <Country> >();
scan.AssemblyContainingType <IDataContext <Kind> >();
scan.AssemblyContainingType <IDataContext <State> >();
scan.AssemblyContainingType <IDataContext <User> >();
}
// Use the ASP.NET Core DI system to inject these dependencies
public PluginLoadOptions(
IPluginLogger <T> logger,
IAssemblyScanner <T> assemblyScanner,
ISharedServicesProvider <T> sharedServicesProvider,
IPluginTypesProvider <T> pluginTypesProvider,
IPluginActivationContextProvider <T> pluginActivationContextProvider,
IRemotePluginActivator <T> activator,
IParameterConverter parameterConverter,
IResultConverter resultConverter,
IPluginAssemblyLoader <T> assemblyLoader,
IPluginProxyCreator <T> proxyCreator,
IHostTypesProvider <T> hostTypesProvider,
IRemoteTypesProvider <T> remoteTypesProvider,
IRuntimePlatformContext runtimePlatformContext,
IAssemblySelector <T> assemblySelector,
IPluginSelector <T> pluginSelector
)
{
this.logger = logger;
this.assemblyScanner = assemblyScanner;
this.sharedServicesProvider = sharedServicesProvider;
this.pluginTypesProvider = pluginTypesProvider;
this.pluginActivationContextProvider = pluginActivationContextProvider;
this.activator = activator;
this.parameterConverter = parameterConverter;
this.resultConverter = resultConverter;
this.assemblyLoader = assemblyLoader;
this.proxyCreator = proxyCreator;
this.hostTypesProvider = hostTypesProvider;
this.remoteTypesProvider = remoteTypesProvider;
this.runtimePlatformContext = runtimePlatformContext;
this.assemblySelector = assemblySelector;
this.pluginSelector = pluginSelector;
}
public static IBus CreateFakeBus(int busReceptionPort, string busName, PeerId busId, int directoryServicePort, string directoryServiceName,PeerId directoryServiceId, IAssemblyScanner assemblyScanner = null, IPeerConfiguration peerconfig = null, IContainer container = null)
{
container = container ?? new Container();
return BusFactory.CreateBus(container, containerConfigurationExpression: ctx =>
{
ctx.For
<ZmqTransportConfiguration>()
.Use(
new DummyTransportConfig(
busReceptionPort));
ctx.For
<IBusBootstrapperConfiguration
>().Use(new DummyBootstrapperConfig
{
DirectoryServiceEndpoint
=
"tcp://localhost:" +
directoryServicePort,
DirectoryServiceName
=
directoryServiceName,
DirectoryServiceId = directoryServiceId
});
ctx.For<IPeerConfiguration>().Use(
peerconfig ?? new DummyPeerConfig(busName,busId, null));
ctx.For<IAssemblyScanner>().Use(
assemblyScanner ?? new AssemblyScanner());
});
}
public static void AssembliesFromPath(this IAssemblyScanner scanner, string path,
Predicate <Assembly> assemblyFilter)
{
var assemblyPaths = Directory.GetFiles(path)
.Where(file =>
Path.GetExtension(file).Equals(
".exe",
StringComparison.OrdinalIgnoreCase)
||
Path.GetExtension(file).Equals(
".dll",
StringComparison.OrdinalIgnoreCase));
foreach (var assemblyPath in assemblyPaths)
{
Assembly assembly = null;
try
{
assembly = Assembly.LoadFrom(assemblyPath);
}
catch
{
}
if (assembly != null && assemblyFilter(assembly))
{
scanner.Assembly(assembly);
}
}
}
public static void GlueTogetherMediatrInterfaces(this IAssemblyScanner scanner)
{
scanner.ConnectImplementationsToTypesClosing(typeof(IRequestHandler <,>));
scanner.ConnectImplementationsToTypesClosing(typeof(IAsyncRequestHandler <,>));
scanner.ConnectImplementationsToTypesClosing(typeof(INotificationHandler <>));
scanner.ConnectImplementationsToTypesClosing(typeof(IAsyncNotificationHandler <>));
}
public StrapiPageController(IAssemblyScanner assemblyScanner, IContentRepository contentRepository,
IServiceProvider serviceProvider)
{
_assemblyScanner = assemblyScanner;
_serviceProvider = serviceProvider;
_contentRepository = contentRepository;
}
public RouteBuilder(IContainer container, IAssemblyScanner assemblyScanner, IAddressProvider addressProvider, MessageConventions conventions)
{
this.container = container;
this.assemblyScanner = assemblyScanner;
this.addressProvider = addressProvider;
this.conventions = conventions;
}
/// <summary>
/// Extension method to help with scanning assemblies in the solution for handler types
/// </summary>
/// <param name="scanner"></param>
public static void ScanForHandlers(this IAssemblyScanner scanner)
{
scanner.TheCallingAssembly();
scanner.AssemblyContainingType <IHandlerBase>();
scanner.AssembliesFromApplicationBaseDirectory();
scanner.AddAllTypesOf <IHandlerBase>();
}
public override void Registros(IAssemblyScanner scan)
{
scan.AddAllTypesOf <IDatabaseProvider>();
scan.AddAllTypesOf <Seed>();
this.InitializeDatabase();
}
public static IAssemblyScanner ScanReferencedAssemblies(this IAssemblyScanner scanner)
{
var assemblies = GetReferencedAssemblies();
scanner.ScanAssemblies(assemblies);
return(scanner);
}
public static void ScanAllMyAssemblies(this IAssemblyScanner scanner)
{
scanner.Assembly(typeof(Startup).GetTypeInfo().Assembly);
scanner.Assembly("MediatrEF6PoC3.Models");
scanner.Assembly("MediatrEF6PoC3.Messages");
scanner.Assembly("MediatrEF6PoC3.EF6Handlers");
scanner.Assembly("MediatrEF6PoC3.EF6");
}
private void EnsureTypes()
{
if (_TypeFinder == null)
{
_TypeFinder = _RenderingTypeFinderSettings.AssemblyScannerFactory();
_TypeFinder.Scan(_RenderingTypeFinderSettings.AssembliesToScan, _RenderingTypeFinderSettings.TypesToFind);
}
}
public static void ScanPluginDirectory(this IAssemblyScanner scanner, Registry registry)
{
try
{
var cfg = ConfigurationManager.AppSettings["app:plugin-path"];
if (string.IsNullOrWhiteSpace(cfg))
{
return;
}
var pluginsDirectory = Path.GetFullPath(cfg);
if (!Directory.Exists(pluginsDirectory))
{
return;
}
scanner.AssembliesFromPath(pluginsDirectory);
scanner.LookForRegistries();
Type structureMapCheck = typeof(IServicePlugin);
var assemblies = FindAssemblies(pluginsDirectory);
foreach (var assembly in assemblies)
{
foreach (var type in assembly.GetExportedTypes().Where(a => !a.IsAbstract))
{
if (!structureMapCheck.IsAssignableFrom(type))
{
continue;
}
var interfaces = type.GetInterfaces();
foreach (var item in interfaces)
{
if (item == structureMapCheck)
{
continue;
}
registry.For(item).Use(type);
}
var baseType = type.BaseType;
if (baseType == null || !baseType.IsAbstract)
{
continue;
}
registry.For(baseType).Use(type);
}
}
}
catch (Exception e)
{
var msg = e.Message;
}
}
//SKYOUT: private void ScanAllModulesForModuleSpecificODataBuilderTypes(IAssemblyScanner assemblyScanner)
//{
// // Note that because we are in App.Core.Infrastructure, we can't see the
// // Typed version of this interface (as this assembly does not know anything
// // about OData as it does not have a Ref to OData Assemblies...nor should it, as that
// // woudl drag in way too many other dependencies (ApiControllers, Web, etc.)
// // So we search for and register the *untyped* version of the interface:
// //Scan for OData Model Builders in *all* modules.
// assemblyScanner.AddAllTypesOf<IAppODataModelBuilder>();
// //Scan for OData Model Builder Configuration fragments in *all* modules.
// assemblyScanner.AddAllTypesOf<IAppODataModelBuilderConfiguration>();
//}
// Scan across all known assemblies for DbContext related model definitions
// And seeding definitions, and define the DbContext lifespan:
private void ScanAllModulesForModuleSpecificDbContextTypes(IAssemblyScanner assemblyScanner)
{
// Register the Db Model definitions and seeder definitions for Core:
assemblyScanner.AddAllTypesOf <IHasAppModuleDbContextModelBuilderInitializer>();
assemblyScanner.AddAllTypesOf <IHasAppModuleDbContextSeedInitializer>();
this.RegisterDbContextInHttpContext <AppCoreDbContext>(AppCoreDbContextNames.Core);
For <HostSectionConfigurationManager>().Use <HostSectionConfigurationManager>().Singleton();
}
static void ScannerConfiguration(IAssemblyScanner scanner)
{
scanner.TheCallingAssembly();
scanner.AssemblyContainingType(typeof(Secret));
scanner.SingleImplementationsOfInterface();
scanner.WithDefaultConventions();
// Using OnAddedPluginType doesn't make concrete types singletons by default.
scanner.With(new SingletonConvention());
}
private void ScanSolutionAssemblies(IAssemblyScanner scanner)
{
AppDomain
.CurrentDomain
.GetAssemblies()
.Where(assembly => assembly.FullName.StartsWith("DotNetDns."))
.ToList()
.ForEach(assembly => scanner.Assembly(assembly));
}
public ContentRepository(IAppSettings appSettings, IStrapiAdmin strapiAdmin, IHttpClient httpClient,
IAssemblyScanner assemblyScanner)
{
_httpClient = httpClient;
_strapiAdmin = strapiAdmin;
_assemblyScanner = assemblyScanner;
strapiAdmin.Authorize(_httpClient);
}
public static void TheCallingAssembly(this IAssemblyScanner scanner)
{
var callingAssembly = findTheCallingAssembly();
if (callingAssembly != null)
{
scanner.Assembly(callingAssembly);
}
}
public void Init()
{
_builder = MockRepository.GenerateMock <IBuilder>();
_scanner = MockRepository.GenerateMock <IAssemblyScanner>();
_builder.Stub(x => x.GetInstance(typeof(MessageModule))).Return(MockRepository.GenerateMock <IMessageModule>());
_builder.Stub(x => x.GetInstance(typeof(AnotherMessageModule))).Return(MockRepository.GenerateMock <IMessageModule>());
_sut = new ModuleManager(_scanner, _builder);
}
public DefaultMvcPluginLoader(IAssemblyScanner assemblyScanner,
IPluginTypeSelector pluginTypeSelector,
IAssemblyLoader assemblyLoader,
IPluginCache pluginCache)
{
this.assemblyScanner = assemblyScanner;
this.pluginTypeSelector = pluginTypeSelector;
this.assemblyLoader = assemblyLoader;
this.pluginCache = pluginCache;
}
public TestFramework(
ITestFixtureFactory testFixtureFactory,
IDirectoryScanner directoryScanner,
IAssemblyScanner assemblyScanner
)
{
this.testFixtureFactory = testFixtureFactory;
this.directoryScanner = directoryScanner;
this.assemblyScanner = assemblyScanner;
}
public void Return_empty_array_if_no_test_fixtures_types_in_assembly()
{
//Arrange
assemblyScanner = new Core.AssemblyScanner(new TestDetector());
//Act
Type[] result = assemblyScanner.GetTestsFromAssembly(moduleBuilder.Assembly);
//Assert
Assert.Empty(result);
}
private void DoScan(IAssemblyScanner assemblyScanner)
{
// Always create concrete instances based on usual DI naming
// convention
// i.e. Search for class name "Concrete" when "IConcrete" is
// requested.
assemblyScanner.WithDefaultConventions();
// Scan all assemblies, including the one executing.
assemblyScanner.AssembliesFromPath(this.executingAssemblyLocation);
}
private void AddConventions(IAssemblyScanner scanner)
{
scanner.WithDefaultConventions();
Assembly
.GetExecutingAssembly()
.GetTypes()
.Where(type => typeof(IRegistrationConvention).IsAssignableFrom(type))
.ToList()
.ForEach(type => scanner.With(CreateConvention(type)));
}
private void ScanThisModulesForODataModelBuilderTypes(IAssemblyScanner assemblyScanner)
{
// Note that because we are in App.Core.Infrastructure, we can't see the
// Typed version of this interface (as this assembly does not know anything
// about OData as it does not have a Ref to OData Assemblies...nor should it, as that
// woudl drag in way too many other dependencies (ApiControllers, Web, etc.)
// So we search for and register the *untyped* version of the interface:
//Scan for OData Model Builder Configuration fragments in *this* modules.
assemblyScanner.AddAllTypesOf <IAppModuleOdataModelBuilderConfiguration>();
}
public BusBootstrapper(IAssemblyScanner assemblyScanner, ZmqTransportConfiguration zmqTransportConfiguration, IBusBootstrapperConfiguration bootstrapperConfiguration,
IMessageSender messageSender, IPeerManager peerManager, ISubscriptionManager subscriptionManager, IPeerConfiguration peerConfiguration)
{
_assemblyScanner = assemblyScanner;
_zmqTransportConfiguration = zmqTransportConfiguration;
_bootstrapperConfiguration = bootstrapperConfiguration;
_messageSender = messageSender;
_peerManager = peerManager;
_subscriptionManager = subscriptionManager;
_peerConfiguration = peerConfiguration;
}
public DocumentationService(IAssemblyScanner assemblyScanner, IConverter converter)
{
_assemblyScanner = assemblyScanner;
_converter = converter;
_path = Path.Combine(Directory.GetCurrentDirectory(), "Documentation");
if (!Directory.Exists(_path))
{
Directory.CreateDirectory(_path);
}
}
public static void AssembliesFromApplicationBaseDirectory(this IAssemblyScanner scanner, Predicate <Assembly> assemblyFilter)
{
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
scanner.AssembliesFromPath(baseDirectory, assemblyFilter);
var binPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
if (Directory.Exists(binPath))
{
scanner.AssembliesFromPath(binPath, assemblyFilter);
}
}
public StrapiBuilder(IAppSettings appSettings, IStrapiRepository strapiRepository, IStrapiProcess strapiProcess,
IHttpClient httpClient, IStrapiAdmin strapiAdmin, IAssemblyScanner assemblyScanner)
{
_httpClient = httpClient;
_strapiProcess = strapiProcess;
_assemblyScanner = assemblyScanner;
_strapiRepository = strapiRepository;
strapiAdmin.Authorize(_httpClient);
_strapiContentTypeBuilderUri = $"{strapiAdmin.BaseUrl}/content-type-builder";
_pathToStrapiInstallationDirectory = Path.Combine(appSettings.PathToWorkingDirectory, "strapi");
}
public static void AssembliesFromApplicationBaseDirectory(this IAssemblyScanner scanner, Func <Assembly, bool> assemblyFilter)
{
var assemblies = AssemblyFinder.FindAssemblies(assemblyFilter, txt =>
{
Console.WriteLine("StructureMap could not load assembly from file " + txt);
});
foreach (var assembly in assemblies)
{
scanner.Assembly(assembly);
}
}
public static void AssembliesFromPath(this IAssemblyScanner scanner, string path)
{
var assemblies = AssemblyFinder.FindAssemblies(path, txt =>
{
Console.WriteLine("StructureMap could not load assembly from file " + txt);
});
foreach (var assembly in assemblies)
{
scanner.Assembly(assembly);
}
}
// Scan across all known assemblies for DbContext related model definitions
// And seeding definitions, and define the DbContext lifespan:
private void ScanAllModulesForModuleSpecificDbContextTypes(IAssemblyScanner assemblyScanner)
{
// Register the Db Model definitions and seeder definitions for Core:
assemblyScanner.AddAllTypesOf <IHasAppModuleDbContextModelBuilderInitializer>();
assemblyScanner.AddAllTypesOf <IHasAppModuleDbContextSeedInitializer>();
// Add all Pre-Commit Processors (these kick in just as you
// Commit a DbContext, and ensure specific fields are
// automatically filled in)
assemblyScanner.AddAllTypesOf <IDbCommitPreCommitProcessingStrategy>();
this.RegisterDbContextInHttpContext <AppModuleDbContext>(AppModuleDbContextNames.Default);
}
public ReliabilityCoordinator(IPeerManager peerManager, IPeerConfiguration peerConfiguration, IAssemblyScanner assemblyScanner)
{
_peerManager = peerManager;
_peerConfiguration = peerConfiguration;
_assemblyScanner = assemblyScanner;
_peerManager.PeerConnected += OnPeerChange;
var messageOptionses = _assemblyScanner.GetMessageOptions();
foreach (var messageOptionse in messageOptionses)
{
_messageOptions.Add(messageOptionse.MessageType.FullName, messageOptionse);
}
}
private static void ScanAssemblies(IAssemblyScanner scanner)
{
var assebliesToBeScanned = ConfigurationManager.AppSettings["AssembliesToBeScanned"];
List<string> assemblies = null;
if (assebliesToBeScanned != null)
{
assemblies = assebliesToBeScanned.Split(';').ToList();
}
if (assemblies != null)
{
assemblies.ForEach(scanner.Assembly);
}
scanner.WithDefaultConventions();
scanner.TheCallingAssembly();
scanner.LookForRegistries();
}
public SerializationHelper(IAssemblyScanner scanner)
{
var knownMessages = scanner.GetMessageOptions();
foreach (var messageOptionse in knownMessages)
{
try
{
var fullName = messageOptionse.MessageType.FullName;
var idFromString = StringUtils.CreateIdFromString(fullName);
_messageTypeToId.Add(fullName, idFromString);
_messageTypeIdToMessageType.Add(idFromString, fullName);
}
catch (ArgumentException ex)
{
throw new ArgumentException("Problem while loading message type to message type id dictionary, two type names might have the same id");
}
}
}
protected abstract void GetAssemblies(IAssemblyScanner assembly);
public MessageDispatcher(IContainer objectFactory, IAssemblyScanner assemblyScanner)
{
_objectFactory = objectFactory;
_assemblyScanner = assemblyScanner;
}
private static void AddAssembliesToScan(IAssemblyScanner assemblyScanner)
{
var assemblies = AssemblyScanner.GetAssembliesInFolder(AppDomain.CurrentDomain.BaseDirectory, fileName => !fileName.StartsWith("libzmq-"))
.Where(a => a != typeof(ZebusRegistry).Assembly);
foreach (var assembly in assemblies)
{
assemblyScanner.Assembly(assembly);
}
}
private static void doScan(IAssemblyScanner scanner)
{
scanner.ConnectImplementationsToTypesClosing(typeof(IHandler<>));
}
public virtual void Initialize(IAssemblyScanner scan)
{
scan.AssemblyContainingType(GetType());
}
protected override void GetAssemblies(IAssemblyScanner assembly)
{
assembly.AssemblyContainingType<Bootstrapper>();
assembly.TheCallingAssembly();
}
private static void Initialize(IAssemblyScanner scan)
{
scan.WithDefaultConventions();
scan.TheCallingAssembly();
scan.AssemblyContainingType(typeof(Microsoft.TeamFoundation.Client.TeamFoundationServer));
}
private static void Initialize(IAssemblyScanner scan)
{
scan.WithDefaultConventions();
scan.TheCallingAssembly();
}
private void Scan(IAssemblyScanner scanner)
{
scanner.TheCallingAssembly();
scanner.SingleImplementationsOfInterface();
scanner.WithDefaultConventions();
// Copy all plugins to the /bin/Plugins folder
CopyPlugins();
// Scan plugins
foreach (string subDirectory in Directory.GetDirectories(_applicationSettings.PluginsBinPath))
{
scanner.AssembliesFromPath(subDirectory);
}
// UserServiceBase is scanned below
// Scan for TextPlugins
scanner.AddAllTypesOf<TextPlugin>();
// Scan for SpecialPages
scanner.AddAllTypesOf<SpecialPagePlugin>();
// The pluginfactory
scanner.AddAllTypesOf<IPluginFactory>();
// Config, repository, context
scanner.AddAllTypesOf<ApplicationSettings>();
scanner.AddAllTypesOf<IRepository>();
scanner.AddAllTypesOf<IUserContext>();
// Services and services
scanner.AddAllTypesOf<ServiceBase>();
scanner.AddAllTypesOf<IPageService>();
scanner.AddAllTypesOf<IActiveDirectoryProvider>();
scanner.AddAllTypesOf<UserServiceBase>();
scanner.AddAllTypesOf<IFileService>();
// Text parsers
scanner.AddAllTypesOf<MarkupConverter>();
scanner.AddAllTypesOf<CustomTokenParser>();
// MVC Related
scanner.AddAllTypesOf<Roadkill.Core.Mvc.Controllers.Api.ApiControllerBase>();
scanner.AddAllTypesOf<Roadkill.Core.Mvc.Controllers.ControllerBase>();
scanner.AddAllTypesOf<UserViewModel>();
scanner.AddAllTypesOf<SettingsViewModel>();
scanner.AddAllTypesOf<AttachmentRouteHandler>();
scanner.AddAllTypesOf<ISetterInjected>();
scanner.AddAllTypesOf<IAuthorizationAttribute>();
scanner.AddAllTypesOf<RoadkillLayoutPage>();
scanner.AddAllTypesOf(typeof(RoadkillViewPage<>));
scanner.ConnectImplementationsToTypesClosing(typeof(RoadkillViewPage<>));
// Emails
scanner.AddAllTypesOf<SignupEmail>();
scanner.AddAllTypesOf<ResetPasswordEmail>();
// Cache
scanner.AddAllTypesOf<ListCache>();
scanner.AddAllTypesOf<PageViewModelCache>();
// Export
scanner.AddAllTypesOf<WikiExporter>();
}
private static void PerformScan(IAssemblyScanner scanner)
{
scanner.AssembliesFromApplicationBaseDirectory();
scanner.Include(type => type.HasAttribute<UnitWorkerAttribute>());
scanner.Convention<HttpContextLifecycleConvention>();
}
private static void Scan(IAssemblyScanner s)
{
s.AssembliesFromApplicationBaseDirectory();
s.LookForRegistries();
s.WithDefaultConventions();
}
private static void doScan(IAssemblyScanner scanner)
{
scanner.ConnectImplementationsToTypesClosing(typeof(CommandExecutor<>));
}
private static void FindAllStructureMapPlugins(IAssemblyScanner x)
{
x.AssemblyContainingType<Bootstrapper>();
x.TheCallingAssembly();
x.WithDefaultConventions();
}
private void AddAssemblies(IAssemblyScanner x)
{
x.Assembly(GetType().Assembly);
}
