Beispiel #1
1
        public void Init() {
            _settingsA = new ShellSettings { Name = "Alpha" };
            _settingsB = new ShellSettings { Name = "Beta", };
            _routes = new RouteCollection();

            var rootBuilder = new ContainerBuilder();
            rootBuilder.Register(ctx => _routes);
            rootBuilder.RegisterType<ShellRoute>().InstancePerDependency();
            rootBuilder.RegisterType<RunningShellTable>().As<IRunningShellTable>().SingleInstance();
            rootBuilder.RegisterModule(new WorkContextModule());
            rootBuilder.RegisterType<WorkContextAccessor>().As<IWorkContextAccessor>().InstancePerMatchingLifetimeScope("shell");
            rootBuilder.RegisterType<HttpContextAccessor>().As<IHttpContextAccessor>();
            rootBuilder.RegisterType<ExtensionManager>().As<IExtensionManager>();
            rootBuilder.RegisterType<StubCacheManager>().As<ICacheManager>();
            rootBuilder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>();
            rootBuilder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();

            _rootContainer = rootBuilder.Build();

            _containerA = _rootContainer.BeginLifetimeScope(
                "shell",
                builder => {
                    builder.Register(ctx => _settingsA);
                    builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().InstancePerMatchingLifetimeScope("shell");
                });

            _containerB = _rootContainer.BeginLifetimeScope(
                "shell",
                builder => {
                    builder.Register(ctx => _settingsB);
                    builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().InstancePerMatchingLifetimeScope("shell");
                });
        }
Beispiel #2
0
 public void DictionaryDocument_Operations()
 {
     var builder = new ContainerBuilder();
     builder.RegisterModule(new SolrNetModule("http://localhost:8983/solr"));
     var container = builder.Build();
     var m = container.Resolve<ISolrOperations<Dictionary<string, object>>>();
 }
        // Configure is called after ConfigureServices is called.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            var builder = new ContainerBuilder();
            
            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap = new Dictionary<string, string>();

            //app.UseCookieAuthentication(options =>
            //{
            //    options.AuthenticationScheme = "Temp";
            //    options.AutomaticAuthentication = false;
            //}, "external");

            // Configure the HTTP request pipeline.
            //app.UseStaticFiles();


            // Add the following route for porting Web API 2 controllers.
            // routes.MapWebApiRoute("DefaultApi", "api/{controller}/{id?}");
            app.UseOAuthBearerAuthentication(options =>
            {
                options.Authority = "https://localhost:44333/core";
                //options.Authority = "https://karamaidentityserver.azurewebsites.net/core";
                options.Audience = "https://karama.com/resources";
                options.AutomaticAuthentication = true;                
            });

            app.UseMiddleware<RequiredScopesMiddleware>(new List<string> { "api3" });

            app.UseCors("AllowSpecificOrigins");


            // Add MVC to the request pipeline.
            app.UseMvc();
        }
Beispiel #4
0
 protected override void Load(ContainerBuilder builder)
 {
     throw new NotImplementedException();
     //builder.RegisterAssemblyTypes(typeof(GenericRepository).Assembly)
     //    .Where(x => x.Name.EndsWith("Repository"))
     //    .AsImplementedInterfaces();
 }
Beispiel #5
0
        public void FactoryMethodWillCreateShellRoutes() {
            var settings = new ShellSettings { Name = "Alpha" };
            var builder = new ContainerBuilder();
            builder.RegisterType<ShellRoute>().InstancePerDependency();
            builder.RegisterAutoMocking();
            builder.Register(ctx => settings);

            var container = builder.Build();
            var buildShellRoute = container.Resolve<Func<RouteBase, ShellRoute>>();

            var routeA = new Route("foo", new MvcRouteHandler());
            var route1 = buildShellRoute(routeA);

            var routeB = new Route("bar", new MvcRouteHandler()) {
                DataTokens = new RouteValueDictionary { { "area", "Beta" } }
            };
            var route2 = buildShellRoute(routeB);

            Assert.That(route1, Is.Not.SameAs(route2));

            Assert.That(route1.ShellSettingsName, Is.EqualTo("Alpha"));
            Assert.That(route1.Area, Is.Null);

            Assert.That(route2.ShellSettingsName, Is.EqualTo("Alpha"));
            Assert.That(route2.Area, Is.EqualTo("Beta"));
        }
		private void RegisterContainer() {
			var builder = new ContainerBuilder();
			builder.RegisterControllers(Assembly.GetExecutingAssembly());
			_pluginServicee.Startup(builder);
			_container = builder.Build();
			DependencyResolver.SetResolver(new AutofacDependencyResolver(_container));
		}
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterType<ShippingByWeightService>().As<IShippingByWeightService>().InstancePerHttpRequest();

            //data layer
            var dataSettingsManager = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();

            if (dataProviderSettings != null && dataProviderSettings.IsValid())
            {
                //register named context
                builder.Register<IDbContext>(c => new ShippingByWeightObjectContext(dataProviderSettings.DataConnectionString))
                    .Named<IDbContext>("nop_object_context_shipping_weight_zip")
                    .InstancePerHttpRequest();

                builder.Register<ShippingByWeightObjectContext>(c => new ShippingByWeightObjectContext(dataProviderSettings.DataConnectionString))
                    .InstancePerHttpRequest();
            }
            else
            {
                //register named context
                builder.Register<IDbContext>(c => new ShippingByWeightObjectContext(c.Resolve<DataSettings>().DataConnectionString))
                    .Named<IDbContext>("nop_object_context_shipping_weight_zip")
                    .InstancePerHttpRequest();

                builder.Register<ShippingByWeightObjectContext>(c => new ShippingByWeightObjectContext(c.Resolve<DataSettings>().DataConnectionString))
                    .InstancePerHttpRequest();
            }

            //override required repository with our custom context
            builder.RegisterType<EfRepository<ShippingByWeightRecord>>()
                .As<IRepository<ShippingByWeightRecord>>()
                .WithParameter(ResolvedParameter.ForNamed<IDbContext>("nop_object_context_shipping_weight_zip"))
                .InstancePerHttpRequest();
        }
Beispiel #8
0
        protected void Application_Start()
        {
            Database.SetInitializer(new TrainingDbInitializer());

            var builder = new ContainerBuilder();

            builder.RegisterType<EditableUserRepository>().As<IEditableRepository<User>>();
            builder.RegisterType<EditableSysOpRepository>().As<IEditableRepository<SysOp>>();
            builder.RegisterType<CompanyRepository>().As<IEditableRepository<Company>>();
            builder.RegisterType<CommentRepository>().As<IEditableRepository<Comment>>();
            builder.RegisterType<CourseRepository>().As<IEditableRepository<Course>>();
            builder.RegisterType<EmployeeCourseRepository>().As<IEditableRepository<EmployeeCourse>>();
            builder.RegisterType<DivisionRepository>().As<IEditableRepository<Division>>();
            builder.RegisterType<EmployeeRepository>().As<IEditableRepository<Employee>>();
            builder.RegisterType<EmployeeCourseStatusRepository>().As<IEditableRepository<EmployeeCourseStatus>>();
            builder.RegisterType<InstructorRepository>().As<IEditableRepository<Instructor>>();
            builder.RegisterType<RaceRepository>().As<IEditableRepository<Race>>();
            builder.RegisterType<RegionRepository>().As<IEditableRepository<Region>>();
            builder.RegisterType<ResultRepository>().As<IEditableRepository<Result>>();
            builder.RegisterType<EmployeeDocumentRepository>().As<IEditableRepository<EmployeeDocument>>();
            builder.RegisterType<TrainingScheduleRepository>().As<IEditableRepository<TrainingSchedule>>();
            builder.RegisterType<EmployeeTrainingScheduleRepository>().As<IEditableRepository<EmployeeTrainingSchedule>>();
            builder.RegisterType<TrainingManualRepository>().As<IEditableRepository<TrainingManual>>();
            builder.RegisterType<CompanyBudgetRepository>().As<IEditableRepository<CompanyBudget>>();
            builder.RegisterType<DivisionBudgetRepository>().As<IEditableRepository<DivisionBudget>>();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
            GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            GlobalConfiguration.Configure(WebApiConfig.Register);
            GlobalConfiguration.Configuration.MessageHandlers.Add(new BasicTrainingAuthMessageHandler());
        }
