public void CollectionsAreTaggable()
{
var builder = new ContainerBuilder();
builder.RegisterCollection<object>("o")
.InstancePerMatchingLifetimeScope("tag")
.As(typeof(IList<object>));
var outer = builder.Build();
var inner = outer.BeginLifetimeScope("tag");
var coll = inner.Resolve<IList<object>>();
Assert.NotNull(coll);
var threw = false;
try
{
outer.Resolve<IList<object>>();
}
catch (Exception)
{
threw = true;
}
Assert.True(threw);
}
public static void Start()
{
var builder = new ContainerBuilder();
builder.RegisterGlassServices();
builder.RegisterCacheServices();
builder.RegisterProcessors(Assembly.Load("YOURPROJECT.Library"));
builder.RegisterGlassMvcServices("YOURPROJECT.Web");
builder.RegisterGlassFactory("YOURPROJECT.Library");
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterControllers(Assembly.GetExecutingAssembly());
// Module registrations
builder.RegisterModule(new MiniProfilerModule("YOURPROJECT.Library", "YOURPROJECT.Web"));
builder.RegisterModule(new LogInjectionModule<ILog>(LogManager.GetLogger);
// Custom Registrations
// This is necessary to 'seal' the container, and make it resolvable from the AutofacStartup.ServiceLocator singleton
IContainer container = builder.Build();
container.RegisterContainer();
// Create the dependency resolver.
var resolver = new AutofacWebApiDependencyResolver(container);
// Configure Web API with the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = resolver;
// Configure the MVC dependency resolver
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
public Wmp11MusicBuilder ()
: base (Wmp11Ids.Music, "Music")
{
genre_builder = new ContainerBuilder<GenreOptions> (
Wmp11Ids.MusicGenre, "Genre", GetId, (id, options) => new MusicGenre (GetId (), id, options));
artist_builder = new ContainerBuilder<BuildableMusicArtistOptions> (
Wmp11Ids.MusicArtist, "Artist", GetId, ArtistProvider);
album_builder = new ContainerBuilder<MusicAlbumOptions> (
Wmp11Ids.MusicAlbum, "Album", GetId, (id, options) => new MusicAlbum (GetId (), id, options));
playlists_builder = new ContainerBuilder<PlaylistContainerOptions> (
Wmp11Ids.MusicPlaylists, "Playlists", GetId, (id, options) => new PlaylistContainer (GetId (), id, options));
folders_builder = new ContainerBuilder<StorageFolderOptions> (
Wmp11Ids.MusicFolders, "Folders", GetId, (id, options) => new StorageFolder (GetId (), id, options));
contributing_artists_builder = new ContainerBuilder<MusicArtistOptions> (
Wmp11Ids.MusicContributingArtists, "Contributing Artists", GetId, ArtistProvider);
album_artist_builder = new ContainerBuilder<BuildableMusicArtistOptions> (
Wmp11Ids.MusicAlbumArtist, "Album Artist", GetId, ArtistProvider);
composer_builder = new ContainerBuilder<BuildableMusicArtistOptions> (
Wmp11Ids.MusicComposer, "Composer", GetId, ArtistProvider);
one_star_builder = new ContainerBuilder<ContainerOptions> (
Wmp11Ids.MusicRating1Star, "1+ stars", GetId, RatingProvider);
two_star_builder = new ContainerBuilder<ContainerOptions> (
Wmp11Ids.MusicRating2Star, "2+ stars", GetId, RatingProvider);
three_star_builder = new ContainerBuilder<ContainerOptions> (
Wmp11Ids.MusicRating3Star, "3+ stars", GetId, RatingProvider);
four_star_builder = new ContainerBuilder<ContainerOptions> (
Wmp11Ids.MusicRating4Star, "4+ stars", GetId, RatingProvider);
five_star_builder = new ContainerBuilder<ContainerOptions> (
Wmp11Ids.MusicRating5Star, "5+ stars", GetId, RatingProvider);
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c => new WorkingDirectory(c.Resolve<DirectoryInfo>())).As<IWorkingDirectory>().ContainerScoped();
builder.Register(c => new Repository(c.Resolve<IWorkingDirectory>())).As<IRepository>().ContainerScoped();
builder.Register(c => new Index(c.Resolve<IRepository>())).As<IIndex>();
builder.Register(c => new GitLib()).As<IGit>();
}
public void Instance_is_reused_on_same_thread_when_controlled_by_threadsingleton_lifecycle()
{
var builder = new ContainerBuilder();
builder.DefaultControlledBy<ThreadSingletonLifecycle>();
builder.Register<IFoo, Foo>();
builder.Register<IBar, Bar>();
var container = builder.Build();
var threadData = new ThreadData(container);
var thread = new Thread(threadData.ResolveFoosWithContainer);
var threadDataTwo = new ThreadData(container);
var threadTwo = new Thread(threadDataTwo.ResolveFoosWithContainer);
thread.Start();
threadTwo.Start();
thread.Join();
threadTwo.Join();
Assert.IsTrue(ReferenceEquals(threadData.FooOne, threadData.FooTwo));
Assert.IsFalse(ReferenceEquals(threadData.FooOne, threadDataTwo.FooOne));
}
public SilkveilContainerTests()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.Register(typeof(IContainerBinder), typeof(ContainerBinder));
containerBuilder.Register(typeof(IRequestListener), typeof(DownloadRequestListener));
containerBuilder.Register(typeof(IRequestListener), typeof(RedirectRequestListener));
containerBuilder.Register(typeof(IMappingResolver<IDownloadMapping>), typeof(DownloadMappingResolver));
containerBuilder.Register(typeof(IMappingResolver<IRedirectMapping>), typeof(RedirectMappingResolver));
containerBuilder.Register<IMappingProvider<IDownloadMapping>>(
c =>
{
var downloadMappingProvider = new DownloadMappingProvider(c);
downloadMappingProvider.Initialize();
return downloadMappingProvider;
});
containerBuilder.Register<IMappingProvider<IRedirectMapping>>(
c =>
{
var redirectMappingProvider = new RedirectMappingProvider(c);
redirectMappingProvider.Initialize();
return redirectMappingProvider;
});
containerBuilder.Register(typeof(IContentSource), typeof(HttpContentSource));
containerBuilder.Register(typeof(IContentSource), typeof(FileContentSource));
containerBuilder.Register(typeof(IStreamSplitter), typeof(StreamSplitter));
containerBuilder.Register(typeof(IHttpStreamFactory), typeof(HttpStreamFactory));
containerBuilder.Register(typeof(ISilkveilContainer), typeof(SilkveilContainer));
containerBuilder.Register(typeof(IDownloadMapping), typeof(DownloadMapping));
containerBuilder.Register(typeof(IRedirectMapping), typeof(RedirectMapping));
this._container = containerBuilder.Build();
}
public void Can_register_and_use_generics_with_configuration_api()
{
var configuration = new LightCoreConfiguration();
var registrations = new List<Registration>
{
new Registration
{
ContractType = typeof(IFoo).AssemblyQualifiedName,
ImplementationType = typeof(Foo).AssemblyQualifiedName,
Arguments = new List<Argument>
{
new Argument
{
Type = "Guid",
Value = "354c11f1-94e5-41b8-9a13-122e2df2b0c7"
}
}
}
};
configuration.Registrations = registrations;
var builder = new ContainerBuilder();
RegistrationLoader.Instance.Register(builder, configuration);
var container = builder.Build();
Guid expected = new Guid("354c11f1-94e5-41b8-9a13-122e2df2b0c7");
Assert.AreEqual(expected, ((Foo)container.Resolve<IFoo>()).Arg4);
}
public void SetUp()
{
var builder = new ContainerBuilder();
builder.RegisterMetadataRegistrationSources();
builder.RegisterType<object>().WithMetadata("TheInt", SuppliedValue);
_container = builder.Build();
}
public void SetUp()
{
var builder = new ContainerBuilder();
builder.RegisterMetadataRegistrationSources();
builder.RegisterType<object>();
_container = builder.Build();
}
public void AnyCreationPolicyDefaultsToShared()
{
var builder = new ContainerBuilder();
var catalog = new TypeCatalog(typeof(HasAnyCreationPolicy));
builder.RegisterComposablePartCatalog(catalog);
AssertDisposalTrackerIsSingleton(builder);
}
public void WhenTIsRegisteredByName_CanResolveLazyTByName()
{
var builder = new ContainerBuilder();
builder.RegisterType<object>().Named<object>("foo");
var container = builder.Build();
Assert.True(container.IsRegisteredWithName<Lazy<object>>("foo"));
}
public void Register(ContainerBuilder builder, IEnumerable<Type> possibleTypes)
{
foreach (Type possibleType in this.DiscoverDependencies(possibleTypes))
{
this.InternalRegister(builder, possibleType);
}
}
public void DefaultLifetimeForMefComponentsIsSingleton()
{
var builder = new ContainerBuilder();
var catalog = new TypeCatalog(typeof(HasDefaultCreationPolicy));
builder.RegisterComposablePartCatalog(catalog);
AssertDisposalTrackerIsSingleton(builder);
}
public void CollectionInNestedLifetimeScope()
{
// Issue #711
// Note #711 was using named collections; this test is not.
// Named collections don't have different behavior than the standard
// auto-generated behavior from a resolve standpoint since you
// can't resolve a specifically named collection.
var cb = new ContainerBuilder();
cb.RegisterType<Foo1>().As<IFoo>();
cb.RegisterType<Foo2>().As<IFoo>();
using (var container = cb.Build())
{
var collection = container.Resolve<IEnumerable<IFoo>>();
Assert.Equal(2, collection.Count());
using (var scope = container.BeginLifetimeScope())
{
collection = container.Resolve<IEnumerable<IFoo>>();
Assert.Equal(2, collection.Count());
}
using (var scope = container.BeginLifetimeScope(b => { }))
{
collection = container.Resolve<IEnumerable<IFoo>>();
Assert.Equal(2, collection.Count());
}
}
}
public void ConcurrentResolveOperationsForNonSharedInstancesFromDifferentLifetimes_DoNotBlock()
{
var evt = new ManualResetEvent(false);
var builder = new ContainerBuilder();
builder.Register((c, p) =>
{
if (p.TypedAs<bool>())
evt.WaitOne();
return new object();
});
var container = builder.Build();
var unblocked = 0;
var blockedScope = container.BeginLifetimeScope();
var blockedThread = new Thread(() =>
{
blockedScope.Resolve<object>(TypedParameter.From(true));
Interlocked.Increment(ref unblocked);
});
blockedThread.Start();
Thread.Sleep(500);
container.Resolve<object>(TypedParameter.From(false));
container.BeginLifetimeScope().Resolve<object>(TypedParameter.From(false));
Thread.MemoryBarrier();
Assert.Equal(0, unblocked);
evt.Set();
blockedThread.Join();
}
public void should_register_dependency_using_A_convention()
{
var builder = new ContainerBuilder();
var dependencyTypes = Assembly.GetExecutingAssembly().GetExportedTypes(); //new[] { typeof(MockDependency) };
// convention which should match to IMockDependencyMarker and register it
var convention = Substitute.For<IRegistrationConvention>();
// match to IMockDependencyMarker
convention.IsMatch(Arg.Is<Type>(type => typeof(IMockDependencyMarker).IsAssignableFrom(type))).Returns(true);
// apply convention
convention.WhenForAnyArgs(c => c.Apply(null, null)).Do(
ci =>
{
var registration = ci.Arg<ITypeRegistration>();
registration.As<IMockDependency>();
});
// act
builder.RegisterUsingConventions(dependencyTypes, new[] { convention });
IContainer container = builder.Build();
// assert
var mockDependency = container.ResolveOptional<IMockDependency>();
mockDependency.Should().NotBeNull();
mockDependency.Should().BeOfType<MockDependency>();
}
public void OnCircularDependency_MessageDescribesCycle()
{
try
{
var builder = new ContainerBuilder();
builder.Register(c => c.Resolve<object>());
var target = builder.Build();
target.Resolve<object>();
}
catch (DependencyResolutionException de)
{
Assert.IsNull(de.InnerException);
Assert.IsTrue(de.Message.Contains("System.Object -> System.Object"));
Assert.IsFalse(de.Message.Contains("System.Object -> System.Object -> System.Object"));
return;
}
catch (Exception ex)
{
Assert.Fail("Expected a DependencyResolutionException, got {0}.", ex);
return;
}
Assert.Fail("Expected a DependencyResolutionException.");
}
public void WrapperResolvesAuthenticationFilterFromDependencyScope()
{
var builder = new ContainerBuilder();
builder.Register<ILogger>(c => new Logger()).InstancePerDependency();
var activationCount = 0;
builder.Register<IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve<ILogger>()))
.AsWebApiAuthenticationFilterFor<TestController>(c => c.Get())
.InstancePerRequest()
.OnActivated(e => activationCount++);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var configuration = new HttpConfiguration { DependencyResolver = resolver };
var requestMessage = new HttpRequestMessage();
requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
var contollerContext = new HttpControllerContext { Request = requestMessage };
var controllerDescriptor = new HttpControllerDescriptor { ControllerType = typeof(TestController) };
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new AuthenticationFilterWrapper(metadata);
wrapper.OnAuthenticate(context);
Assert.That(activationCount, Is.EqualTo(1));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterType<AdditionService>().As<IAdditionService>();
builder.RegisterType<MultiplicationService>().As<IMultiplicationService>();
builder.RegisterType<CalculationService>().As<ICalculationService>();
}
public void SetUp()
{
var cb = new ContainerBuilder();
cb.RegisterModule(new QuartzAutofacJobsModule(Assembly.GetExecutingAssembly()));
_container = cb.Build();
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">
/// The builder through which components can be registered.
/// </param>
/// <remarks>
/// </remarks>
protected override void Load(ContainerBuilder builder)
{
builder.Register(
c =>
CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
c.ResolveOptional<IStorageObserver>()).BuildStorageProviders()).OnRelease(
p => p.QueueStorage.AbandonAll());
builder.Register(
c =>
CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
c.ResolveOptional<IStorageObserver>()).BuildBlobStorage());
builder.Register(
c =>
CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
c.ResolveOptional<IStorageObserver>()).BuildQueueStorage()).OnRelease(p => p.AbandonAll());
builder.Register(
c =>
CloudStorage.ForInMemoryStorage().WithDataSerializer(c.Resolve<IDataSerializer>()).WithObserver(
c.ResolveOptional<IStorageObserver>()).BuildTableStorage());
builder.Register(c => new NeutralLogStorage { BlobStorage = new MemoryBlobStorageProvider() });
}
public void ProvidedLifetimeScopeExposed()
{
var container = new ContainerBuilder().Build();
var dependencyResolver = new AutofacDependencyResolver(container);
Assert.Equal(container, dependencyResolver.LifetimeScope);
}
public void EnsureWebTypeIsRegistered(Type serviceType)
{
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterModule(new AutofacWebTypesModule());
IContainer container = builder.Build();
Assert.That(container.IsRegistered(serviceType), Is.True);
}
public LightCoreDelegateUseCase()
{
var builder = new ContainerBuilder();
builder.Register<IWebApp>(
c => new WebApp(
c.Resolve<IAuthenticator>(),
c.Resolve<IStockQuote>()));
builder.Register<IAuthenticator>(
c => new Authenticator(
c.Resolve<ILogger>(),
c.Resolve<IErrorHandler>(),
c.Resolve<IDatabase>()));
builder.Register<IStockQuote>(
c => new StockQuote(
c.Resolve<ILogger>(),
c.Resolve<IErrorHandler>(),
c.Resolve<IDatabase>()));
builder.Register<ILogger>(
c => new Logger());
builder.Register<IErrorHandler>(
c => new ErrorHandler(
c.Resolve<ILogger>()));
builder.Register<IDatabase>(
c => new Database(
c.Resolve<ILogger>(),
c.Resolve<IErrorHandler>()));
this._container = builder.Build();
}
public void Can_register_and_use_closed_to_closed_generic_with_configuration_api()
{
var configuration = new LightCoreConfiguration();
var registrations = new List<Registration>
{
new Registration
{
// LightCore.TestTypes.IRepository`1, LightCore.TestTypes
ContractType = typeof (IRepository<Bar>).AssemblyQualifiedName,
ImplementationType = typeof (BarRepository).AssemblyQualifiedName
}
};
configuration.Registrations = registrations;
var builder = new ContainerBuilder();
RegistrationLoader.Instance.Register(builder, configuration);
var container = builder.Build();
var repository = container.Resolve<IRepository<Bar>>();
Assert.That(repository, Is.Not.Null);
Assert.That(repository, Is.InstanceOf<BarRepository>());
}
static void run()
{
var builder = new ContainerBuilder();
var registry = new AutofacDependencyRegistryBuilder(builder).build();
Resolve.initialize_with(registry);
builder.Register(x => registry).As<DependencyRegistry>().SingletonScoped();
//needs startups
builder.Register<StartServiceBus>().As<NeedStartup>();
// infrastructure
var manager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 2201), "client.esent");
manager.CreateQueues("client");
builder.Register(x => new RhinoPublisher("server", 2200, manager)).As<ServiceBus>().SingletonScoped();
builder.Register(x => new RhinoReceiver(manager.GetQueue("client"), x.Resolve<CommandProcessor>())).As<RhinoReceiver>().As<Receiver>().SingletonScoped();
// commanding
//builder.Register<AsynchronousCommandProcessor>().As<CommandProcessor>().SingletonScoped();
builder.Register<SynchronousCommandProcessor>().As<CommandProcessor>().SingletonScoped();
builder.Register<RequestHandler>().As<Handler>();
Resolve.the<IEnumerable<NeedStartup>>().each(x => x.run());
Resolve.the<CommandProcessor>().run();
"started".log();
}
public void ContainerScope_DefaultServiceRegistrationUsingPreservation()
{
var builder = new ContainerBuilder();
builder.RegisterInstance("s1").PreserveExistingDefaults();
var container = builder.Build();
Assert.Equal("s1", container.Resolve<string>());
}
public void Initialise()
{
var builder = new ContainerBuilder();
builder.RegisterType<Logger>().As<ILogger>();
builder.RegisterType<Repository>().As<IRepository>();
builder.Build();
}
public void ContainerBuilder_can_initialize_container()
{
var builder = new ContainerBuilder();
var container = builder.Build();
Assert.IsNotNull(container);
}
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));
}
private void Build(ContainerBuilder builder)
{
Container = builder.Build();
}
public static void RegisterAutoMocking(this ContainerBuilder builder, MockBehavior behavior)
{
builder.RegisterSource(new AutoMockSource(behavior));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterType <DataRepository>().As <IDataRepository>();
}
public void ConfigureContainer(ContainerBuilder builder)
{
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(ctx => ctx.Resolve <GenericDatastore>().RootRecord)
.SingleInstance()
.As <GenericDatastoreRecord>();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <Plugin2>().As <IPlugin>();
builder.RegisterType <Collaborator>().AsSelf();
}
public virtual void Initialize(ContainerBuilder builder)
{
Build(builder);
}
public override void RegisterTypes(IContainerRegistry containerRegistry)
{
ContainerBuilder containerBuilder = containerRegistry.GetBuilder();
base.RegisterTypes(containerRegistry);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
//services.AddMemoryCache();
RegisterAppInsights(services);
services.AddMvc(options =>
{
options.Filters.Add(typeof(HttpGlobalExceptionFilter));
}).AddControllersAsServices() //Injecting Controllers themselves thru DI
//全局配置Json序列化处理
.AddJsonOptions(options =>
{
//忽略循环引用
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
//不使用驼峰样式的key
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
//设置时间格式
options.SerializerSettings.DateFormatString = "yyyy-MM-dd";
});
services.AddHealthChecks(checks =>
{
var minutes = 1;
if (int.TryParse(Configuration["HealthCheck:Timeout"], out var minutesParsed))
{
minutes = minutesParsed;
}
checks.AddMySQLCheck("book2db", Configuration["ConnectionString"], TimeSpan.FromMinutes(minutes));
checks.AddUrlCheck("http://localhost:15672/", TimeSpan.FromMinutes(minutes));
});
services.AddDbContext <SiteDbContext>(options =>
{
options.UseMySql(Configuration["ConnectionString"],
mySqlOptionsAction: sqlOptions =>
{
sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
//sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
});
options.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
}, ServiceLifetime.Scoped);
services.AddDbContext <EventStoreDbContext>(options =>
{
options.UseMySql(Configuration["ConnectionString"],
mySqlOptionsAction: sqlOptions =>
{
sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
//sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
});
options.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
}, ServiceLifetime.Scoped);
services.AddSwaggerSupport();
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
// Add application services.
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
//services.AddTransient<Func<DbConnection, IIntegrationEventLogService>>(
// sp => (DbConnection c) => new IntegrationEventLogService(c));
//services.AddTransient<IIdentityAccessIntegrationEventService, IdentityAccessIntegrationEventService>();
//services.AddAutoMapperSetup();
services.AddEventStoreSetup();
services.AddApplicationSetup();
services.AddRabbitMQEventBusSetup(Configuration);
var container = new ContainerBuilder();
container.Populate(services);
container.RegisterModule(new ApplicationModule());
container.RegisterModule(new MediatorModule());
return(new AutofacServiceProvider(container.Build()));
}
protected override void Load(ContainerBuilder builder)
{
_ = builder.Register(context =>
DocumentStoreFactory.CreateStore(_connectionString, Assembly.GetExecutingAssembly()))
.As <IDocumentStore>()
.SingleInstance();
_ = builder.Register(context => context.Resolve <IDocumentStore>())
.Keyed <IDocumentStore>(DatabaseType.Tenant)
.SingleInstance();
_ = builder.Register(context => FileStoreFactory.CreateStore(_connectionString))
.As <IFilesStore>()
.SingleInstance();
_ = builder.Register(context => context.Resolve <IFilesStore>())
.Keyed <IFilesStore>(DatabaseType.Tenant)
.SingleInstance();
_ = builder.Register(x => x.Resolve <IDocumentStore>().OpenSession())
.As <IDocumentSession>()
.InstancePerLifetimeScope();
_ = builder.Register(x => x.Resolve <IDocumentSession>())
.Keyed <IDocumentSession>(DatabaseType.Tenant)
.InstancePerLifetimeScope();
_ = builder.Register(x => x.Resolve <IDocumentStore>().OpenAsyncSession())
.As <IAsyncDocumentSession>()
.InstancePerLifetimeScope();
_ = builder.Register(x => x.Resolve <IAsyncDocumentSession>())
.Keyed <IAsyncDocumentSession>(DatabaseType.Tenant)
.InstancePerLifetimeScope();
_ = builder.Register(x => x.Resolve <IFilesStore>().OpenAsyncSession())
.As <IAsyncFilesSession>()
.InstancePerLifetimeScope();
_ = builder.Register(x => x.Resolve <IAsyncFilesSession>())
.Keyed <IAsyncFilesSession>(DatabaseType.Tenant)
.InstancePerLifetimeScope();
_ = builder.RegisterType <TenantRavenDbContext>()
.As <IRavenTenantDbContext>()
.As <IRavenDbContext>()
.As <ITenantDbContext>()
.As <IDbContext>()
.WithRavenDbMetadata()
.InstancePerLifetimeScope();
// Register Raven repositories
_ = builder.RegisterRepository <RavenCampaignRepository, ICampaignRepository>();
_ = builder.RegisterRepository <RavenCampaignSettingsRepository, ICampaignSettingsRepository>();
_ = builder.RegisterRepository <RavenBreakRepository, IBreakRepository>();
_ = builder.RegisterRepository <RavenBusinessTypeRepository, IBusinessTypeRepository>();
_ = builder.RegisterRepository <RavenScheduleRepository, IScheduleRepository>();
_ = builder.RegisterRepository <RavenProgrammeRepository, IProgrammeRepository>();
_ = builder.RegisterRepository <RavenProgrammeDictionaryRepository, IProgrammeDictionaryRepository>();
_ = builder.RegisterRepository <RavenAutoBookRepository, IAutoBookRepository>();
_ = builder.RegisterRepository <RavenRunRepository, IRunRepository>();
_ = builder.RegisterRepository <RavenSpotRepository, ISpotRepository>();
_ = builder.RegisterRepository <RavenClashRepository, IClashRepository>();
_ = builder.RegisterRepository <RavenClashExceptionRepository, IClashExceptionRepository>();
_ = builder.RegisterRepository <RavenChannelRepository, IChannelsRepository>();
_ = builder.RegisterRepository <RavenSalesAreaRepository, ISalesAreaRepository>();
_ = builder.RegisterRepository <RavenScenarioResultRepository, IScenarioResultRepository>();
_ = builder.RegisterRepository <RavenMetadataRepository, IMetadataRepository>();
_ = builder.RegisterRepository <RavenTenantSettingsRepository, ITenantSettingsRepository>();
_ = builder.RegisterRepository <RavenProductRepository, IProductRepository>();
_ = builder.RegisterRepository <RavenFunctionalAreaRepository, IFunctionalAreaRepository>();
_ = builder.RegisterRepository <RavenLanguageRepository, ILanguageRepository>();
_ = builder.RegisterRepository <RavenRestrictionRepository, IRestrictionRepository>();
_ = builder.RegisterRepository <RavenRatingsScheduleRepository, IRatingsScheduleRepository>();
_ = builder.RegisterRepository <RavenResultsFileRepository, IResultsFileRepository>();
_ = builder.RegisterRepository <RavenOutputFileRepository, IOutputFileRepository>();
_ = builder.RegisterRepository <RavenUniverseRepository, IUniverseRepository>();
_ = builder.RegisterRepository <RavenFailuresRepository, IFailuresRepository>();
_ = builder.RegisterRepository <RavenScenarioCampaignFailureRepository, IScenarioCampaignFailureRepository>();
_ = builder.RegisterRepository <RavenRecommendationRepository, IRecommendationRepository>();
_ = builder.RegisterRepository <RavenISRSettingsRepository, IISRSettingsRepository>();
_ = builder.RegisterRepository <RavenRSSettingsRepository, IRSSettingsRepository>();
_ = builder.RegisterRepository <RavenISRGlobalSettingsRepository, IISRGlobalSettingsRepository>();
_ = builder.RegisterRepository <RavenRSGlobalSettingsRepository, IRSGlobalSettingsRepository>();
_ = builder.RegisterRepository <RavenDemographicRepository, IDemographicRepository>();
_ = builder.RegisterRepository <RavenSmoothFailureMessageRepository, ISmoothFailureMessageRepository>();
_ = builder.RegisterRepository <RavenSmoothFailureRepository, ISmoothFailureRepository>();
_ = builder.RegisterRepository <RavenAutoBookSettingsRepository, IAutoBookSettingsRepository>();
_ = builder.RegisterRepository <RavenAutoBookDefaultParametersRepository, IAutoBookDefaultParametersRepository>();
_ = builder.RegisterRepository <RavenAutoBookInstanceConfigurationRepository, IAutoBookInstanceConfigurationRepository>();
_ = builder.RegisterRepository <RavenAWSInstanceConfigurationRepository, IAWSInstanceConfigurationRepository>();
_ = builder.RegisterRepository <RavenEmailAuditEventSettingsRepository, IEmailAuditEventSettingsRepository>();
_ = builder.RegisterRepository <RavenMSTeamsAuditEventSettingsRepository, IMSTeamsAuditEventSettingsRepository>();
_ = builder.RegisterRepository <RavenProgrammeClassificationRepository, IProgrammeClassificationRepository>();
_ = builder.RegisterRepository <RavenClearanceRepository, IClearanceRepository>();
_ = builder.RegisterRepository <RavenKPIComparisonConfigRepository, IKPIComparisonConfigRepository>();
_ = builder.RegisterRepository <RavenScenarioRepository, IScenarioRepository>();
_ = builder.RegisterRepository <RavenPassRepository, IPassRepository>();
_ = builder.RegisterRepository <RavenSmoothConfigurationRepository, ISmoothConfigurationRepository>();
_ = builder.RegisterRepository <RavenIndexTypeRepository, IIndexTypeRepository>();
_ = builder.RegisterRepository <RavenLibrarySalesAreaPassPrioritiesRepository, ILibrarySalesAreaPassPrioritiesRepository>();
_ = builder.RegisterRepository <RavenEfficiencySettingsRepository, IEfficiencySettingsRepository>();
_ = builder.RegisterRepository <RavenSponsorshipRepository, ISponsorshipRepository>();
_ = builder.RegisterRepository <RavenSpotPlacementRepository, ISpotPlacementRepository>();
_ = builder.RegisterRepository <RavenAnalysisGroupRepository, IAnalysisGroupRepository>();
_ = builder.RegisterRepository <RavenAutopilotRuleRepository, IAutopilotRuleRepository>();
_ = builder.RegisterRepository <RavenAutopilotSettingsRepository, IAutopilotSettingsRepository>();
_ = builder.RegisterRepository <RavenFlexibilityLevelRepository, IFlexibilityLevelRepository>();
_ = builder.RegisterRepository <RavenRuleRepository, IRuleRepository>();
_ = builder.RegisterRepository <RavenRuleTypeRepository, IRuleTypeRepository>();
_ = builder.RegisterRepository <RavenScenarioCampaignResultsRepository, IScenarioCampaignResultRepository>();
_ = builder.RegisterRepository <RavenScenarioCampaignMetricRepository, IScenarioCampaignMetricRepository>();
_ = builder.RegisterRepository <RavenBookingPositionRepository, IBookingPositionRepository>();
_ = builder.RegisterRepository <RavenBookingPositionGroupRepository, IBookingPositionGroupRepository>();
_ = builder.RegisterRepository <RavenFacilityRepository, IFacilityRepository>();
_ = builder.RegisterRepository <RavenDeliveryCappingGroupRepository, IDeliveryCappingGroupRepository>();
_ = builder.RegisterRepository <RavenSalesAreaDemographicRepository, ISalesAreaDemographicRepository>();
_ = builder.RegisterRepository <RavenProgrammeCategoryHierarchyRepository, IProgrammeCategoryHierarchyRepository>();
_ = builder.RegisterRepository <RavenStandardDayPartRepository, IStandardDayPartRepository>();
_ = builder.RegisterRepository <RavenStandardDayPartGroupRepository, IStandardDayPartGroupRepository>();
_ = builder.RegisterRepository <RavenProgrammeEpisodeRepository, IProgrammeEpisodeRepository>();
_ = builder.RegisterRepository <RavenInventoryTypeRepository, IInventoryTypeRepository>();
_ = builder.RegisterRepository <RavenInventoryLockRepository, IInventoryLockRepository>();
_ = builder.RegisterRepository <RavenLockTypeRepository, ILockTypeRepository>();
_ = builder.RegisterRepository <RavenTotalRatingRepository, ITotalRatingRepository>();
_ = builder.RegisterRepository <RavenPipelineAuditEventRepository, IPipelineAuditEventRepository>();
_ = builder.RegisterRepository <RavenAutoBookTaskReportRepository, IAutoBookTaskReportRepository>();
_ = builder.RegisterRepository <RavenBRSConfigurationTemplateRepository, IBRSConfigurationTemplateRepository>();
_ = builder.RegisterRepository <RavenKPIPriorityRepository, IKPIPriorityRepository>();
_ = builder.RegisterRepository <RavenRunTypeRepository, IRunTypeRepository>();
_ = builder.RegisterRepository <RavenSpotBookingRuleRepository, ISpotBookingRuleRepository>();
_ = builder.RegisterRepository <RavenLengthFactorRepository, ILengthFactorRepository>();
_ = builder.RegisterRepository <RavenLandmarkRunQueueRepository, ILandmarkRunQueueRepository>();
_ = builder.RegisterType <RavenTenantIdentifierSequence>()
.As <IRavenTenantIdentifierSequence>()
.As <IRavenIdentifierSequence>()
.As <ITenantIdentifierSequence>()
.As <IIdentifierSequence>()
.WithRavenDbMetadata()
.InstancePerLifetimeScope();
_ = builder.RegisterType <RavenIdentityGenerator>()
.As <IRavenIdentityGenerator>()
.As <IIdentityGenerator>()
.WithRavenDbMetadata()
.InstancePerLifetimeScope();
_ = builder.Register(context => new RavenDatabaseIndexAwaiter(context.Resolve <IRavenTenantDbContext>()))
.As <IDatabaseIndexAwaiter>()
.WithRavenDbMetadata()
.InstancePerLifetimeScope();
_ = builder.RegisterType <RavenSalesAreaCleanupDeleteCommand>()
.As <ISalesAreaCleanupDeleteCommand>()
.WithRavenDbMetadata()
.InstancePerLifetimeScope();
}
/// <summary>
/// Registers the data services.
/// </summary>
/// <param name="builder">The builder.</param>
public static void RegisterDataServices(this ContainerBuilder builder)
{
builder.RegisterType<EmployeeDataService>().As<IEmployeeDataService>();
builder.RegisterType<UserLoginService>().As<IUserLoginService>();
builder.RegisterType<PageLoadDataService>().As<IPageLoadDataService>();
}
protected override void Initialize()
{
base.Initialize();
ContainerBuilder.RegisterType <PhotoImporter>().As <IPhotoImporter>().SingleInstance();
}
public static void ConfigureContainer(ContainerBuilder builder)
{
//configure autofac
builder.RegisterModule(new MediatorModule());
builder.RegisterModule(new ApplicationModule());
}
// This only gets called if your environment is Production. The
// default ConfigureContainer won't be automatically called if this
// one is called.
public void ConfigureProductionContainer(ContainerBuilder builder)
{
// Add things to the ContainerBuilder that are only for the
// production environment.
}
protected override void Load(ContainerBuilder builder)
{
RegisterInMemoryLinkStore(builder);
}
/// <summary>
/// Registers the business services.
/// </summary>
/// <param name="builder">The builder.</param>
public static void RegisterBusinessServices(this ContainerBuilder builder)
{
builder.RegisterType<EmployeeService>().As<IEmployeeService>();
builder.RegisterType<LoginService>().As<ILoginService>();
builder.RegisterType<PageLoad>().As<IPageLoad>();
}
/// <inheritdoc/>
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <ServiceProvider>().As <IServiceProvider>().InstancePerLifetimeScope();
}
protected override void OnStart(string[] args)
{
#region logging
PatternLayout layout = new PatternLayout
{
ConversionPattern = "%d %-5p %c - %m%n"
};
layout.ActivateOptions();
ConsoleAppender appender = new ConsoleAppender
{
Layout = layout,
Threshold = Level.Info
};
appender.ActivateOptions();
BasicConfigurator.Configure(appender);
LogManager.Use <Log4NetFactory>();
#endregion
#region create-config
BusConfiguration busConfiguration = new BusConfiguration();
#endregion
#region endpoint-name
busConfiguration.EndpointName("Samples.FirstEndpoint");
#endregion
#region container
ContainerBuilder builder = new ContainerBuilder();
//configure your custom services
//builder.RegisterInstance(new MyService());
IContainer container = builder.Build();
busConfiguration.UseContainer <AutofacBuilder>(c => c.ExistingLifetimeScope(container));
#endregion
#region serialization
busConfiguration.UseSerialization <JsonSerializer>();
#endregion
#region transport
busConfiguration.UseTransport <MsmqTransport>();
#endregion
#region sagas
//Not required since Sagas are enabled by default in Version 5
#endregion
#region persistence
busConfiguration.UsePersistence <InMemoryPersistence, StorageType.Sagas>();
busConfiguration.UsePersistence <InMemoryPersistence, StorageType.Subscriptions>();
busConfiguration.UsePersistence <InMemoryPersistence, StorageType.Timeouts>();
#endregion
#region critical-errors
busConfiguration.DefineCriticalErrorAction((errorMessage, exception) =>
{
// Log the critical error
logger.Fatal(string.Format("CRITICAL: {0}", errorMessage), exception);
// Kill the process on a critical error
string output = string.Format("The following critical error was encountered by NServiceBus:\n{0}\nNServiceBus is shutting down.", errorMessage);
Environment.FailFast(output, exception);
});
#endregion
#region start-bus
busConfiguration.EnableInstallers();
bus = Bus.Create(busConfiguration).Start();
#endregion
}
/// <summary>
/// The register dynamic services.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="assemblies">
/// The assemblies.
/// </param>
private static void RegisterDynamicServices(ContainerBuilder builder, [NotNull] Assembly[] assemblies)
{
CodeContracts.VerifyNotNull(assemblies, "assemblies");
var classes = assemblies.FindClassesWithAttribute <ExportServiceAttribute>();
var exclude = new List <Type>
{
typeof(IDisposable), typeof(IHaveServiceLocator), typeof(IHaveLocalization)
};
classes.ForEach(
c =>
{
var exportAttribute = c.GetAttribute <ExportServiceAttribute>();
if (exportAttribute == null)
{
return;
}
var built = builder.RegisterType(c).As(c);
Type[] typesToRegister;
if (exportAttribute.RegisterSpecifiedTypes != null &&
exportAttribute.RegisterSpecifiedTypes.Any())
{
// only register types provided...
typesToRegister = exportAttribute.RegisterSpecifiedTypes;
}
else
{
// register all associated interfaces including inherited interfaces
typesToRegister = c.GetInterfaces().Where(i => !exclude.Contains(i)).ToArray();
}
built = exportAttribute.Named.IsSet()
? typesToRegister.Aggregate(
built,
(current, regType) => current.Named(exportAttribute.Named, regType))
: typesToRegister.Aggregate(built, (current, regType) => current.As(regType));
switch (exportAttribute.ServiceLifetimeScope)
{
case ServiceLifetimeScope.Singleton:
built.SingleInstance();
break;
case ServiceLifetimeScope.Transient:
built.ExternallyOwned();
break;
case ServiceLifetimeScope.OwnedByContainer:
built.OwnedByLifetimeScope();
break;
case ServiceLifetimeScope.InstancePerScope:
built.InstancePerLifetimeScope();
break;
case ServiceLifetimeScope.InstancePerDependancy:
built.InstancePerDependency();
break;
case ServiceLifetimeScope.InstancePerContext:
built.InstancePerMatchingLifetimeScope(LifetimeScope.Context);
break;
}
});
}
public IContainer DICollections()
{
var basePath = Microsoft.DotNet.PlatformAbstractions.ApplicationEnvironment.ApplicationBasePath;
IServiceCollection services = new ServiceCollection();
services.AddAutoMapper(typeof(Startup));
services.AddSingleton(new Appsettings(basePath));
services.AddSingleton(new LogLock(basePath));
services.AddSingleton <IRedisCacheManager, RedisCacheManager>();
services.AddScoped <Blog.Core.Model.Models.DBSeed>();
services.AddScoped <Blog.Core.Model.Models.MyContext>();
//读取配置文件
var symmetricKeyAsBase64 = AppSecretConfig.Audience_Secret_String;
var keyByteArray = Encoding.ASCII.GetBytes(symmetricKeyAsBase64);
var signingKey = new SymmetricSecurityKey(keyByteArray);
var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var permission = new List <PermissionItem>();
var permissionRequirement = new PermissionRequirement(
"/api/denied",
permission,
ClaimTypes.Role,
Appsettings.app(new string[] { "Audience", "Issuer" }),
Appsettings.app(new string[] { "Audience", "Audience" }),
signingCredentials, //签名凭据
expiration: TimeSpan.FromSeconds(60 * 60) //接口的过期时间
);
services.AddSingleton(permissionRequirement);
//【授权】
services.AddAuthorization(options =>
{
options.AddPolicy(Permissions.Name,
policy => policy.Requirements.Add(permissionRequirement));
});
services.AddScoped <SqlSugar.ISqlSugarClient>(o =>
{
return(new SqlSugar.SqlSugarClient(new SqlSugar.ConnectionConfig()
{
ConnectionString = GetMainConnectionDb().Conn, //必填, 数据库连接字符串
DbType = (SqlSugar.DbType)GetMainConnectionDb().DbType, //必填, 数据库类型
IsAutoCloseConnection = true, //默认false, 时候知道关闭数据库连接, 设置为true无需使用using或者Close操作
IsShardSameThread = true, //共享线程
InitKeyType = SqlSugar.InitKeyType.SystemTable //默认SystemTable, 字段信息读取, 如：该属性是不是主键，标识列等等信息
}));
});
//实例化 AutoFac 容器
var builder = new ContainerBuilder();
//builder.RegisterType<AdvertisementServices>().As<IAdvertisementServices>();
//指定已扫描程序集中的类型注册为提供所有其实现的接口。
var servicesDllFile = Path.Combine(basePath, "Blog.Core.Services.dll");
var assemblysServices = Assembly.LoadFrom(servicesDllFile);
builder.RegisterAssemblyTypes(assemblysServices)
.AsImplementedInterfaces()
.InstancePerLifetimeScope()
.EnableInterfaceInterceptors();
var repositoryDllFile = Path.Combine(basePath, "Blog.Core.Repository.dll");
var assemblysRepository = Assembly.LoadFrom(repositoryDllFile);
builder.RegisterAssemblyTypes(assemblysRepository).AsImplementedInterfaces();
//将services填充到Autofac容器生成器中
builder.Populate(services);
//使用已进行的组件登记创建新容器
var ApplicationContainer = builder.Build();
var blogservice = ApplicationContainer.Resolve <IBlogArticleServices>();
var myContext = ApplicationContainer.Resolve <MyContext>();
DBSeed.SeedAsync(myContext, basePath).Wait();
return(ApplicationContainer);
}
protected override void Load(ContainerBuilder builder)
{
// IMetricsListener
builder.Register(
c =>
this.metricsConfig.Enabled
? new MetricsListener(this.metricsConfig.ListenerConfig, c.Resolve <IMetricsProvider>())
: new NullMetricsListener() as IMetricsListener)
.As <IMetricsListener>()
.SingleInstance();
// IMetricsProvider
builder.Register(
c =>
this.metricsConfig.Enabled
? new MetricsProvider(MetricsConstants.EdgeHubMetricPrefix, this.iothubHostName, this.edgeDeviceId, this.metricsConfig.HistogramMaxAge)
: new NullMetricsProvider() as IMetricsProvider)
.As <IMetricsProvider>()
.SingleInstance();
// ISignatureProvider
builder.Register(
c =>
{
ISignatureProvider signatureProvider = this.edgeHubConnectionString.Map(
cs =>
{
IotHubConnectionStringBuilder csBuilder = IotHubConnectionStringBuilder.Create(cs);
return(new SharedAccessKeySignatureProvider(csBuilder.SharedAccessKey) as ISignatureProvider);
})
.GetOrElse(
() =>
{
string edgeHubGenerationId = this.edgeHubGenerationId.Expect(() => new InvalidOperationException("Generation ID missing"));
string workloadUri = this.workloadUri.Expect(() => new InvalidOperationException("workloadUri is missing"));
string workloadApiVersion = this.workloadApiVersion.Expect(() => new InvalidOperationException("workloadUri version is missing"));
return(new HttpHsmSignatureProvider(this.edgeHubModuleId, edgeHubGenerationId, workloadUri, workloadApiVersion, Constants.WorkloadApiVersion) as ISignatureProvider);
});
return(signatureProvider);
})
.As <ISignatureProvider>()
.SingleInstance();
// Detect system environment
builder.Register(c => new SystemEnvironment())
.As <ISystemEnvironment>()
.SingleInstance();
// DataBase options
builder.Register(c => new RocksDbOptionsProvider(c.Resolve <ISystemEnvironment>(), this.optimizeForPerformance, this.storageMaxTotalWalSize, this.storageMaxOpenFiles, this.storageLogLevel))
.As <IRocksDbOptionsProvider>()
.SingleInstance();
if (!this.usePersistentStorage && this.useBackupAndRestore)
{
// Backup and restore serialization
builder.Register(c => new ProtoBufDataBackupRestore())
.As <IDataBackupRestore>()
.SingleInstance();
}
// IStorageSpaceChecker
builder.Register(
c =>
{
IStorageSpaceChecker spaceChecker = !this.usePersistentStorage
? new MemorySpaceChecker(() => 0L) as IStorageSpaceChecker
: new NullStorageSpaceChecker();
return(spaceChecker);
})
.As <IStorageSpaceChecker>()
.SingleInstance();
// IDbStoreProvider
builder.Register(
async c =>
{
var loggerFactory = c.Resolve <ILoggerFactory>();
ILogger logger = loggerFactory.CreateLogger(typeof(RoutingModule));
if (this.usePersistentStorage)
{
// Create partitions for messages and twins
var partitionsList = new List <string> {
Core.Constants.MessageStorePartitionKey, Core.Constants.TwinStorePartitionKey, Core.Constants.CheckpointStorePartitionKey
};
try
{
IDbStoreProvider dbStoreProvider = DbStoreProvider.Create(
c.Resolve <IRocksDbOptionsProvider>(),
this.storagePath,
partitionsList);
logger.LogInformation($"Created persistent store at {this.storagePath}");
return(dbStoreProvider);
}
catch (Exception ex) when(!ex.IsFatal())
{
logger.LogError(ex, "Error creating RocksDB store. Falling back to in-memory store.");
IDbStoreProvider dbStoreProvider = await this.BuildInMemoryDbStoreProvider(c);
return(dbStoreProvider);
}
}
else
{
logger.LogInformation($"Using in-memory store");
IDbStoreProvider dbStoreProvider = await this.BuildInMemoryDbStoreProvider(c);
return(dbStoreProvider);
}
})
.As <Task <IDbStoreProvider> >()
.SingleInstance();
// Task<Option<IEncryptionProvider>>
builder.Register(
async c =>
{
Option <IEncryptionProvider> encryptionProviderOption = await this.workloadUri
.Map(
async uri =>
{
var encryptionProvider = await EncryptionProvider.CreateAsync(
this.storagePath,
new Uri(uri),
this.workloadApiVersion.Expect(() => new InvalidOperationException("Missing workload API version")),
Constants.WorkloadApiVersion,
this.edgeHubModuleId,
this.edgeHubGenerationId.Expect(() => new InvalidOperationException("Missing generation ID")),
Constants.InitializationVectorFileName) as IEncryptionProvider;
return(Option.Some(encryptionProvider));
})
.GetOrElse(() => Task.FromResult(Option.None <IEncryptionProvider>()));
return(encryptionProviderOption);
})
.As <Task <Option <IEncryptionProvider> > >()
.SingleInstance();
// Task<IStoreProvider>
builder.Register(async c =>
{
var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
return(storeProvider);
})
.As <Task <IStoreProvider> >()
.SingleInstance();
// Task<IMetadataStore>
builder.Register(
async c =>
{
var storeProvider = await c.Resolve <Task <IStoreProvider> >();
IKeyValueStore <string, string> entityStore = storeProvider.GetEntityStore <string, string>("ProductInfo", "MetadataStore");
IMetadataStore metadataStore = new MetadataStore(entityStore, this.productInfo);
return(metadataStore);
})
.As <Task <IMetadataStore> >()
.SingleInstance();
// ITokenProvider
builder.Register(c => new ClientTokenProvider(c.Resolve <ISignatureProvider>(), this.iothubHostName, this.edgeDeviceId, this.edgeHubModuleId, TimeSpan.FromHours(1)))
.Named <ITokenProvider>("EdgeHubClientAuthTokenProvider")
.SingleInstance();
// ITokenProvider
builder.Register(
c =>
{
string deviceId = WebUtility.UrlEncode(this.edgeDeviceId);
string moduleId = WebUtility.UrlEncode(this.edgeHubModuleId);
return(new ClientTokenProvider(c.Resolve <ISignatureProvider>(), this.iothubHostName, deviceId, moduleId, TimeSpan.FromHours(1)));
})
.Named <ITokenProvider>("EdgeHubServiceAuthTokenProvider")
.SingleInstance();
builder.Register(
c =>
{
var loggerFactory = c.Resolve <ILoggerFactory>();
var logger = loggerFactory.CreateLogger <RoutingModule>();
return(Proxy.Parse(this.proxy, logger));
})
.As <Option <IWebProxy> >()
.SingleInstance();
// Task<IDeviceScopeIdentitiesCache>
builder.Register(
async c =>
{
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache;
if (this.authenticationMode == AuthenticationMode.CloudAndScope || this.authenticationMode == AuthenticationMode.Scope)
{
var edgeHubTokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubServiceAuthTokenProvider");
var proxy = c.Resolve <Option <IWebProxy> >();
var serviceIdentityTree = new ServiceIdentityTree(this.edgeDeviceId);
string hostName = this.gatewayHostName.GetOrElse(this.iothubHostName);
IDeviceScopeApiClientProvider securityScopesApiClientProvider = new DeviceScopeApiClientProvider(hostName, this.edgeDeviceId, this.edgeHubModuleId, 10, edgeHubTokenProvider, serviceIdentityTree, proxy);
IServiceProxy serviceProxy = new ServiceProxy(securityScopesApiClientProvider, this.nestedEdgeEnabled);
IKeyValueStore <string, string> encryptedStore = await GetEncryptedStore(c, "DeviceScopeCache");
deviceScopeIdentitiesCache = await DeviceScopeIdentitiesCache.Create(serviceIdentityTree, serviceProxy, encryptedStore, this.scopeCacheRefreshRate, this.scopeCacheRefreshDelay);
}
else
{
deviceScopeIdentitiesCache = new NullDeviceScopeIdentitiesCache();
}
return(deviceScopeIdentitiesCache);
})
.As <Task <IDeviceScopeIdentitiesCache> >()
.AutoActivate()
.SingleInstance();
// IRegistryApiClient
builder.Register(
c =>
{
string upstreamHostname = this.gatewayHostName.GetOrElse(this.iothubHostName);
var proxy = c.Resolve <Option <IWebProxy> >();
var edgeHubTokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubServiceAuthTokenProvider");
return(new RegistryOnBehalfOfApiClient(upstreamHostname, proxy, edgeHubTokenProvider));
})
.As <IRegistryOnBehalfOfApiClient>()
.SingleInstance();
// Task<ICredentialsCache>
builder.Register(
async c =>
{
ICredentialsCache underlyingCredentialsCache;
if (this.persistTokens)
{
IKeyValueStore <string, string> encryptedStore = await GetEncryptedStore(c, "CredentialsCache");
return(new PersistedTokenCredentialsCache(encryptedStore));
}
else
{
underlyingCredentialsCache = new NullCredentialsCache();
}
ICredentialsCache credentialsCache = new CredentialsCache(underlyingCredentialsCache);
return(credentialsCache);
})
.As <Task <ICredentialsCache> >()
.SingleInstance();
// Task<IAuthenticator>
builder.Register(
async c =>
{
IAuthenticator tokenAuthenticator;
IAuthenticator certificateAuthenticator;
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache;
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
// by default regardless of how the authenticationMode, X.509 certificate validation will always be scoped
deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
certificateAuthenticator = new DeviceScopeCertificateAuthenticator(deviceScopeIdentitiesCache, new NullAuthenticator(), this.trustBundle, true, this.nestedEdgeEnabled);
switch (this.authenticationMode)
{
case AuthenticationMode.Cloud:
tokenAuthenticator = await this.GetCloudTokenAuthenticator(c);
break;
case AuthenticationMode.Scope:
tokenAuthenticator = new DeviceScopeTokenAuthenticator(deviceScopeIdentitiesCache, this.iothubHostName, this.edgeDeviceHostName, new NullAuthenticator(), true, true, this.nestedEdgeEnabled);
break;
default:
IAuthenticator cloudTokenAuthenticator = await this.GetCloudTokenAuthenticator(c);
tokenAuthenticator = new DeviceScopeTokenAuthenticator(deviceScopeIdentitiesCache, this.iothubHostName, this.edgeDeviceHostName, cloudTokenAuthenticator, true, true, this.nestedEdgeEnabled);
break;
}
ICredentialsCache credentialsCache = await credentialsCacheTask;
return(new Authenticator(tokenAuthenticator, certificateAuthenticator, credentialsCache) as IAuthenticator);
})
.As <Task <IAuthenticator> >()
.SingleInstance();
// IClientCredentialsFactory
builder.Register(c => new ClientCredentialsFactory(c.Resolve <IIdentityProvider>(), this.productInfo))
.As <IClientCredentialsFactory>()
.SingleInstance();
// ConnectionReauthenticator
builder.Register(
async c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var authenticatorTask = c.Resolve <Task <IAuthenticator> >();
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var deviceScopeIdentitiesCacheTask = c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
IConnectionManager connectionManager = await connectionManagerTask;
IAuthenticator authenticator = await authenticatorTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await deviceScopeIdentitiesCacheTask;
var connectionReauthenticator = new ConnectionReauthenticator(
connectionManager,
authenticator,
credentialsCache,
deviceScopeIdentitiesCache,
TimeSpan.FromMinutes(5),
edgeHubCredentials.Identity,
deviceConnectivityManager);
return(connectionReauthenticator);
})
.As <Task <ConnectionReauthenticator> >()
.SingleInstance();
base.Load(builder);
}
public override void ConfigureContainer(ContainerBuilder builder)
{
base.ConfigureContainer(builder);
// builder.RegisterType<SomeService>().As<ISomeService>(); //if needed override registration with own test fakes
}
public void ConfigureContainer(ContainerBuilder containerBuilder)
{
containerBuilder.RegisterModule(new DependencyRegister());
}
protected override void Load(ContainerBuilder builder)
{
ConfiguratioinIoc.Load(builder);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterAssemblyTypesWithAttributes(ThisAssembly);
}
/// <summary> /// Initializes an instance of <see cref="AutofacDependencyResolver"/> that overrides the default <see cref="Locator"/>. /// </summary> /// <param name="containerBuilder">Autofac container builder.</param> public static void UseAutofacDependencyResolver(this ContainerBuilder containerBuilder) => Locator.SetLocator(new AutofacDependencyResolver(containerBuilder.Build()));
protected override void Load(ContainerBuilder builder)
{
builder.Register(c => new AComponent()).As <AComponent>();
}
/// <summary>
/// autofac configure
/// https://github.com/1100100/Dapper.Extensions
/// </summary>
/// <param name="containerBuilder"></param>
public void ConfigureContainer(ContainerBuilder containerBuilder)
{
containerBuilder.AddZipkin(ServiceName.ProductService);
}
protected override void Load(ContainerBuilder builder)
{
if (Configuration.GetValue <bool>("logging:human"))
{
builder.Register(c => new Func <IObjectWriter>(() => new JsonLogWriter(Formatting.Indented, true)))
.AsSelf()
.SingleInstance();
}
else
{
builder.Register(c => new Func <IObjectWriter>(() => new JsonLogWriter()))
.AsSelf()
.SingleInstance();
}
var loggingFile = Configuration.GetValue <string>("logging:file");
if (!string.IsNullOrWhiteSpace(loggingFile))
{
builder.RegisterInstance(new FileChannel(loggingFile))
.As <ILogChannel>()
.As <IExternalSystem>()
.SingleInstance();
}
builder.Register(c => new ApplicationInfoLogAppender(GetType(), Guid.NewGuid()))
.As <ILogAppender>()
.SingleInstance();
builder.RegisterType <ActionContextLogAppender>()
.As <ILogAppender>()
.SingleInstance();
builder.RegisterType <TimestampLogAppender>()
.As <ILogAppender>()
.SingleInstance();
builder.RegisterType <DebugLogChannel>()
.As <ILogChannel>()
.SingleInstance();
builder.RegisterType <ConsoleLogChannel>()
.As <ILogChannel>()
.SingleInstance();
builder.RegisterType <SemanticLog>()
.As <ISemanticLog>()
.SingleInstance();
builder.Register(c => SystemClock.Instance)
.As <IClock>()
.SingleInstance();
builder.RegisterType <BackgroundUsageTracker>()
.As <IUsageTracker>()
.SingleInstance();
builder.RegisterType <HttpContextAccessor>()
.As <IHttpContextAccessor>()
.SingleInstance();
builder.RegisterType <ActionContextAccessor>()
.As <IActionContextAccessor>()
.SingleInstance();
builder.RegisterType <DefaultDomainObjectRepository>()
.As <IDomainObjectRepository>()
.SingleInstance();
builder.RegisterType <DefaultDomainObjectFactory>()
.As <IDomainObjectFactory>()
.SingleInstance();
builder.RegisterType <AggregateHandler>()
.As <IAggregateHandler>()
.SingleInstance();
builder.RegisterType <InMemoryCommandBus>()
.As <ICommandBus>()
.SingleInstance();
builder.RegisterType <DefaultEventNotifier>()
.As <IEventNotifier>()
.SingleInstance();
builder.RegisterType <DefaultStreamNameResolver>()
.As <IStreamNameResolver>()
.SingleInstance();
builder.RegisterType <ImageSharpAssetThumbnailGenerator>()
.As <IAssetThumbnailGenerator>()
.SingleInstance();
builder.RegisterType <EventDataFormatter>()
.AsSelf()
.SingleInstance();
builder.RegisterType <SchemaJsonSerializer>()
.AsSelf()
.SingleInstance();
builder.RegisterType <FieldRegistry>()
.AsSelf()
.SingleInstance();
builder.Register(c => new InvalidatingMemoryCache(new MemoryCache(c.Resolve <IOptions <MemoryCacheOptions> >()), c.Resolve <IPubSub>()))
.As <IMemoryCache>()
.SingleInstance();
}
public static void Main(string[] args)
{
if (!Mutex.TryOpenExisting(MutexName, out _))
{
using (new Mutex(false, MutexName))
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
};
settings.Converters.Add(new StringEnumConverter(typeof(CamelCaseNamingStrategy)));
return(settings);
};
var applicationDataContainers = new ApplicationDataContainers
{
LocalSettings = new ApplicationDataContainerAdapter(ApplicationData.Current.LocalSettings),
RoamingSettings = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings),
KeyBindings = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings.CreateContainer(Constants.KeyBindingsContainerName, ApplicationDataCreateDisposition.Always)),
ShellProfiles = new ApplicationDataContainerAdapter(ApplicationData.Current.LocalSettings.CreateContainer(Constants.ShellProfilesContainerName, ApplicationDataCreateDisposition.Always)),
Themes = new ApplicationDataContainerAdapter(ApplicationData.Current.RoamingSettings.CreateContainer(Constants.ThemesContainerName, ApplicationDataCreateDisposition.Always))
};
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterInstance(applicationDataContainers);
containerBuilder.RegisterType <NotificationService>().As <INotificationService>().InstancePerDependency();
containerBuilder.RegisterType <TerminalsManager>().SingleInstance();
containerBuilder.RegisterType <ToggleWindowService>().SingleInstance();
containerBuilder.RegisterInstance(new HotKeyManager()).SingleInstance();
containerBuilder.RegisterType <SystemTrayApplicationContext>().SingleInstance();
containerBuilder.RegisterType <AppCommunicationService>().SingleInstance();
containerBuilder.RegisterType <DefaultValueProvider>().As <IDefaultValueProvider>();
containerBuilder.RegisterType <SettingsService>().As <ISettingsService>().SingleInstance();
containerBuilder.RegisterType <UpdateService>().As <IUpdateService>().SingleInstance();
containerBuilder.RegisterInstance(Dispatcher.CurrentDispatcher).SingleInstance();
var container = containerBuilder.Build();
// TODO: It's maybe better to wait for logging to be configured before continuing?
// ReSharper disable once AssignmentIsFullyDiscarded
_ = ConfigureLoggingAsync();
var appCommunicationService = container.Resolve <AppCommunicationService>();
if (args.Length > 0 && args[2] == "appLaunched")
{
// ReSharper disable once AssignmentIsFullyDiscarded
_ = appCommunicationService.StartAppServiceConnectionAsync();
}
#if !STORE
// ReSharper disable once AssignmentIsFullyDiscarded
_ = Task.Factory.StartNew(() => container.Resolve <IUpdateService>().CheckForUpdateAsync());
#endif
var settingsService = container.Resolve <ISettingsService>();
// ReSharper disable once AssignmentIsFullyDiscarded
_ = Task.Factory.StartNew(() => Utilities.MuteTerminal(settingsService.GetApplicationSettings().MuteTerminalBeeps));
if (settingsService.GetApplicationSettings().EnableTrayIcon)
{
Application.Run(container.Resolve <SystemTrayApplicationContext>());
}
else
{
Application.Run();
}
}
}
else
{
var eventWaitHandle = EventWaitHandle.OpenExisting(AppCommunicationService.EventWaitHandleName, System.Security.AccessControl.EventWaitHandleRights.Modify);
eventWaitHandle.Set();
}
}
