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"); }); }
public ApplicationController(ILifetimeScope rootScope) { Guard.NotNull("rootScope", rootScope); this.rootScope = rootScope; mainWindowLock = new Object(); }
/// <summary> /// Gets a nested lifetime scope that services can be resolved from. /// </summary> /// <param name="container">The parent container.</param> /// <param name="configurationAction">Action on a <see cref="ContainerBuilder"/> /// that adds component registations visible only in nested lifetime scopes.</param> /// <returns>A new or existing nested lifetime scope.</returns> public static ILifetimeScope GetLifetimeScope(ILifetimeScope container, Action<ContainerBuilder> configurationAction) { // Little hack here to get dependencies when HttpContext is not available if (HttpContext.Current != null) return LifetimeScope ?? (LifetimeScope = InitializeLifetimeScope(configurationAction, container)); return InitializeLifetimeScope(configurationAction, container); }
/// <summary> /// Creates a new child scope or returns an existing child scope. /// </summary> /// <param name="parentScope">The current parent container.</param> /// <param name="scopeKindTag"> /// A tag to identify this kind of scope so it can be reused to share objects /// through fancy registration extensions (e.g. InstancePerSPSite, InstancePerSPWeb) /// </param> /// <param name="childScopeKey">A key to uniquely identify this scope within the container.</param> /// <returns>The child scope for the uniquely identified resource</returns> public ILifetimeScope GetChildLifetimeScope(ILifetimeScope parentScope, string scopeKindTag, string childScopeKey) { ILifetimeScope ensuredScope = null; // Don't bother locking if the instance is already created if (this.childScopes.ContainsKey(childScopeKey)) { // Return the already-initialized container right away ensuredScope = this.childScopes[childScopeKey]; } else { // Only one scope should be registered at a time in this helper instance, to be on the safe side lock (this.childScopesLockObject) { // Just in case, check again (because the assignment could have happened before we took hold of lock) if (this.childScopes.ContainsKey(childScopeKey)) { ensuredScope = this.childScopes[childScopeKey]; } else { // This scope will never be disposed, i.e. it will live as long as the parent // container, provided no one calls Dispose on it. // The newly created scope is meant to sandbox InstancePerLifetimeScope-registered objects // so that they get shared only within a boundary uniquely identified by the key. ensuredScope = parentScope.BeginLifetimeScope(scopeKindTag); this.childScopes[childScopeKey] = ensuredScope; } } } return ensuredScope; }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public WebApplicationComponent(IWebAppEndpoint endpoint, Auto<ILogger> logger, IComponentContext componentContext) { _app = endpoint.Contract; _address = endpoint.Address; _logger = logger.Instance; _container = (ILifetimeScope)componentContext; }
protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) { pipelines.EnableJsonErrorResponse(container.Resolve<IErrorMapper>()); pipelines.EnableCORS(); base.ApplicationStartup(container, pipelines); }
/// <summary> /// Initializes a new instance of the <see cref="AutofacDependencyResolver" /> class. /// </summary> /// <param name="lifetimeScope">The lifetime scope that services will be resolved from.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="lifetimeScope" /> is <see langword="null" />. /// </exception> public AutofacDependencyResolver(ILifetimeScope lifetimeScope) { if (lifetimeScope == null) throw new ArgumentNullException("lifetimeScope"); _lifetimeScope = lifetimeScope; _lifetimeScope.ComponentRegistry.AddRegistrationSource(this); }
// The bootstrapper enables you to reconfigure the composition of the framework, // by overriding the various methods and properties. // For more information https://github.com/NancyFx/Nancy/wiki/Bootstrapper //protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) //{ // // No registrations should be performed in here, however you may // // resolve things that are needed during application startup. //} //protected override void ConfigureApplicationContainer(ILifetimeScope existingContainer) //{ // // Perform registration that should have an application lifetime //} protected override void ConfigureRequestContainer(ILifetimeScope container, NancyContext context) { // Perform registrations that should have a request lifetime var builder = new ContainerBuilder(); builder.RegisterModule(new ServicesModule()); builder.Update(container.ComponentRegistry); }
public FilterPage () { this.Icon = "slideout.png"; this.Title = "Filter"; _scope = App.AutoFacContainer.BeginLifetimeScope(); var vm = _scope.Resolve<FilterViewModel> (); BindingContext = vm; var layout = new StackLayout (); layout.Children.Add (new Label() {Text = "Enter a filter"}); layout.Children.Add (new Label() {Text = "Subject"}); var subjectEntry = new Entry(); subjectEntry.SetBinding (Entry.TextProperty, "Subject"); layout.Children.Add (subjectEntry); var button = new Button () { Text = "Apply Filter" }; button.SetBinding (Button.CommandProperty, "FilterMeasures"); layout.Children.Add (button); Content = layout; }
public AutofacMediatorBuilder(ILifetimeScope container) { _key = HandlerKey; _asyncKey = AsyncHandlerKey; _container = container; _builder = new ContainerBuilder(); }
protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) { pipelines.OnError.AddItemToEndOfPipeline((context, exception) => { var message = string.Format("Exception: {0}", exception); new ElmahErrorHandler.LogEvent(message).Raise(); return null; }); pipelines.BeforeRequest.AddItemToEndOfPipeline(ctx => { var lang = ctx.Request.Headers.AcceptLanguage.FirstOrDefault(); if (lang != null) { // Accepted language can be something like "fi-FI", but it can also can be like fi-FI,fi;q=0.9,en;q=0.8 if (lang.Contains(",")) lang = lang.Substring(0, lang.IndexOf(",")); System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo(lang); System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo(lang); } return null; }); DoMigrations(); }
public DatabaseLock( ILifetimeScope lifetimeScope, IClock clock) { _lifetimeScope = lifetimeScope; _clock = clock; }
protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) { base.ApplicationStartup(container, pipelines); // register interfaces/implementations container.Update(builder => builder //.RegisterType<CouchDbTShirtRepository>() .RegisterType<MockedTShirtRepository>() .As<ITShirtRepository>()); // register MyCouchStore parameter for couchdb repo classes container.Update(builder => builder .RegisterType<MyCouchStore>() .As<IMyCouchStore>() .UsingConstructor(typeof (string), typeof (string)) .WithParameters(new [] { new NamedParameter("dbUri","http://*****:*****@localhost:5984/"), new NamedParameter("dbName","cshirts") }) ); // TODO: remove after implementing REST-Api & replacing razor with angular // display razor error messages StaticConfiguration.DisableErrorTraces = false; }
protected override void ConfigureApplicationContainer(ILifetimeScope container) { base.ConfigureApplicationContainer(container); var builder = new ContainerBuilder(); builder.RegisterType<AppSettings>().As<IAppSettings>().SingleInstance(); builder.RegisterType<DummyMailChimpWebhooks>().As<IMailChimpWebhooks>().SingleInstance(); builder.RegisterType<DummyMailgunWebhooks>().As<IMailgunWebhooks>().SingleInstance(); builder.RegisterType<AzureTableStorageTodoService>().As<ITodoService>().SingleInstance(); // Consumers and sagas builder.RegisterAssemblyTypes(typeof(Bootstrapper).Assembly) .Where(t => t.Implements<ISaga>() || t.Implements<IConsumer>()) .AsSelf(); // Saga repositories builder.RegisterGeneric(typeof(InMemorySagaRepository<>)) .As(typeof(ISagaRepository<>)) .SingleInstance(); // Service bus builder.Register(c => ServiceBusFactory.New(sbc => { sbc.ReceiveFrom("loopback://localhost/queue"); sbc.Subscribe(x => x.LoadFrom(container)); })).As<IServiceBus>().SingleInstance(); builder.Update(container.ComponentRegistry); }
/// <summary> /// 初始化一个 <see cref="AutofacLifetimeScopeProvider"/> 类的实例. /// </summary> /// <param name="container"> /// 容器. /// </param> public AutofacLifetimeScopeProvider(ILifetimeScope container) { Guard.ArgumentNotNull(() => container); this.container = container; AutofacRequestLifetimeHttpModule.SetLifetimeScopeProvider(this); }
protected MessagePipelineBase(IMessageHandlerProvider messageHandlerProvider, ILifetimeScope lifetimeScope, IMessage message, Logger logger) : base(logger) { _messageHandlerProvider = messageHandlerProvider; LifetimeScope = lifetimeScope; Message = message; }
protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) { pipelines.OnError.AddItemToEndOfPipeline(LogException); pipelines.BeforeRequest.AddItemToEndOfPipeline(DetectLanguage); DoMigrations(); }
/// <summary> /// Initializes a new instance of the <see cref="AutofacWebApiDependencyResolver"/> class. /// </summary> /// <param name="container">The container that nested lifetime scopes will be create from.</param> public AutofacWebApiDependencyResolver(ILifetimeScope container) { if (container == null) throw new ArgumentNullException("container"); _container = container; _rootDependencyScope = new AutofacWebApiDependencyScope(container); }
protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) { StaticConfiguration.DisableErrorTraces = false; // Enable memory sessions, and secure them against session hijacking pipelines.EnableInProcSessions(); pipelines.BeforeRequest.AddItemToStartOfPipeline(ctx => { var antiSessionHijackLogic = container.Resolve<IAntiSessionHijackLogic>(); return antiSessionHijackLogic.InterceptHijackedSession(ctx.Request); }); pipelines.AfterRequest.AddItemToEndOfPipeline(ctx => { var antiSessionHijackLogic = container.Resolve<IAntiSessionHijackLogic>(); antiSessionHijackLogic.ProtectResponseFromSessionHijacking(ctx); }); // Load the user from the AspNet session. If one is found, create a Nancy identity and assign it. pipelines.BeforeRequest.AddItemToEndOfPipeline(ctx => { var identityAssigner = container.Resolve<INancyIdentityFromContextAssigner>(); identityAssigner.AssignNancyIdentityFromContext(ctx); return null; }); pipelines.OnError = pipelines.OnError + ErrorPipelines.HandleModelBindingException() + ErrorPipelines.HandleRequestValidationException() + ErrorPipelines.HandleSecurityException(); base.ApplicationStartup(container, pipelines); }
public void KillEmAll() { Scope.KillEmAll(); if (AfScope.IsInstance()) AfScope.Dispose(); AfScope = Container.BeginLifetimeScope(); }
protected override void Resolve(ILifetimeScope container) { _compositionStrategy = container.Resolve<CompositionStrategy>(); _compositionStrategy.Logger = container.Resolve<ILogger>(); var alphaExtension = new ExtensionDescriptor { Id = "Alpha", Name = "Alpha", ExtensionType = "Module" }; var alphaFeatureDescriptor = new FeatureDescriptor { Id = "Alpha", Name = "Alpha", Extension = alphaExtension }; var betaFeatureDescriptor = new FeatureDescriptor { Id = "Beta", Name = "Beta", Extension = alphaExtension, Dependencies = new List<string> { "Alpha" } }; alphaExtension.Features = new List<FeatureDescriptor> { alphaFeatureDescriptor, betaFeatureDescriptor }; _availableExtensions = new[] { alphaExtension }; _installedFeatures = new List<Feature> { new Feature { Descriptor = alphaFeatureDescriptor, ExportedTypes = new List<Type> { typeof(AlphaDependency) } }, new Feature { Descriptor = betaFeatureDescriptor, ExportedTypes = new List<Type> { typeof(BetaDependency) } } }; _loggerMock.Setup(x => x.IsEnabled(It.IsAny<LogLevel>())).Returns(true); _extensionManager.Setup(x => x.AvailableExtensions()).Returns(() => _availableExtensions); _extensionManager.Setup(x => x.AvailableFeatures()).Returns(() => _extensionManager.Object.AvailableExtensions() .SelectMany(ext => ext.Features) .ToReadOnlyCollection()); _extensionManager.Setup(x => x.LoadFeatures(It.IsAny<IEnumerable<FeatureDescriptor>>())).Returns(() => _installedFeatures); }
public static HttpConfiguration Configure(IdentityServerOptions options, ILifetimeScope container) { var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.SuppressDefaultHostAuthentication(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); config.Services.Add(typeof(IExceptionLogger), new LogProviderExceptionLogger()); config.Services.Replace(typeof(IHttpControllerTypeResolver), new HttpControllerTypeResolver()); config.Formatters.Remove(config.Formatters.XmlFormatter); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.LocalOnly; if (options.LoggingOptions.EnableWebApiDiagnostics) { var liblog = new TraceSource("LibLog"); liblog.Switch.Level = SourceLevels.All; liblog.Listeners.Add(new LibLogTraceListener()); var diag = config.EnableSystemDiagnosticsTracing(); diag.IsVerbose = options.LoggingOptions.WebApiDiagnosticsIsVerbose; diag.TraceSource = liblog; } ConfigureRoutes(options, config); return config; }
/// <summary> /// Initializes a new instance of the <see cref="AutofacJobFactory" /> class. /// </summary> /// <param name="lifetimeScope">The lifetime scope.</param> /// <param name="scopeName">Name of the scope.</param> public AutofacJobFactory(ILifetimeScope lifetimeScope, string scopeName) { if (lifetimeScope == null) throw new ArgumentNullException("lifetimeScope"); if (scopeName == null) throw new ArgumentNullException("scopeName"); _lifetimeScope = lifetimeScope; _scopeName = scopeName; }
protected override void RequestStartup(ILifetimeScope container, IPipelines pipelines, NancyContext context) { // No registrations should be performed in here, however you may // resolve things that are needed during request startup. FormsAuthentication.Enable(pipelines, new FormsAuthenticationConfiguration() { RedirectUrl = "~/account/login", UserMapper = container.Resolve<IUserMapper>(), }); pipelines.BeforeRequest.AddItemToEndOfPipeline(c => { if (c.CurrentUser.IsAuthenticated()) { container.Resolve<ITenantContext>().SetTenantId(c.CurrentUser.AsAuthenticatedUser().Id, c.CurrentUser.HasClaim("Admin")); c.ViewBag.UserName = c.CurrentUser.AsAuthenticatedUser().FullName; c.ViewBag.IsAdmin = c.CurrentUser.HasClaim("Admin"); } else container.Resolve<ITenantContext>().SetTenantId(null, false); return null; }); }
/// <summary> /// Initializes a new instance of the <see cref="AutofacDependencyResolver" /> class. /// </summary> /// <param name="lifetimeScope">The lifetime scope that services will be resolved from.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="lifetimeScope" /> is <see langword="null" />. /// </exception> public AutofacDependencyResolver(ILifetimeScope lifetimeScope) { if (lifetimeScope == null) throw new ArgumentNullException("lifetimeScope"); _lifetimeScope = lifetimeScope; }
public PluginHttpApi( ILogger logger, ILifetimeScope lifetimeScope) { _logger = logger; _lifetimeScope = lifetimeScope; }
protected override void ConfigureApplicationContainer(ILifetimeScope existingContainer) { var setup = new Setup((IContainer)existingContainer); // defaults setup.WithGuidGenerator(); setup.WithThreadStaticTenantContext(); setup.WithMongo("MongoConnectionReadModel"); setup.RegisterReadModelRepositories(); // web specific var builder = new ContainerBuilder(); builder.RegisterType<NancyUserMapper>().As<IUserMapper>(); builder.RegisterType<StaticContentResolverForInMemory>().As<IStaticContentResolver>(); builder.RegisterType<ExcelService>().As<IExcelService>(); builder.Update(setup.Container.ComponentRegistry); // bus setup.WithInMemoryBus(); setup.RegisterReadModelHandlers(); // eventstore setup.WithMongoEventStore("MongoConnectionEventStore", new AuthorizationPipelineHook(setup.Container), new MessageDispatcher(setup.Container), false); // start the bus setup.Container.Resolve<IServiceBus>().Start(ConfigurationManager.AppSettings["serviceBusEndpoint"]); }
public Rebuild(IStoreEvents eventStore, IDomainUpdateServiceBusHandlerHook hook, ILifetimeScope container, IMongoContext mongo) { _eventStore = eventStore; _hook = hook; _container = container; _mongo = mongo; }
public static void Initialize() { /*bool databaseInstalled = DataSettingsHelper.DatabaseIsInstalled(); if (databaseInstalled) { //startup tasks RunStartupTasks(); }*/ //startup tasks //RunStartupTasks(); var builder = new ContainerBuilder(); builder.RegisterType<WebAppTypeFinder>().As<ITypeFinder>().SingleInstance(); _container = builder.Build(); if (HttpContext.Current == null) { _applicationContainer = new StubLifetimeScopeProvider(_container).GetLifetimeScope(null); } else { _applicationContainer = _container; } var typeFinder = _container.Resolve<ITypeFinder>(); UpdateContainer(x => { var drTypes = typeFinder.FindClassesOfType<IDependencyRegistrar>(); var drInstances = new List<IDependencyRegistrar>(); foreach (var drType in drTypes) drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType)); //sort drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList(); foreach (var dependencyRegistrar in drInstances) dependencyRegistrar.Register(x, typeFinder); }); }
protected override void ConfigureApplicationContainer(ILifetimeScope existingContainer) { var builder = new ContainerBuilder(); _tasks.ForEach(task => task.Task.Invoke(builder)); builder.Update(existingContainer.ComponentRegistry); base.ConfigureApplicationContainer(existingContainer); }
public void DisposeJobLifetimeScope() { _childLifetimeScope.Dispose(); _childLifetimeScope = null; }
public FactoryAbstract(ILifetimeScope scope) { _scope = scope; }
public void Run(ILifetimeScope scope) { }
public void UseContainer(ILifetimeScope lifetimeScope) { SetContainer(lifetimeScope); }
public SettingsWindow(SettingsWidgetModel viewModel, ILifetimeScope container) : base(container) { InitializeComponent(); DataContext = viewModel; }
public AsyncRunner(ILifetimeScope lifetimeScope) { LifetimeScope = lifetimeScope; }
public QueryExecutor(ILifetimeScope lifetimeScope) { _lifetimeScope = lifetimeScope; }
public static ILifetimeScope SetScopeValue <T>(this ILifetimeScope scope, T instance) { return(SetScopeFactory(scope, () => instance)); }
public AutofacTypeResolver(ILifetimeScope scope) { _scope = scope; }
public void CreateJobLifetimeScope() { _childLifetimeScope = _mainContainer.BeginLifetimeScope(); }
public LineHandlerFactory(ILifetimeScope lifetimeScope) { this.lifetimeScope = lifetimeScope; }
public static ILifetimeScope SetScopeFactory <T>(this ILifetimeScope scope, Func <T> factory) { ScopeMapFor(scope)[typeof(T)] = factory; return(scope); }
public bool Start(HostControl hostControl) { _log.InfoFormat($"Starting {GetType().GetDisplayName()}"); var started = new List <ServiceControl>(); try { var scanner = new AssemblyScanner(); List <AssemblyRegistration> registrations = scanner.GetAssemblyRegistrations().ToList(); _log.Info($"Found {registrations.Count} assembly registrations"); foreach (var registration in registrations) { _log.Info($"Assembly: {registration.Assembly.GetName().Name}"); foreach (var type in registration.Types) { _log.Info($" Type: {type.GetTypeName()}"); } } var busFactoryType = scanner.GetHostBusFactoryType(); if (busFactoryType == null) { throw new ConfigurationException("A valid transport assembly was not found."); } _bootstrapperScope = CreateBootstrapperScope(registrations, busFactoryType); var bootstrappers = _bootstrapperScope.Resolve <IEnumerable <IServiceBootstrapper> >(); List <ServiceControl> services = bootstrappers.Select(x => x.CreateService()).ToList(); Parallel.ForEach(services, serviceControl => { hostControl.RequestAdditionalTime(TimeSpan.FromMinutes(1)); StartService(hostControl, serviceControl); lock (started) { started.Add(serviceControl); } }); _services.AddRange(started); return(true); } catch (Exception ex) { _log.Error("Service failed to start", ex); Parallel.ForEach(started, service => { hostControl.RequestAdditionalTime(TimeSpan.FromMinutes(1)); StopService(hostControl, service); }); throw; } }
public ShellViewModel(IEventAggregator eventAggregator, ChocolateyInstaller chocolateyInstaller, LicenseAgreement licenseAgreement, ILifetimeScope lifetimeScope, PowerShellRunner powerShellRunner) { this.chocolateyInstaller = chocolateyInstaller; this.licenseAgreement = licenseAgreement; this.lifetimeScope = lifetimeScope; this.powerShellRunner = powerShellRunner; this.eventAggregator = eventAggregator; RunStartupSequence(); }
public AutofacContainer(ILifetimeScope container) { _container = container ?? new ContainerBuilder().Build(); }
public FDServiceHelper(ILifetimeScope lifetimeScope, ILogger <FDServiceHelper> logger) { _ApplicationContainer = lifetimeScope; _Logger = logger; }
public LifetimeScopeEndingEventArgs(ILifetimeScope lifetimeScope) { this._lifetimeScope = lifetimeScope; }
public MassTransitHostService(ILifetimeScope hostScope) { _hostScope = hostScope; _services = new List <ServiceControl>(); }
AutofacResolver(ILifetimeScope container) { _container = container ?? throw new ArgumentNullException("container"); }
/// <summary> /// Initializes a new instance of the <see cref="AutoFacServiceLocatorProvider"/> class. /// </summary> /// <param name="container"> /// The container. /// </param> public AutoFacServiceLocatorProvider([NotNull] ILifetimeScope container) { CodeContracts.VerifyNotNull(container, "container"); this.Container = container; }
/// <summary> /// Initializes a new instance of the <see cref="AutofacJobFactory" /> class. /// </summary> /// <param name="lifetimeScope">The lifetime scope.</param> /// <param name="scopeTag">The tag to use for new scopes.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="lifetimeScope" /> or <paramref name="scopeTag" /> is /// <see langword="null" />. /// </exception> public AutofacJobFactory([NotNull] ILifetimeScope lifetimeScope, [NotNull] object scopeTag) { _lifetimeScope = lifetimeScope ?? throw new ArgumentNullException(nameof(lifetimeScope)); _scopeTag = scopeTag ?? throw new ArgumentNullException(nameof(scopeTag)); }
public AutofacJobFactory(ILifetimeScope scope) => this.scope = scope;
/// <summary> /// Overridable resolve strategy for IJob instance /// </summary> /// <param name="nestedScope"> /// Nested ILifetimeScope for resolving Job instance with other dependencies /// </param> /// <param name="jobDetail"> /// The <see cref="T:Quartz.IJobDetail" /> /// and other info about job /// </param> /// <returns></returns> protected virtual IJob ResolveJobInstance(ILifetimeScope nestedScope, IJobDetail jobDetail) { var jobType = jobDetail.JobType; return((IJob)nestedScope.Resolve(jobType)); }
public override void Finish() { _container = _builder.Build(); }
public virtual void BeforeEachTest() { Scope = Container.BeginLifetimeScope(); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object" /> class. /// </summary> public JobTrackingInfo(ILifetimeScope scope) { Scope = scope; }
public DummyClass(IObjectRegistration p1, ContainerOption p2, ILifetimeScope p3) { }
public MessageProcessor(ILifetimeScope lifetimeScope) { _lifetimeScope = lifetimeScope; }
public clsTaller(ILifetimeScope lifetimeScope) : base(lifetimeScope) { }
public MetricsQueryDataContextFactory(ILifetimeScope lifetimeScope) { this.lifetimeScope = lifetimeScope ?? throw new ArgumentNullException(nameof(lifetimeScope)); }