Beispiel #9
0
        private static void RegisterTypes(ContainerBuilder builder)
        {
            string baseDirectory = HttpContext.Current.Server.MapPath("~/App_Data") + ConfigurationManager.AppSettings["dataFolderName"];

            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            var repositoryAssemblies = Assembly.Load("FileRepository");
            builder.RegisterAssemblyTypes(repositoryAssemblies).AsImplementedInterfaces().WithParameter(new NamedParameter("path", baseDirectory));

            var serviceAssemblies = Assembly.Load("Services");
            builder.RegisterAssemblyTypes(serviceAssemblies).AsImplementedInterfaces();

            var configurationManagerWrapperAssembly = Assembly.Load("ConfigurationManagerWrapper");
            builder.RegisterAssemblyTypes(configurationManagerWrapperAssembly).AsImplementedInterfaces();

            var fileAssembly = Assembly.Load("SystemFileAdapter");
            builder.RegisterAssemblyTypes(fileAssembly).AsImplementedInterfaces();

            //builder.RegisterType<NLogLogger>().As<ILogger>();
            builder.Register(c => new NLogLogger()).As<ILogger>().InstancePerHttpRequest();
            builder.RegisterType<UserHub>();
            builder.RegisterType<TodoHub>();
            //            builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
            builder.RegisterFilterProvider();
        }
Beispiel #10
0
        public static IContainer BuildContainer()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<StatisticsViewModel>();
            builder.RegisterType<DetailsViewModel>();

            builder.RegisterType<MainView>();
            builder.RegisterType<MainViewModel>();
            builder.RegisterType<CameraView>();
            builder.RegisterType<CameraViewModel>();

            builder.RegisterType<MvxMessengerHub>().As<IMvxMessenger>().SingleInstance();
            builder.RegisterType<ApplicationDataRepository>().As<IApplicationDataRepository>();

            builder.RegisterAssemblyTypes(typeof(MyShuttleClient).Assembly)
                .Where(t => t.Name.EndsWith("Service"))
                .AsImplementedInterfaces();

            builder.RegisterAssemblyTypes(typeof(MyShuttleClient).Assembly)
                .Where(t => t.Name.EndsWith("ServiceSingleton"))
                .AsImplementedInterfaces().SingleInstance();

            builder.RegisterType<MyShuttleClient>().As<IMyShuttleClient>();

            return builder.Build();
        }
Beispiel #11
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            // Add framework services.
            services.AddApplicationInsightsTelemetry(Configuration);

            services.AddEntityFramework()
                .AddSqlServer()
                .AddDbContext<ApplicationDbContext>(options =>
                    options.UseSqlServer(Configuration["Data:DefaultConnection:ConnectionString"]));

            services.AddIdentity<ApplicationUser, IdentityRole>()
                .AddEntityFrameworkStores<ApplicationDbContext>()
                .AddDefaultTokenProviders();

            services.AddMvc();

            // Create the Autofac container builder.
            var builder = new ContainerBuilder();
            // Add any Autofac modules or registrations.
            builder.RegisterModule(new ServiceModule());
            // Populate the services.
            builder.Populate(services);
            // Build the container.
            var container = builder.Build();
            // Resolve and return the service provider.
            return container.Resolve<IServiceProvider>();
        }
        public static void RegisterAutofac()
        {
            var builder = new ContainerBuilder();

            // Register your MVC controllers.
            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            // OPTIONAL: Register model binders that require DI.
            builder.RegisterModelBinders(Assembly.GetExecutingAssembly());
            builder.RegisterModelBinderProvider();

            // OPTIONAL: Register web abstractions like HttpContextBase.
            builder.RegisterModule<AutofacWebTypesModule>();

            // OPTIONAL: Enable property injection in view pages.
            builder.RegisterSource(new ViewRegistrationSource());

            // OPTIONAL: Enable property injection into action filters.
            builder.RegisterFilterProvider();

            // Register services
            RegisterServices(builder);

            // Set the dependency resolver to be Autofac.
            var container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }
        public void TheyShouldBeResolvable()
        {
            var interceptorTypes = new[] {typeof (DummyInterceptor)};

            var builder = new ContainerBuilder();
            var typeProvider = Substitute.For<ITypeProvider>();
            typeProvider.InterceptorTypes.Returns(interceptorTypes);

            builder.RegisterNimbus(typeProvider);

            using (var container = builder.Build())
            using (var dependencyResolver = container.Resolve<IDependencyResolver>())
            using (var scope = dependencyResolver.CreateChildScope())
            {
                var interceptorSetting = new GlobalOutboundInterceptorTypesSetting
                                         {
                                             Value = interceptorTypes
                                         };
                var outboundInterceptorFactory = new OutboundInterceptorFactory(interceptorSetting,
                                                                                new PropertyInjector(Substitute.For<IClock>(),
                                                                                                     Substitute.For<IDispatchContextManager>(),
                                                                                                     Substitute.For<ILargeMessageBodyStore>()));

                var dummyNimbusMessage = new NimbusMessage("nullQueue");
                var interceptors = outboundInterceptorFactory.CreateInterceptors(scope, dummyNimbusMessage);

                interceptors.Count().ShouldBe(1);
            }
        }
Beispiel #14
0
        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterModule(new RepositoryModule());

            builder.RegisterType(typeof(SampleArchContext)).As(typeof(DbContext)).InstancePerLifetimeScope();
            builder.RegisterType(typeof(UnitOfWork)).As(typeof(IUnitOfWork)).InstancePerRequest();
        }
    protected void Application_Start()
    {
        #region ApplicationStart

        ContainerBuilder builder = new ContainerBuilder();

        // Register your MVC controllers.
        builder.RegisterControllers(typeof(MvcApplication).Assembly);

        // Set the dependency resolver to be Autofac.
        IContainer container = builder.Build();

        BusConfiguration busConfiguration = new BusConfiguration();
        busConfiguration.EndpointName("Samples.MvcInjection.WebApplication");
        // ExistingLifetimeScope() ensures that IBus is added to the container as well,
        // allowing you to resolve IBus from your own components.
        busConfiguration.UseContainer<AutofacBuilder>(c => c.ExistingLifetimeScope(container));
        busConfiguration.UseSerialization<JsonSerializer>();
        busConfiguration.UsePersistence<InMemoryPersistence>();
        busConfiguration.EnableInstallers();

        bus = Bus.CreateSendOnly(busConfiguration);

        DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

        AreaRegistration.RegisterAllAreas();
        RegisterRoutes(RouteTable.Routes);

        #endregion
    }
 public static void RegisterTypes()
 {
     var builder = new ContainerBuilder();
     builder.RegisterType<VideoRepository>().As<IVideoRepository>().InstancePerLifetimeScope();
     builder.RegisterType<OrderRepository>().As<IOrderRepository>().InstancePerLifetimeScope();
     builder.RegisterType<UserRepository>().As<IUserRepository>();
     builder.RegisterType<MockPaymentProcessor>().As<IPaymentProcessor>().InstancePerLifetimeScope();
     builder.RegisterType<StoreController>()
                         .UsingConstructor(typeof(IVideoRepository), typeof(IUserRepository));
     builder.RegisterType<CartController>()
                         .UsingConstructor(typeof(IVideoRepository));
     builder.RegisterType<WishlistController>()
                         .UsingConstructor(typeof(IUserRepository), typeof(IVideoRepository));
     builder.RegisterType<OrderController>()
                         .UsingConstructor(typeof(IVideoRepository), typeof(IOrderRepository), typeof(IUserRepository), typeof(IPaymentProcessor));
     builder.RegisterType<HomeController>()
                         .UsingConstructor(typeof(IVideoRepository), typeof(IOrderRepository), typeof(IUserRepository));
     builder.RegisterType<VideosController>()
                         .UsingConstructor(typeof(IVideoRepository));
     builder.RegisterType<OrdersController>()
                         .UsingConstructor(typeof(IOrderRepository));
     builder.RegisterType<UsersController>()
                         .UsingConstructor(typeof(IUserRepository));
     builder.RegisterType<AccountController>()
                         .UsingConstructor(typeof(IUserRepository));
     var container = builder.Build();
     var resolver = new AutofacDependencyResolver(container);
     DependencyResolver.SetResolver(resolver);
 }
