public void Configuration(IAppBuilder app)
{
var builder = new ContainerBuilder();
AutofacConfiguration.Configure(builder);
builder.RegisterModule <InfrastructureModule>();
var container = builder.Build();
var config = new HttpConfiguration
{
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
ApiConfiguration.Configure(config);
// Overriden configurations
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
app.UseAutofacMiddleware(container);
app.UseAutofacWebApi(config);
app.UseTestServerAuthentication();
app.UseWebApi(config);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
AutofacConfiguration.Start();
}
private async Task PerformStart()
{
_databaseBackuper = new DatabaseBackuper(DatabaseFilepath);
SettingsManager.HandleSettingsUpgrade();
while (true)
{
ContainerBuilder builder = null;
using (new MeasureTimeWrapper(() => builder = AutofacConfiguration.ContainerBuilder(), "ContainerBuilder")) { }
var init = await HandleApplicationInit(builder);
try
{
//it could be using, but then there is problem with resolving func factory... anyway it will die with app.
IContainer container = null;
using (new MeasureTimeWrapper(() => container = builder.Build(), "Container.Build")) { }
if (HandleInitDataGeneration(init, container))
{
return;
}
using (new MeasureTimeWrapper(() => container.Resolve <MainWindow>().Show(), "Resolve<MainWindow>.Show")) { }
await _updater.HandleApplicationUpdatesCheck();
break;
}
catch (LiteException exception)
{
_logger.Value.Error("Loading app failed", exception);
}
}
}
internal static IContainer GetContainer()
{
MapperConfiguration.Configure();
var builder = AutofacConfiguration.ContainerBuilder();
//override db register
builder.Register(x => new LiteRepository(new LiteDatabase(new MemoryStream()))).SingleInstance().ExternallyOwned();
builder.RegisterType <ApplicationViewModel>()
.Named <ViewModelBase>(nameof(ApplicationViewModel))
.As <ViewModelBase>()
.As <ApplicationViewModel>()
.SingleInstance();
//search should be perform instantly in tests
builder.Register(x =>
{
var vm = new SearchViewModel(
x.Resolve <IQueryDispatcher>(),
x.Resolve <ICommandDispatcher>(),
x.Resolve <ViewModelFactory>(),
x.Resolve <TransactionsProvider>())
{
IsDebounceable = false
};
return(vm);
})
.As <SearchViewModel>()
.Named <ViewModelBase>(nameof(SearchViewModel));
return(builder.Build());
}
private static void SetupDependencies()
{
IContainer container = null;
var containerBuilder = new ContainerBuilder();
//containerBuilder.RegisterModule<ApplicationServicesModule>();
//containerBuilder.RegisterType<NsbEventBus>().As<IEventBus>();
containerBuilder.RegisterType<RavenDBEventStore>().As<IEventStore>();
containerBuilder.RegisterInstance<ICommandService>(InitializeCommandService());
containerBuilder.RegisterInstance<IEventBus>(InitializeEventBus());
//InitializeNServiceBus(container);
containerBuilder.Register(x => container);
// var config = new AutofacConfiguration(x =>
// {
// var eventBus = InitializeEventBus();
// var eventStore = InitializeEventStore();
// x.For{IEventBus}().Use(eventBus);
// x.For{IEventStore}().Use(eventStore);
// x.For{IUnitOfWorkFactory}().Use{UnitOfWorkFactory}();
// }
//);
container = containerBuilder.Build();
AutofacConfiguration config = new AutofacConfiguration(container);
// I believe this is a single call to configure inject all component dependencies
// e.g. NcqrsEnvironment.SetDefault<IEventBus>( InitializeEventBus() );
NcqrsEnvironment.Configure(config);
}
static void Main()
{
//Configurations
AutofacConfiguration.Configure();
Global.IsNameSpaceEnabled = true;
DotLiquidConfiguration.Configure();
AutoMapperConfiguration.Configure();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//Test
//using (var scope = Global.Container.BeginLifetimeScope())
//{
// var templateService = scope.Resolve<IRetrieveDbObjectsRepository>();
// var result = templateService.GetColumnsWithKeys();
//}
//Endof test
using (var scope = Global.Container.BeginLifetimeScope())
{
Application.Run(scope.Resolve <PocoGenerator>());
//Application.Run(scope.Resolve<TypeMapper>());
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
AutofacConfiguration.Configurate();
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
private static SearchResponse GetJournalsImported(bool includeArchived, int pageNumber)
{
//vagues search window ever, to return all transactions in the searcher
const string searchWindow =
"{'Period':{'From':'1649-01-30', 'To':'4789-7-14'},'Parameters':{'users':'steve\r\nBarry'}";
var searchRequest = "{pageNumber: " + pageNumber + ", searchWindow: " + searchWindow + "}";
var requestResponse = new MockRequest("POST",
searchRequest,
"application/json", "http://*****:*****@"Sage50SampleData",
Username = "******",
IncludeArchived = includeArchived
});
return(lifetime.GetParsedResponseContent <SearchResponse>(requestResponse).Result);
}
}
private static void Main(string[] args)
{
var container = AutofacConfiguration.Configure();
var task = container.Resolve <Application>().Run(args);
task.Wait();
}
/*public static IServiceLocator SetupOracle(string connectionString)
* {
* return Setup(Database.Oracle, connectionString);
* }*/
private static IServiceLocator Setup(Database db, string connectionString, bool withAspects)
{
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException("connectionString", "Connection string not provided");
}
return(AutofacConfiguration.Configure(db, connectionString, withAspects));
}
public async Task ItShouldDispatchCommandsWhichDoesntReturnResults()
{
var container = AutofacConfiguration.CreateContainer(new List <Assembly> {
GetType().Assembly
});
var dispatcher = container.Resolve <IDomainCommandDispatcher>();
await dispatcher.Dispatch(new MyCommandWithNoResult());
}
private static ContainerBuilder CreateContainerBuilder(DateTime currentDate, ICurrentUserRegistry registry)
{
var containerBuilder = AutofacConfiguration.CreateDefaultContainerBuilder();
containerBuilder.Register(_ => CreateClock(currentDate)).As <IClock>();
containerBuilder.Register(_ => registry).As <ICurrentUserRegistry>();
return(containerBuilder);
}
public static IContainer InitializeTests(HttpClient client) =>
AutofacConfiguration.InitializeTests(Container, setupAction =>
{
setupAction.Register(c => RestService.For <IApi>(client)).As <IApi>();
setupAction.Register(c => RestService.For <ICoursesApi>(client)).As <ICoursesApi>();
setupAction.Register(c => RestService.For <IPeopleApi>(client)).As <IPeopleApi>();
setupAction.Register(c => RestService.For <IPeopleCollectionApi>(client)).As <IPeopleCollectionApi>();
setupAction.CommonSetup();
});
protected void Application_Start()
{
DependencyResolver.SetResolver(new AutofacDependencyResolver(AutofacConfiguration.Build(typeof(MvcApplication).Assembly)));
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ControllerBuilder.Current.SetControllerFactory(new DefaultControllerFactory(new LocalizedControllerActivator()));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
LogFourNet.Configure();
AutofacConfiguration.Configure();
}
/// <summary>
/// Handles the global application startup event.
/// </summary>
protected void Application_Start(object sender, EventArgs e)
{
LogManager.Initialize();
// https://code.google.com/p/autofac/source/browse/Examples/MultitenantExample.WcfService/Global.asax.cs
var bootStart = new AutofacConfiguration();
bootStart.DoStart();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AutofacConfiguration.RegisterAndResolve();
//AutoMapperWebConfiguration.Configure();
}
public async Task ItShouldDispatchCommandsWhichReturnResults()
{
var container = AutofacConfiguration.CreateContainer(new List <Assembly> {
GetType().Assembly
});
var dispatcher = container.Resolve <IDomainCommandDispatcher>();
var result = await dispatcher.Dispatch(new MyCommandWithResult { Ping = "Pong" });
Assert.Equal("Pong", result);
}
public async Task ItShouldDispatchQueries()
{
var container = AutofacConfiguration.CreateContainer(new List <Assembly> {
GetType().Assembly
});
var dispatcher = container.Resolve <IDomainQueryDispatcher>();
var result = await dispatcher.Dispatch(new MyQuery());
Assert.Equal("result", result);
}
public void ItShouldInjectUnitOfWork()
{
var container = AutofacConfiguration.CreateContainer(new List <Assembly> {
GetType().Assembly
});
using (var scope = container.BeginLifetimeScope())
{
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
AutomapperConfigurations.RegisterConfigurations();
AutofacConfiguration.ConfigureContainer();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public async Task ItShouldThrownAnExceptionIfHandlerNotSpecified()
{
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
var container = AutofacConfiguration.CreateContainer(new List <Assembly> {
GetType().Assembly
});
var dispatcher = container.Resolve <IDomainQueryDispatcher>();
await dispatcher.Dispatch(new MyQueryWithNoHandler());
});
}
public async Task ItShouldThrowAnErrorWhenNoHanlderFound()
{
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
var container = AutofacConfiguration.CreateContainer(new List <Assembly> {
GetType().Assembly
});
var dispatcher = container.Resolve <IDomainCommandDispatcher>();
await dispatcher.Dispatch(new MyCommandWithNoHanlder());
});
}
public void When_component_is_not_registered_it_should_not_be_retrievable()
{
var kernel = new ContainerBuilder();
var container = kernel.Build();
var configuration = new AutofacConfiguration(container);
IReplicant component;
var success = configuration.TryGet(out component);
success.Should().BeFalse();
component.Should().BeNull();
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
AutoMapperConfig.RegisterMappings();
AutofacConfiguration.Config();
var navigayionViewModel = DependencyResolver.Current.Resolve <NavigationViewModel>();
var window = new MainWindow(navigayionViewModel);
window.Show();
}
static IEnumerable <Transaction> ExecuteSearch(ISearchRequest request, IEnumerable <Transaction> transactionsInRepository)
{
CollectionAssert.IsNotEmpty(transactionsInRepository, "Searching an empty repository is not a useful test");
using (var lifetime = AutofacConfiguration
.CreateDefaultContainerBuilder()
.WithNoLicensing()
.BuildSearchable(transactionsInRepository))
{
return(lifetime.Resolve <SearchController>().Search(request).Transactions.ToList());
}
}
public void When_component_is_not_registered_it_should_not_be_retrievable()
{
var kernel = new ContainerBuilder();
var container = kernel.Build();
var configuration = new AutofacConfiguration(container);
IReplicant component;
var success = configuration.TryGet(out component);
success.Should().BeFalse();
component.Should().BeNull();
}
static void Main(string[] args)
{
//custom IOC
//Player p = new Player(Armory.GetWeapon());
//p.Attack();
var container = AutofacConfiguration.GetContainer();
IWeapon weapon = container.Resolve <IWeapon>();
Player p = new Player(weapon);
p.Attack();
}
private static IContainer CreateContainer()
{
var assembliesToScan = new List <Assembly> {
typeof(Program).GetTypeInfo().Assembly
};
var container = AutofacConfiguration.CreateContainer(assembliesToScan, builder =>
{
builder.RegisterType <MyDbContext>().InstancePerLifetimeScope();
});
return(container);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//Load map entity -> viewmodels
AutomapperConfiguration.Configure();
//--> Autofac
AutofacConfiguration.Register();
}
protected void Application_Start()
{
//AutofacConfig.Initialize(GlobalConfiguration.Configuration);
AutofacConfiguration.RegisterAutoFac();
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ViewEngineInit();
//ControllerBuilder.Current.SetControllerFactory(new NinjectControllerFactory());
}
/// <summary>
///
/// </summary>
protected void Application_Start()
{
logger.Debug(System.Reflection.MethodBase.GetCurrentMethod().Name);
var container = AutofacConfiguration.Build(Assembly.GetExecutingAssembly());
GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configure(WebApiConfig.Register);
var getData = container.Resolve <IGetData>();
getData.GetDataRates();
getData.GetDataTrans();
}
public void When_component_is_registered_it_should_be_retrievable()
{
var kernel = new ContainerBuilder();
kernel.RegisterType<Nexus6>().As<IReplicant>();
var container = kernel.Build();
var configuration = new AutofacConfiguration(container);
IReplicant component;
var success = configuration.TryGet(out component);
success.Should().BeTrue();
component.Should().NotBeNull();
component.Should().BeOfType<IReplicant>();
}