Beispiel #17
0
        public static void Init()
        {
            var serviceBusConnectionString = ConfigurationManager.ConnectionStrings["ServiceBus"].ConnectionString;
            var builder = new ContainerBuilder();
            var typeProvider = new AssemblyScanningTypeProvider(
                   Assembly.GetAssembly(typeof(ExampleEventHandler)),
                   Assembly.GetAssembly(typeof(ExampleCommand))
                   );

            var applicationName = Assembly.GetExecutingAssembly().ToNimbusName();
            var instanceName = Environment.MachineName;

            builder.RegisterNimbus(typeProvider);
            builder.RegisterType<NimbusLogger>().As<ILogger>();
            builder.Register(componetContext => new BusBuilder()
                .Configure()
                .WithConnectionString(serviceBusConnectionString)
                .WithNames(applicationName, instanceName)
                .WithTypesFrom(typeProvider)
                .WithDefaultTimeout(TimeSpan.FromSeconds(30))
                .WithAutofacDefaults(componetContext)
                .Build())
                .As<IBus>()
                .AutoActivate()
                .OnActivated(o => o.Instance.Start())
                .SingleInstance();

            _container = builder.Build();
        }
Beispiel #18
0
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();

            containerBuilder.RegisterType<Cpu>().As<ICpu>().SingleInstance();
            containerBuilder.RegisterType<Emulator>().As<IEmulator>();
            containerBuilder.RegisterType<Memory>().As<IMemory>().SingleInstance();
            containerBuilder.RegisterType<Ppu>().As<IPpu>();

            var instructionTypes = Assembly.GetExecutingAssembly().GetTypes().Where(f => typeof(IInstruction).IsAssignableFrom(f) && !f.IsAbstract).ToArray();

            containerBuilder.RegisterTypes(instructionTypes)
                .As<IInstruction>();

            var container = containerBuilder.Build();

            var emulator = container.Resolve<IEmulator>();
            var memory = container.Resolve<IMemory>();
            memory.SetCartridge(new Cartridge("../../roms/nestest.nes"));
            emulator.Reset();
            for (;;)
            {
                emulator.Step();
            }
        }
        protected void Application_Start() {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);


            Store = new DocumentStore() { ConnectionStringName = "Onboarding" };
            Store.Initialize();
            var builder = new ContainerBuilder();

            Store.Conventions.RegisterIdConvention<User>((dbname, commands, user) => "users/" + user.UserName);

            builder.Register(c => {
                var store = new DocumentStore {
                    ConnectionStringName = "Onboarding",
                    DefaultDatabase = "Onboarding"
                }.Initialize();

                return store;

            }).As<IDocumentStore>().SingleInstance();

            builder.Register(c => c.Resolve<IDocumentStore>().OpenAsyncSession()).As<IAsyncDocumentSession>().InstancePerLifetimeScope();

        }
Beispiel #20
0
 public void Init(IEnumerable<Type> dataMigrations) {
    
     var builder = new ContainerBuilder();
     _folders = new StubFolders();
     var contentDefinitionManager = new Mock<IContentDefinitionManager>().Object;
     
     builder.RegisterInstance(new ShellSettings { DataTablePrefix = "TEST_"});
     
     builder.RegisterType<SqlServerDataServicesProvider>().As<IDataServicesProvider>();
     builder.RegisterType<DataServicesProviderFactory>().As<IDataServicesProviderFactory>();
     builder.RegisterType<NullInterpreter>().As<IDataMigrationInterpreter>();
     builder.RegisterInstance(_folders).As<IExtensionFolders>();
     builder.RegisterInstance(contentDefinitionManager).As<IContentDefinitionManager>();
     builder.RegisterType<ExtensionManager>().As<IExtensionManager>();
     builder.RegisterType<DataMigrationManager>().As<IDataMigrationManager>();
     builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
     builder.RegisterType<StubCacheManager>().As<ICacheManager>();
     builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();
     builder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>();
     _session = _sessionFactory.OpenSession();
     builder.RegisterInstance(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>().As<ITransactionManager>();
     foreach(var type in dataMigrations) {
         builder.RegisterType(type).As<IDataMigration>();
     }
     _container = builder.Build();
     _container.Resolve<IExtensionManager>();
     _dataMigrationManager = _container.Resolve<IDataMigrationManager>();
     _repository = _container.Resolve<IRepository<DataMigrationRecord>>();
     _transactionManager = _container.Resolve<ITransactionManager>();
     InitDb();
 }
        public void Init() {
            _contentDefinitionManager = new Mock<IContentDefinitionManager>();

            var builder = new ContainerBuilder();
            builder.RegisterType<DefaultContentManager>().As<IContentManager>();
            builder.RegisterType<DefaultContentManagerSession>().As<IContentManagerSession>();
            builder.RegisterInstance(_contentDefinitionManager.Object);
            builder.RegisterInstance(new Mock<IContentDisplay>().Object);

            builder.RegisterType<AlphaPartHandler>().As<IContentHandler>();
            builder.RegisterType<BetaPartHandler>().As<IContentHandler>();
            builder.RegisterType<GammaPartHandler>().As<IContentHandler>();
            builder.RegisterType<DeltaPartHandler>().As<IContentHandler>();
            builder.RegisterType<EpsilonPartHandler>().As<IContentHandler>();
            builder.RegisterType<FlavoredPartHandler>().As<IContentHandler>();
            builder.RegisterType<StyledHandler>().As<IContentHandler>();
            builder.RegisterType<DefaultShapeTableManager>().As<IShapeTableManager>();
            builder.RegisterType<ShapeTableLocator>().As<IShapeTableLocator>();
            builder.RegisterType<DefaultShapeFactory>().As<IShapeFactory>();
            builder.RegisterType<DefaultContentDisplay>().As<IContentDisplay>();

            builder.RegisterType<StubExtensionManager>().As<IExtensionManager>();

            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));

            _session = _sessionFactory.OpenSession();
            builder.RegisterInstance(new TestSessionLocator(_session)).As<ISessionLocator>();

            _container = builder.Build();
            _manager = _container.Resolve<IContentManager>();
        }
        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<ViewFactory>().As<IViewFactory>().SingleInstance();
            builder.RegisterType<Navigator>().As<INavigator>().SingleInstance();
            builder.Register<INavigation>(ctx => App.Current.MainPage.Navigation).SingleInstance();

        }
Beispiel #23
0
        public void Init() {
            _tempFolderName = Path.GetTempFileName();
            File.Delete(_tempFolderName);
            var assembly = GetType().Assembly;
            foreach (var name in assembly.GetManifestResourceNames()) {
                if (name.StartsWith(DataPrefix)) {
                    string text;
                    using (var stream = assembly.GetManifestResourceStream(name)) {
                        using (var reader = new StreamReader(stream))
                            text = reader.ReadToEnd();

                    }

                    // Pro filtering
                    var relativePath = name
                        .Substring(DataPrefix.Length)
                        .Replace(".txt", ":txt")
                        .Replace(".recipe.xml", ":recipe:xml")
                        .Replace('.', Path.DirectorySeparatorChar)
                        .Replace(":txt", ".txt")
                        .Replace(":recipe:xml", ".recipe.xml");

                    var targetPath = Path.Combine(_tempFolderName, relativePath);

                    Directory.CreateDirectory(Path.GetDirectoryName(targetPath));
                    using (var stream = new FileStream(targetPath, FileMode.Create)) {
                        using (var writer = new StreamWriter(stream)) {
                            writer.Write(text);
                        }
                    }
                }
            }

            var builder = new ContainerBuilder();
            var harvester = new ExtensionHarvester(new StubCacheManager(), new StubWebSiteFolder(), new Mock<ICriticalErrorProvider>().Object);
            _folders = new ModuleFolders(new[] { _tempFolderName }, harvester);
            builder.RegisterType<RecipeManager>().As<IRecipeManager>();
            builder.RegisterType<RecipeHarvester>().As<IRecipeHarvester>();
            builder.RegisterType<RecipeStepExecutor>().As<IRecipeStepExecutor>();
            builder.RegisterType<StubStepQueue>().As<IRecipeStepQueue>().InstancePerLifetimeScope();
            builder.RegisterType<StubRecipeJournal>().As<IRecipeJournal>();
            builder.RegisterType<StubRecipeScheduler>().As<IRecipeScheduler>();
            builder.RegisterType<ExtensionManager>().As<IExtensionManager>();
            builder.RegisterType<StubAppDataFolder>().As<IAppDataFolder>();
            builder.RegisterType<StubClock>().As<IClock>();
            builder.RegisterType<StubCacheManager>().As<ICacheManager>();
            builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();
            builder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>();
            builder.RegisterInstance(_folders).As<IExtensionFolders>();
            builder.RegisterInstance(new Mock<IRecipeExecuteEventHandler>().Object);
            builder.RegisterType<Environment.Extensions.ExtensionManagerTests.StubLoaders>().As<IExtensionLoader>();
            builder.RegisterType<RecipeParser>().As<IRecipeParser>();
            builder.RegisterType<StubWebSiteFolder>().As<IWebSiteFolder>();
            builder.RegisterType<CustomRecipeHandler>().As<IRecipeHandler>();

            _container = builder.Build();
            _recipeManager = _container.Resolve<IRecipeManager>();
            _recipeParser = _container.Resolve<IRecipeParser>();
            _recipeHarvester = _container.Resolve<IRecipeHarvester>();
        }
        public void ResolveSolrOperations_withMultiCore()
        {
            // Arrange
            var builder = new ContainerBuilder();
            var cores = new SolrServers {
                                new SolrServerElement {
                                        Id = "entity1",
                                        DocumentType = typeof (Entity1).AssemblyQualifiedName,
                                        Url = "http://localhost:8983/solr/coreEntity1",
                                    },
                               new SolrServerElement {
                                        Id = "entity2",
                                        DocumentType = typeof (Entity2).AssemblyQualifiedName,
                                        Url = "http://localhost:8983/solr/coreEntity2",
                                },
                            };

            builder.RegisterModule(new SolrNetModule(cores));
            var container = builder.Build();

            // Act
            var solrOperations1 = container.Resolve<ISolrOperations<Entity1>>();
            var solrOperations2 = container.Resolve<ISolrOperations<Entity2>>();

            // Assert
            Assert.IsTrue(solrOperations1 is SolrServer<Entity1>);
            Assert.IsTrue(solrOperations2 is SolrServer<Entity2>);
        }
Beispiel #25
0
        /// <summary>
        /// Override to add registrations to the container.
        /// </summary>
        protected override void Load(ContainerBuilder builder)
        {
            base.Load(builder);

            Log.Trace("Registering Cyclops.DependencyInjection module");
            builder.RegisterCyclopsRepositories<PetstoreRepository>("PetstoreDatabase");
        }
        public static void Configure()
        {
            var builder = new ContainerBuilder();

            var config = GlobalConfiguration.Configuration;

            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            //builder.RegisterWebApiFilterProvider(config);
            var dbPath = WebConfigurationManager.AppSettings["sqLiteDb"].Replace(@"~\", "");
            bool useDiskConnOnlyValue;
            if (!bool.TryParse(WebConfigurationManager.AppSettings["useDiskConnOnly"], out useDiskConnOnlyValue))
            {
                throw new InvalidOperationException("Invalid useDiskCOnnOnly in web.config");
            }

            var lucenceIndeDirectory = WebConfigurationManager.AppSettings["lucenceIndeDirectory"].Replace(@"~\", "");

            builder.RegisterModule(new LuceneIndexModule(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, lucenceIndeDirectory)));

            builder.RegisterModule(new ConnectionManagerModule(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dbPath), useDiskConnOnlyValue));
            builder.RegisterModule(new LocationControllerModule());

            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
        }
Beispiel #27
0
        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Foo>();
            builder.RegisterAndActivate<ScopeFactory<Foo>>();

            Console.WriteLine("MyModule.Load()");
        }
Beispiel #28
0
        public static ContainerBuilder GetMinimalBuilder()
        {
            var builder = new ContainerBuilder();
            builder.Register(c => ReadAppConfigConfig()).SingleInstance();

            return builder;
        }
        public void Init() {
            var builder = new ContainerBuilder();
            //builder.RegisterModule(new ImplicitCollectionSupportModule());
            builder.RegisterType<MembershipService>().As<IMembershipService>();
            builder.RegisterType<DefaultContentQuery>().As<IContentQuery>();
            builder.RegisterType<DefaultContentManager>().As<IContentManager>();
            builder.RegisterType(typeof(SettingsFormatter))
                .As(typeof(IMapper<XElement, SettingsDictionary>))
                .As(typeof(IMapper<SettingsDictionary, XElement>));
            builder.RegisterType<ContentDefinitionManager>().As<IContentDefinitionManager>();
            builder.RegisterType<DefaultContentManagerSession>().As<IContentManagerSession>();
            builder.RegisterType<UserPartHandler>().As<IContentHandler>();
            builder.RegisterType<StubWorkContextAccessor>().As<IWorkContextAccessor>();
            builder.RegisterType<OrchardServices>().As<IOrchardServices>();
            builder.RegisterAutoMocking(MockBehavior.Loose);
            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
            builder.RegisterInstance(new Mock<IMessageEventHandler>().Object);
            builder.RegisterType<DefaultMessageManager>().As<IMessageManager>();
            builder.RegisterType<DefaultShapeTableManager>().As<IShapeTableManager>();
            builder.RegisterType<DefaultShapeFactory>().As<IShapeFactory>();
            builder.RegisterType<StubExtensionManager>().As<IExtensionManager>();
            builder.RegisterType<DefaultContentDisplay>().As<IContentDisplay>();

            _session = _sessionFactory.OpenSession();
            builder.RegisterInstance(new TestSessionLocator(_session)).As<ISessionLocator>();
            _container = builder.Build();
            _membershipService = _container.Resolve<IMembershipService>();
        }
Beispiel #30
0
        public static void Configure()
        {
            var assemblies = BuildManager.GetReferencedAssemblies().Cast<Assembly>().ToArray();
            var builder = new ContainerBuilder();

            builder.RegisterAssemblyTypes(assemblies)
                .Where(t => typeof(IStartable).IsAssignableFrom(t))
                .As<IStartable>()
                .SingleInstance();

            builder.RegisterAssemblyModules(assemblies);

            builder.RegisterControllers(Assembly.GetExecutingAssembly());
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            var container = builder.Build();

            // Set the dependency resolver for Web API.
            var webApiResolver = new AutofacWebApiDependencyResolver(container);
            GlobalConfiguration.Configuration.DependencyResolver = webApiResolver;

            // Set the dependency resolver for MVC.
            var mvcResolver = new AutofacDependencyResolver(container);
            DependencyResolver.SetResolver(mvcResolver);
        }
        protected override void Register(Autofac.ContainerBuilder builder)
        {
            _descriptor              = new ShellDescriptor {
            };
            _testViewEngine          = new TestViewEngine();
            _testVirtualPathProvider = new TestVirtualPathProvider {
                TestViewEngine = _testViewEngine
            };

            builder.Register(ctx => _descriptor);
            builder.RegisterType <StylesheetBindingStrategy>().As <IShapeTableProvider>();
            builder.RegisterInstance(_testViewEngine).As <IShapeTemplateViewEngine>();
            builder.RegisterInstance(_testVirtualPathProvider).As <IVirtualPathProvider>();

            var extensionManager = new Mock <IExtensionManager>();

            builder.Register(ctx => extensionManager);
            builder.Register(ctx => extensionManager.Object);
        }
Beispiel #32
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterType <DefaultRequestDispacher>().As <IRequestDispatcher>();
            builder.RegisterType <RequestHandlerResolver>().As <IRequestHandlerResolver>();
            builder.RegisterType <DefaultWebApiRequestProcessor>().As <IWebApiRequestProcessor>();
            var requestHandlerInterface   = typeof(IRequestHandler <,>);
            var requestHandlerDefinitions = RequestHandlerFinder.InAssembly(this.GetType().GetTypeInfo().Assembly);

            foreach (var requestHandler in requestHandlerDefinitions)
            {
                builder.RegisterType(requestHandler.RequestHandlerType)
                .As(requestHandlerInterface.MakeGenericType(requestHandler.RequestType, requestHandler.ResponseType));
            }



            var config    = new HttpConfiguration();
            var generated = config.ConfigureRequestHandlers(requestHandlerDefinitions);

            builder.RegisterApiControllers(generated);

            var container = builder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            // Register the Autofac middleware FIRST, then the Autofac Web API middleware,
            // and finally the standard Web API middleware.
            config.MapHttpAttributeRoutes();
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);



            config.EnableSwagger(c =>
            {
                c.SingleApiVersion("v1", "RequestHandlers.TestHost");
            })
            .EnableSwaggerUi(c =>
            {
            });
        }
Beispiel #33
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            // Autofac Configuration
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterControllers(typeof(MvcApplication).Assembly).PropertiesAutowired();


            builder.RegisterModule(new ServiceModule());

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }
Beispiel #34
0
        static IoC()
        {
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterModule(new MediatrModule());

            builder.RegisterType <WebAPI>().AsSelf().SingleInstance();
            builder.RegisterType <QueryWorker>().AsSelf().SingleInstance();
            builder.RegisterType <ServiceImpl>().AsSelf().SingleInstance();

            builder.Register(x =>
            {
                var sqlString =
                    "Data Source=.;Initial Catalog=BusinessModel;Integrated Security=true;User Id=POSSQL;Password=123456";
                return(SqlServerTools.CreateDataConnection(sqlString));
            }
                             ).InstancePerLifetimeScope();
            Default = builder.Build();
        }
Beispiel #35
0
        /// <summary>
        /// 注册时指定参数(注册类型 + 参数)
        /// 【WithParameter】
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder)
        {
            builder.RegisterType <StudentRepository>()
            .As <IStudentRepository>()
            .AsSelf();

            builder.RegisterType <TeacherRepository>()
            .As <ITeacherRepository>();

            builder.RegisterType <StudentAppService>()
            .UsingConstructor(typeof(StudentRepository), typeof(ITeacherRepository), typeof(string))
            //.WithParameter("test", "123")//方法1.直接指定参数名称和参数值
            .WithParameter(new TypedParameter(typeof(string), "456"))    //方法2.传入Parameter对象
                                                                         //.WithParameter((pi, cc) => pi.ParameterType == typeof(string) && pi.Name == "test", (pi, cc) => "789")//方法3.传入两个委托分别指定筛选参数的方法和参数值
                                                                         //.WithParameters(new List<TypedParameter> { new TypedParameter(typeof(string), "110") })//方法4.传入Parameter对象集合(参考方法2)
            .As <IStudentAppService>();;

            return(builder);
        }
Beispiel #36
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);


            //Autofac Configuration
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterControllers(typeof(MvcApplication).Assembly).PropertiesAutowired();
            builder.RegisterApiControllers(typeof(MvcApplication).Assembly).PropertiesAutowired();


            builder.RegisterModule(new ServiceModule());
            builder.RegisterModule(new EFModule());


            //var x = new ApplicationDbContext();
            //builder.Register<ApplicationDbContext>(c => x);
            //builder.Register<UserStore<ApplicationUser>>(c => new UserStore<ApplicationUser>(x)).AsImplementedInterfaces();
            //builder.Register<IdentityFactoryOptions<ApplicationUserManager>>(c => new IdentityFactoryOptions<ApplicationUserManager>()
            //{
            //	DataProtectionProvider = new Microsoft.Owin.Security.DataProtection.DpapiDataProtectionProvider("ApplicationName")
            //});
            //builder.RegisterType<ApplicationUserManager>();

            var container = builder.Build();

            //DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // Set the dependency resolver for MVC.
            var mvcResolver = new AutofacDependencyResolver(container);

            DependencyResolver.SetResolver(mvcResolver);

            // Set the dependency resolver for Web API.
            var webApiResolver = new AutofacWebApiDependencyResolver(container);

            GlobalConfiguration.Configuration.DependencyResolver = webApiResolver;
        }
Beispiel #37
0
        /// <inheritdoc/>
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            this.scope      = BuildContainer().BeginLifetimeScope();
            this.MainWindow = this.scope.Resolve <Views.MainWindow>();
            this.MainWindow.Show();

            IContainer BuildContainer()
            {
                var containerBuilder = new Autofac.ContainerBuilder();

                containerBuilder.RegisterType <ViewModels.MainViewModel>();
                containerBuilder.RegisterType <ViewModels.TimerViewModel>().WithParameter(new NamedParameter(ViewModels.TimerViewModel.ConstructorIntervalCollectionName, Models.Interval.PomodoroIntervalCollection)).WithMetadata(MetaTypeKey, ViewModels.ViewModelType.Pomodoro).As <ViewModels.IViewModel>();
                containerBuilder.RegisterType <ViewModels.TimerViewModel>().WithParameter(new NamedParameter(ViewModels.TimerViewModel.ConstructorIntervalCollectionName, Models.Interval.SitStandIntervalCollection)).WithMetadata(MetaTypeKey, ViewModels.ViewModelType.SitStand).As <ViewModels.IViewModel>();
                containerBuilder.RegisterType <ViewModels.PreferencesViewModel>().AsSelf().WithMetadata(MetaTypeKey, ViewModels.ViewModelType.Preferences).As <ViewModels.IViewModel>();
                containerBuilder.RegisterType <Views.MainWindow>();
                return(containerBuilder.Build());
            }
        }
Beispiel #38
0
    public void Configure(IAppBuilder appBuilder)
    {
        var config = new HttpConfiguration();

        config.MapHttpAttributeRoutes();                                                      // using attribute based routing because I prefer it

        var builder = new Autofac.ContainerBuilder();

        // Authentication Filter
        builder.Register(c => new AuthoriseAttribute())
        .AsWebApiAuthenticationFilterFor <StatsController>()
        .InstancePerLifetimeScope();

        builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).PropertiesAutowired(); // Create the container builder.
        builder.RegisterApiControllers(Assembly.GetExecutingAssembly());                       // Register the Web API controllers.
        builder.RegisterWebApiFilterProvider(config);                                          // optional

        builder.RegisterType <Stat>().As <IStat>().InstancePerRequest();


        var container = builder.Build();

        config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

        appBuilder.UseAutofacMiddleware(container);
        appBuilder.UseAutofacWebApi(config);                                                  // Make sure the Autofac lifetime scope is passed to Web API.
        appBuilder.UseWebApi(config);                                                         // enable web-api


        string filedir = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "../../web");

        appBuilder.UseFileServer(new FileServerOptions
        {
            EnableDefaultFiles  = true,
            DefaultFilesOptions =
            {
                DefaultFileNames = new[] { "Index.html" }
            },
            EnableDirectoryBrowsing = true,
            FileSystem = new PhysicalFileSystem(filedir),
        });
    }
Beispiel #39
0
        protected override void Load(Autofac.ContainerBuilder builder)
        {
            base.Load(builder);

            builder.RegisterType<BL>()
                .AsSelf()
                .InstancePerLifetimeScope();

            builder.RegisterType<GitSubmissionStoreProvider>()
                .As<ISubmissionStoreProvider>()
                .InstancePerDependency();

            builder.RegisterType<TestResultSaveService>()
                .As<ITestResultSaveService>()
                .SingleInstance();

            builder.Register<IEnumerable<ISubmissionStoreProvider>>((c, p) => GitSubmissionStoreProvider.GetSubmissions(p.Named<string>("course"), p.Named<string>("exampleRegex")))
                .As<IEnumerable<ISubmissionStoreProvider>>()
                .InstancePerDependency();
        }
        public static void SetUpAutofac()
        {
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).InstancePerRequest();
            builder.RegisterControllers(typeof(WebApiApplication).Assembly).PropertiesAutowired();
            builder.RegisterModule(new RepositoryModule());
            builder.RegisterModule(new ManagerModule());
            builder.RegisterModule(new EFModule());
            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            var WebApiResolver = new AutofacWebApiDependencyResolver(container);

            GlobalConfiguration.Configuration.DependencyResolver = WebApiResolver;
            var MvcResolver = new AutofacDependencyResolver(container);

            DependencyResolver.SetResolver(MvcResolver);
        }
Beispiel #41
0
        private static void SetupPostgres(Autofac.ContainerBuilder builder)
        {
            var cs = ConfigurationManager.AppSettings["ConnectionString"];

            if (string.IsNullOrEmpty(cs))
            {
                throw new ConfigurationErrorsException(@"ConnectionString is missing from configuration. Add ConnectionString to <appSettings>
Example: <add key=""ConnectionString"" value=""server=postgres.localhost;port=5432;database=MyDatabase;user=postgres;password=123456;encoding=unicode"" />");
            }

            builder.RegisterInstance(new NGS.DatabasePersistence.Postgres.ConnectionInfo(cs));
            builder.RegisterType <PostgresQueryManager>().As <IDatabaseQueryManager>().InstancePerLifetimeScope();
            builder.RegisterType <PostgresDatabaseQuery>().As <IPostgresDatabaseQuery>();
            builder.Register(c => c.Resolve <IDatabaseQueryManager>().CreateQuery()).As <IDatabaseQuery>().InstancePerLifetimeScope();
            builder.RegisterType <PostgresDatabaseNotification>().As <IDataChangeNotification, IEagerNotification>().SingleInstance();

            builder.RegisterType <PostgresObjectFactory>().As <IPostgresConverterRepository, IPostgresConverterFactory>().SingleInstance();

            builder.RegisterType <NGS.DatabasePersistence.Postgres.QueryGeneration.QueryExecutor>();
        }
Beispiel #42
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            //AutoMapper
            AutoMapperConfig.Initialize();

            //Autofac Configuration
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterControllers(typeof(MvcApplication).Assembly).PropertiesAutowired();

            builder.RegisterModule(new RepositoryModule());
            builder.RegisterModule(new ServiceModule());
            builder.RegisterModule(new EFModule());

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }
Beispiel #43
0
        /// <summary>
        /// Registers the  account Service
        /// </summary>
        /// <param name="builder"></param>
        protected static void RegisterApplicationAccountService(Autofac.ContainerBuilder builder)
        {
            builder.RegisterType <iPow.Application.account.Service.SightInfoService>()
            .As <iPow.Application.account.Service.ISightInfoService>();
            builder.RegisterType <iPow.Application.account.Service.TourPlanDetailService>()
            .As <iPow.Application.account.Service.ITourPlanDetailService>();

            //JPomichael  Time 2012-6-7
            builder.RegisterType <iPow.Application.account.Service.CityInfoMoreService>()
            .As <iPow.Application.account.Service.ICityInfoMoreService>();
            //end

            //JPomichael Time 2012-6-18
            builder.RegisterType <iPow.Application.account.Service.HotelInfoService>()
            .As <iPow.Application.account.Service.IHotelInfoService>();

            //JPomichael Time 2012-6-19
            builder.RegisterType <iPow.Application.account.Service.HotelPropertyInfoService>()
            .As <iPow.Application.account.Service.IHotelPropertyInfoService>();
        }
Beispiel #44
0
        public override bool FinishedLaunching(UIApplication app, NSDictionary options)
        {
            global::Xamarin.Forms.Forms.Init();

            // Code for starting up the Xamarin Test Cloud Agent
                        #if ENABLE_TEST_CLOUD
            Xamarin.Calabash.Start();
                        #endif

            var containerBuilder = new Autofac.ContainerBuilder();

            containerBuilder.RegisterType <MediaPicker> ().As <IMediaPicker> ();
            containerBuilder.RegisterType <TesseractApi> ().As <ITesseractApi> ();

            Resolver.SetResolver(new AutofacResolver(containerBuilder.Build()));

            LoadApplication(new App());

            return(base.FinishedLaunching(app, options));
        }
Beispiel #45
0
        public IContainer BuildContainer(Logger log)
        {
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterInstance(log);
            builder.RegisterAssemblyTypes(typeof(MvcApplication).Assembly).AsImplementedInterfaces();

//            Uncomment for InMemory Storage
//            builder.RegisterAssemblyTypes(typeof(Data.InMemory.Repositories.RecipeRepository).Assembly)
//                   .AsImplementedInterfaces()
//                   .SingleInstance();

            //Uncomment for SQL storage
//            builder.RegisterType<DataContext>().AsSelf().InstancePerRequest();
//            builder.RegisterAssemblyTypes(typeof(Data.SQL.Repositories.RecipeRepository).Assembly).AsImplementedInterfaces().InstancePerRequest();

            //Uncomment for Azure table storage
//            builder.RegisterAssemblyTypes(typeof(PancakeProwler.Data.Table.Repositories.RecipeRepository).Assembly).AsImplementedInterfaces().PropertiesAutowired();

            //Uncomment for Azure DocumentDb storage
//            builder.RegisterAssemblyTypes(typeof(PancakeProwler.Data.DocumentDb.RecipeRepository).Assembly).AsImplementedInterfaces().InstancePerRequest().PropertiesAutowired();

            //Uncomment for storage queue
            //builder.RegisterAssemblyTypes(typeof(PancakeProwler.Data.Queue.Repositories.BookCreationRequestRepository).Assembly).AsImplementedInterfaces().PropertiesAutowired();

            //Uncomment for PostgreSQL storage
            builder.RegisterAssemblyTypes(typeof(PancakeProwler.Data.Postgres.IPostgresRepository).Assembly).AsImplementedInterfaces().InstancePerRequest().PropertiesAutowired();

            builder.RegisterAssemblyTypes(typeof(PancakeProwler.Data.ServiceBus.Repositories.BookCreationRequestRepository).Assembly).AsImplementedInterfaces().PropertiesAutowired();

            builder.RegisterType <PancakeProwler.Data.Common.Repositories.BlobImageRepository>().AsImplementedInterfaces();

            // Uncomment for Elastic Search
            builder.RegisterType <ElasticSearchProvider>().AsImplementedInterfaces();

            // Uncomment for Azure Search
//            builder.RegisterType<AzureSearchProvider>().AsImplementedInterfaces();

            builder.RegisterAssemblyTypes(typeof(MvcApplication).Assembly).Where(x => x.Name.EndsWith("Controller")).AsSelf().PropertiesAutowired();
            return(builder.Build());
        }
Beispiel #46
0
        public void Run(string settingName = "JimuAppServerSettings")
        {
            var   containerBuilder = new Autofac.ContainerBuilder();
            var   serverBuilder    = new ApplicationServerBuilder(containerBuilder, settingName);
            var   hostBuilder      = new HostBuilder();
            IHost host             = null;

            serverBuilder.AddRegister(cb =>
            {
                var type        = typeof(ServerGeneralModuleBase);
                var hostModules = AppDomain.CurrentDomain.GetAssemblies()
                                  .SelectMany(x => x.GetTypes())
                                  .Where(x => x.IsClass && type.IsAssignableFrom(x) && !x.IsAbstract)
                                  .Select(x => Activator.CreateInstance(x, serverBuilder.JimuAppSettings) as ServerGeneralModuleBase)
                                  .OrderBy(x => x.Priority);
                foreach (var module in hostModules)
                {
                    module.DoHostBuild(hostBuilder);
                }

                _hostBuilderAction?.Invoke(hostBuilder, containerBuilder);
                _serverBuilderAction?.Invoke(serverBuilder);

                hostBuilder.ConfigureServices(sc =>
                {
                    serverBuilder.AddBeforeBuilder(cb =>
                    {
                        cb.Populate(sc);
                    });
                });

                host = hostBuilder.Build();
            });



            var app = serverBuilder.Build();

            app.Run();
            host?.Run();
        }
Beispiel #47
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.AddMemoryCache();
            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddSession(options =>
            {
                options.IdleTimeout = TimeSpan.FromMinutes(60);
            });
            services.AddOptions();
            services.Configure <BlogAppSettingConfig>(Configuration.GetSection("BlogAppSetting"));
            //services.AddDbContext<DataContext>(options => options.UseSqlite(Configuration.GetConnectionString("DefaultConnectionSqlite")));
            //services.AddDbContext<DataContext>(options=> options.UseMySql(@"Server=127.0.0.1;database=Blogmy;uid=root;pwd=root"));
            services.AddMvc();
            var containerBuilder = new Autofac.ContainerBuilder();

            containerBuilder.RegisterModule <AutofacModule>();
            containerBuilder.Populate(services);
            var container = containerBuilder.Build();

            return(new AutofacServiceProvider(container));
        }
Beispiel #48
0
        static void Main(string[] args)
        {
            // Create and build your container
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterType <MusicSongService>().As <IMusicSongService>();
            builder.RegisterType <MusicActor>().AsSelf();
            var container = builder.Build();

            // Create the ActorSystem and Dependency Resolver
            var system        = ActorSystem.Create("MySystem");
            var propsResolver = new AutoFacDependencyResolver(container, system);


            IActorRef musicActor = system.ActorOf(system.DI().Props <MusicActor>(), "MusicActor");

            musicActor.Tell("Bohemian Rapsody");

            Console.Read();
            system.Terminate();
        }
Beispiel #49
0
        private static void SetupPatterns(Autofac.ContainerBuilder builder)
        {
            var serverModels =
                (from asm in NGS.Utility.AssemblyScanner.GetAssemblies()
                 let type = asm.GetType("SystemBoot.Configuration")
                            where type != null && type.GetMethod("Initialize") != null
                            select asm)
                .ToList();

            builder.RegisterGeneratedFactory <NGS.DomainPatterns.DomainModel.Factory>();
            builder.RegisterType <NGS.DomainPatterns.DomainModel>();
            builder.Register(c => c.Resolve <NGS.DomainPatterns.DomainModel.Factory>()(serverModels)).As <IDomainModel>().SingleInstance();
            builder.RegisterType <DomainTypeResolver>().As <ITypeResolver>().SingleInstance();
            builder.RegisterType <ServiceLocator>().As <IServiceLocator, IServiceProvider>().InstancePerLifetimeScope();
            builder.RegisterGeneric(typeof(WeakCache <>)).As(typeof(IDataCache <>)).InstancePerLifetimeScope();
            builder.RegisterType <DomainEventSource>().As <IDomainEventSource>().InstancePerLifetimeScope();
            builder.RegisterType <DomainEventStore>().As <IDomainEventStore>().InstancePerLifetimeScope();
            builder.RegisterGeneric(typeof(SingleDomainEventSource <>)).As(typeof(IDomainEventSource <>)).InstancePerLifetimeScope();
            builder.RegisterGeneric(typeof(RegisterChangeNotifications <>)).As(typeof(IObservable <>)).SingleInstance();
            builder.RegisterType <DataContext>().As <IDataContext>().InstancePerLifetimeScope();
        }
Beispiel #50
0
        public static void Config()
        {
            //todo: configure dependecies here
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterType <Log4NetLogger>()
            .As <ILogger>()
            .SingleInstance();
            builder.RegisterType <EventAggregator>()
            .As <IEventAggregator>()
            .SingleInstance();
            builder.RegisterType <DeathByCaptchaService>()
            .As <ICaptchaService>()
            .SingleInstance()
            .WithParameter("debug", true);

            var container = builder.Build();
            var csl       = new Autofac.Extras.CommonServiceLocator.AutofacServiceLocator(container);

            ServiceLocator.SetLocatorProvider(() => csl);
        }
Beispiel #51
0
        protected override void ConfigureContainer(Autofac.ContainerBuilder builder)
        {
            builder.RegisterType <ProductManager>();
            builder.RegisterType <CustomerManager>();
            builder.RegisterType <InvoiceManager>();
            builder.RegisterType <DiscountManager>();

            builder.RegisterType <ServiceClientFactory>().As <IServiceClientFactory>();

            builder.RegisterType <ProductServiceProxy>().As <IProductService>();
            builder.RegisterType <CustomerServiceProxy>().As <ICustomerService>();
            builder.RegisterType <InvoiceServiceProxy>().As <IInvoiceService>();
            builder.RegisterType <DiscountServiceProxy>().As <IDiscountService>();

            builder.RegisterType <MenuItemViewModel <SummaryViewModel> >();
            builder.RegisterType <MenuItemViewModel <ProductsViewModel> >();
            builder.RegisterType <MenuItemViewModel <CustomersViewModel> >();
            builder.RegisterType <MenuItemViewModel <DiscountsViewModel> >();

            base.ConfigureContainer(builder);
        }
        protected override void Load(AutofacRef.ContainerBuilder builder)
        {
            var executingAssembly = Reflaction.Assembly.Load(nameof(BusinessLayer));

            //Register all custom stores
            builder.RegisterAssemblyTypes(executingAssembly)
            .Where(x => x.Name.EndsWith("Store")).AsImplementedInterfaces().InstancePerLifetimeScope();

            //Register custom UserManagers
            builder.RegisterGeneric(typeof(CustomUserManager <>)).AsSelf().InstancePerLifetimeScope();

            //Register custom RoleManagers
            builder.RegisterGeneric(typeof(CustomRoleManager <>)).AsSelf().InstancePerLifetimeScope();

            //builder.RegisterAssemblyTypes(executingAssembly)
            //   .Where(x => x.BaseType != null && x.BaseType.IsGenericType
            //   && x.BaseType.GetGenericTypeDefinition() == typeof(UserManager<>).GetGenericTypeDefinition()).AsSelf().InstancePerLifetimeScope();

            //To exclude types from scanning, use the Except() predicate:
            //builder.RegisterAssemblyTypes(asm).Except<MyUnwantedType>();
        }
        public async Task RouteAnKnownIntentToTheProperHandler()
        {
            string intentName = string.Empty.GetRandom();
            string routeUri   = $"http://{string.Empty.GetRandom()}";

            var cmdProcessor = new Mock <ICommandProcessor>(MockBehavior.Loose);

            var containerBuilder = new Autofac.ContainerBuilder();

            containerBuilder.RegisterInstance <ICommandProcessor>(cmdProcessor.Object);
            var serviceProvider = new AutofacServiceProvider(containerBuilder.Build());

            var routes  = new RouteCollectionBuilder(string.Empty.GetRandom()).Add(intentName, routeUri).Build();
            var intent  = new IntentBuilder().Random().AddName(intentName);
            var request = new UserRequestBuilder().Random().AddIntent(intent).Build();

            var target = new SoftRouter.Engine(serviceProvider, routes);
            var actual = await target.HandleRequestAsync(request);

            cmdProcessor.Verify(p => p.ProcessAsync(routeUri, It.IsAny <UserRequest>()), Times.Once);
        }
Beispiel #54
0
        void Application_Start(object sender, EventArgs e)
        {
            // Code that runs on application startup
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);


            //Autofac Configuration
            var builder = new Autofac.ContainerBuilder();

            builder.RegisterControllers(typeof(Global).Assembly).PropertiesAutowired();

            builder.RegisterModule(new RepositoryModule());
            builder.RegisterModule(new ServiceModule());
            builder.RegisterModule(new EFModule());

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }
        protected override void Load(Autofac.ContainerBuilder builder)
        {
            var assembly = typeof(RepositoryModule)
                           .GetTypeInfo()
                           .Assembly;

            builder.RegisterAssemblyTypes(assembly)
            .Where(x => x.IsAssignableTo <IFakeDatabase>())
            .AsImplementedInterfaces()
            .SingleInstance();

            builder.RegisterAssemblyTypes(assembly)
            .Where(x => x.IsAssignableTo <IRepository>())
            .AsImplementedInterfaces()
            .InstancePerLifetimeScope();

            builder.RegisterAssemblyTypes(assembly)
            .Where(x => x.IsAssignableTo <InMemoryRepository>())
            .AsImplementedInterfaces()
            .InstancePerLifetimeScope();
        }
Beispiel #56
0
        protected override void Configure()
        {
            log4net.Config.XmlConfigurator.Configure();
            log.Info("Started application");
            AppDomain currentDomain = AppDomain.CurrentDomain;

            currentDomain.UnhandledException += new UnhandledExceptionEventHandler(FatalExceptionHandler);

            var builder = new Autofac.ContainerBuilder();

            builder.RegisterType <ApiClient>().As <IApiClient>();
            builder.RegisterType <SessionService>().As <ISessionService>().SingleInstance();
            builder.RegisterType <LoginViewModel>().SingleInstance();
            builder.RegisterType <ConductorViewModel>().SingleInstance();
            builder.RegisterType <ServerListViewModel>().SingleInstance();
            builder.RegisterType <EventAggregator>().As <IEventAggregator>().SingleInstance();
            builder.RegisterType <WindowManager>().As <IWindowManager>().SingleInstance();

            Container = builder.Build();
            Container.InjectProperties(Container);
        }
Beispiel #57
0
        protected override void Load(Autofac.ContainerBuilder builder)
        {
            base.Load(builder);

            builder
            .RegisterType <BL.BL>()
            .As <BL.IBL>()
            .InstancePerLifetimeScope();

            builder
            .RegisterType <BL.BLProdukt>()
            .As <BL.IBLProdukt>()
            .InstancePerLifetimeScope();

            builder
            .RegisterType <BL.BLBestellung>()
            .As <BL.IBLBestellung>()
            .InstancePerLifetimeScope();

            builder
            .RegisterType <BL.BLUser>()
            .As <BL.IBLUser>()
            .InstancePerLifetimeScope();

            builder
            .RegisterType <WarenkorbService>()
            .As <IWarenkorbService>()
            .InstancePerLifetimeScope();

            builder
            .RegisterType <BL.BLAuthentication>()
            .As <BL.IBLAuthentication>()
            .InstancePerLifetimeScope();


            builder
            .RegisterType <DAL.WebshopDataContext>()
            .As <IDAL>()
            .InstancePerLifetimeScope();
        }
        // For more information on bundling, visit http://go.microsoft.com/fwlink/?LinkId=301862
        public static void RegisterDependancies(Autofac.ContainerBuilder builder)
        {
            builder = builder ?? new ContainerBuilder();


            // Register the Web API controllers.
            builder.RegisterApiControllers(typeof(AutofacConfig).Assembly);

            var geocahceDirectory = ConfigurationManager.AppSettings["GeoCache"] ?? @".\App_Data\geocache.json";

            if (!Path.IsPathRooted(geocahceDirectory))
            {
                geocahceDirectory = Path.Combine(HttpRuntime.AppDomainAppPath, geocahceDirectory);
                geocahceDirectory = Path.GetFullPath(geocahceDirectory);
            }
            builder.RegisterInstance(new Services.Geocoder(geocahceDirectory));


            var GedcomFile = ConfigurationManager.AppSettings["GedcomFile"] ?? @".\App_Data\Data.ged";

            if (!Path.IsPathRooted(GedcomFile))
            {
                GedcomFile = Path.Combine(HttpRuntime.AppDomainAppPath, GedcomFile);
                GedcomFile = Path.GetFullPath(GedcomFile);
            }

            builder.RegisterInstance(new Gedcom.Net.GedcomDocument(Gedcom.Net.FileDom.FileDocument.Load(GedcomFile)));

            builder.RegisterType <Services.DataStore>();


            // Build the container.
            var container = builder.Build();

            // Create the depenedency resolver.
            var resolver = new AutofacWebApiDependencyResolver(container);

            // Configure Web API with the dependency resolver.
            GlobalConfiguration.Configuration.DependencyResolver = resolver;
        }
Beispiel #59
0
        public void SetupContainer(Autofac.ContainerBuilder builder)
        {
            builder.RegisterType <BL>()
            .As <MyIBL>()
            .As <IBL>()
            .InstancePerLifetimeScope();

            // Using physical path as parameter
            builder.RegisterType <FileDAL>()
            .As <IDAL>()
            .WithParameter(new TypedParameter(typeof(string),
                                              "../App_Data/Repository.xml"))
            .InstancePerLifetimeScope();

            builder.RegisterType <UserViewModel>()
            .As <IUserViewModel>()
            .InstancePerDependency();

            builder.RegisterType <BlogPostViewModel>()
            .As <IBlogPostViewModel>()
            .InstancePerDependency();
        }
Beispiel #60
0
        public static void ConfigureContainer()
        {
            var builder = new Autofac.ContainerBuilder();
            var config  = GlobalConfiguration.Configuration;

            builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // controller
            builder.RegisterWebApiFilterProvider(config);                    // filter

            builder.RegisterHttpRequestMessage(GlobalConfiguration.Configuration);
            builder.Register(e => // HttpContextBase
                             HttpContext.Current != null
                        ? new HttpContextWrapper(HttpContext.Current)
                        : e.Resolve <HttpRequestMessage>().Properties["MS_HttpContext"])
            .As <HttpContextBase>()
            .InstancePerRequest();


            builder.RegisterModule(new ServiceModule()); // Moduel
            var container = builder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
        }