private static void AddILoggerToParameters(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
var resolvedParameter = new ResolvedParameter((p, i) => p.ParameterType == typeof(ILogger), (p, i) => new SerilogWrapper(i.Resolve<Serilog.ILogger>().ForContext(t)));
e.Parameters = e.Parameters.Union(new[] { resolvedParameter });
}
public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
var zergDataProvider = new ZergDataProvider();
zergDataProvider.InitDatabase();
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
//不同数据库对应不同的仓库
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
builder.Register<IDbContext>(c => new CMSDbContext(dataProviderSettings.RawDataSettings["CMSConnection"])).Named<IDbContext>("CMS").InstancePerRequest();
builder.Register<IDbContext>(c => new CRMDbContext(dataProviderSettings.RawDataSettings["CRMConnection"])).Named<IDbContext>("CRM").InstancePerRequest();
builder.Register<IDbContext>(c => new TradingDbContext(dataProviderSettings.RawDataSettings["TradingConnection"])).Named<IDbContext>("Trading").InstancePerRequest();
builder.Register<IDbContext>(c => new EventDbContext(dataProviderSettings.RawDataSettings["EventConnection"])).Named<IDbContext>("Event").InstancePerRequest();
builder.Register<IDbContext>(c => new CommunityDbContext(dataProviderSettings.RawDataSettings["CommunityConnection"])).Named<IDbContext>("Community").InstancePerRequest();
}
#region 不同的数据库对应不同仓库
var cmsParameter = new ResolvedParameter((pi, ctx) => pi.Name == "context",
(pi, ctx) => ctx.ResolveNamed<IDbContext>("CMS"));
var crmParameter = new ResolvedParameter((pi, ctx) => pi.Name == "context",
(pi, ctx) => ctx.ResolveNamed<IDbContext>("CRM"));
var tradingParameter = new ResolvedParameter((pi, ctx) => pi.Name == "context",
(pi, ctx) => ctx.ResolveNamed<IDbContext>("Trading"));
var eventPrameter = new ResolvedParameter((pi, ctx) => pi.Name == "context",
(pi, ctx) => ctx.ResolveNamed<IDbContext>("Event"));
var communityPrameter = new ResolvedParameter((pi, ctx) => pi.Name == "context",
(pi, ctx) => ctx.ResolveNamed<IDbContext>("Community"));
builder.RegisterGeneric(typeof(CMSRepository<>))
.WithParameter(cmsParameter)
.As(typeof(ICMSRepository<>))
.InstancePerRequest();
builder.RegisterGeneric(typeof(CRMRepository<>))
.WithParameter(crmParameter)
.As(typeof(ICRMRepository<>))
.InstancePerRequest();
builder.RegisterGeneric(typeof(TradingRepository<>))
.WithParameter(tradingParameter)
.As(typeof(ITradingRepository<>))
.InstancePerRequest();
builder.RegisterGeneric(typeof(EventRepository<>))
.WithParameter(eventPrameter)
.As(typeof(IEventRepository<>))
.InstancePerRequest();
builder.RegisterGeneric(typeof(CommunityRepository<>))
.WithParameter(communityPrameter)
.As(typeof(ICommunityRepository<>))
.InstancePerRequest();
#endregion
// builder.RegisterAssemblyTypes(typeFinder.GetAssemblies().ToArray())
// .Where(t =>!String.IsNullOrEmpty(t.Namespace)&& t.Namespace.StartsWith("CMS") && t.Name.Contains("Service"))
// .WithParameter(repositeryParameter);
}
//
// GET: /Home/
public ActionResult NormalDependencyInjection()
{
var service = DependencyResolver.Current.GetService<IMessageService>();
//var chineseService = _container.Resolve<IMessageService>(new NamedParameter("serviceName", "chinese"));
var param = new NamedParameter("Name", "chinese");
var resolveNamed = new ResolvedParameter((p, c) => p.Name == "chinese_service", (p, c) => c.ResolveNamed<IMessageRepository>("chinese"));
var chineseService = AutofacDependencyResolver.Current.ResolveByNamed<IMessageService>("chinese_service");
return View();
}
private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var limitType = e.Component.Activator.LimitType;
var resolvedParameter = new ResolvedParameter((p, i) => p.ParameterType == typeof (ILog),
(p, i) => LogManager.GetLogger(limitType));
e.Parameters = e.Parameters.Union(new[] {resolvedParameter});
}
public void DependencyParameterCreatesExpectedResolver()
{
Type expectedType = typeof(ILogger);
ResolvedParameter parameter = new ResolvedParameter<ILogger>();
IDependencyResolverPolicy resolver = parameter.GetResolverPolicy(expectedType);
Assert.IsInstanceOfType(resolver, typeof(NamedTypeDependencyResolverPolicy));
Assert.AreEqual(expectedType, ((NamedTypeDependencyResolverPolicy)resolver).Type);
Assert.IsNull(((NamedTypeDependencyResolverPolicy)resolver).Name);
}
public void ResolvedParameterHandledNamedTypes()
{
Type expectedType = typeof(ILogger);
string name = "special";
ResolvedParameter parameter = new ResolvedParameter(expectedType, name);
IDependencyResolverPolicy resolver = parameter.GetResolverPolicy(expectedType);
Assert.IsInstanceOfType(resolver, typeof(NamedTypeDependencyResolverPolicy));
Assert.AreEqual(expectedType, ((NamedTypeDependencyResolverPolicy)resolver).Type);
Assert.AreEqual(name, ((NamedTypeDependencyResolverPolicy)resolver).Name);
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
registration.Preparing +=
(sender, args) =>
{
var forType = args.Component.Activator.LimitType;
var logParameter = new ResolvedParameter(
(p, c) => p.ParameterType == typeof(ILogger),
(p, c) => c.Resolve<ILogger>(TypedParameter.From(forType)));
args.Parameters = args.Parameters.Union(new[] { logParameter });
};
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
builder.RegisterType <ExtendedTopicService>().As <IExtendedTopicService>().InstancePerLifetimeScope();
//data context
this.RegisterPluginDataContext <MenuObjectContext>(builder, CONTEXT_NAME);
//override required repository with our custom context
builder.RegisterType <EfRepository <ExtendedTopicRecord> >()
.As <IRepository <ExtendedTopicRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <TopicHeaderRecord> >()
.As <IRepository <TopicHeaderRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <TopicHeaderCarouselRecord> >()
.As <IRepository <TopicHeaderCarouselRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
//we cache presentation models between requests
builder.RegisterType <WidgetsFullCalendarController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
//installation localization service
builder.RegisterType <AppointmentService>().As <IAppointmentService>().InstancePerLifetimeScope();
//helpers
builder.RegisterType <DateTimeHelper>().As <IDateTimeHelper>().InstancePerLifetimeScope();
//data context
this.RegisterPluginDataContext <FullCalendarObjectContext>(builder, "nop_object_context_full_calendar");
//override required repository with our custom context
builder.RegisterType <EfRepository <Appointment> >()
.As <IRepository <Appointment> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_full_calendar"))
.InstancePerLifetimeScope();
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
builder.RegisterInstance(new HttpClient()).SingleInstance();
builder.RegisterType <OnBoardingService>().As <IOnBoardingService>().SingleInstance();
builder.RegisterType <ChargeService>().As <IChargeService>();
builder.RegisterType <AccountService>().As <IAccountService>();
builder.RegisterType <RefundService>().As <IRefundService>();
//data context
builder.RegisterPluginDataContext <Data.StripeConnectObjectContext>("nop_object_context_stripeconnect");
//override required repository with our custom context
builder.RegisterType <EfRepository <Domain.StripeCustomer> >().As <IRepository <Domain.StripeCustomer> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_stripeconnect"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <Domain.StripeOrderCharge> >().As <IRepository <Domain.StripeOrderCharge> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_stripeconnect"))
.InstancePerLifetimeScope();
builder.RegisterType <CustomerEntityService>().As <ICustomerEntityService>().InstancePerLifetimeScope();
builder.RegisterType <OrderChargeEntityService>().As <IOrderChargeEntityService>().InstancePerLifetimeScope();
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
builder.RegisterType <MembersService>().As <IMembersService>().InstancePerLifetimeScope();
builder.RegisterType <LogAccountLoginService>().As <ILogAccountLoginService>().InstancePerLifetimeScope();
builder.RegisterControllers(typeof(DependencyRegistrar).Assembly);
Mapper.CreateMap <Members, MembersModel>();
Mapper.CreateMap <MembersModel, Members>();
//data context
this.RegisterPluginDataContext <PluginContext>(builder, "MembersForWeb");
//override required repository with our custom context
builder.RegisterType <EfRepository <Members> >()
.As <IRepository <Members> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("MembersForWeb"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <LogAccountLogin> >()
.As <IRepository <LogAccountLogin> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("MembersForWeb"))
.InstancePerLifetimeScope();
}
/// <summary>
/// Registers the specified builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="typeFinder">The type finder.</param>
public void Register(ContainerBuilder builder, ITypeFinder typeFinder, bool isActiveModule)
{
builder.RegisterType <SubscriptionEventQueueingService>().As <ISubscriptionEventQueueingService>().InstancePerRequest();
builder.RegisterType <MailChimpInstallationService>().AsSelf().InstancePerRequest();
builder.RegisterType <MailChimpApiService>().As <IMailChimpApiService>().InstancePerRequest();
// Register named context
builder.Register <IDbContext>(c => new MailChimpObjectContext(DataSettings.Current.DataConnectionString))
.Named <IDbContext>(MailChimpObjectContext.ALIASKEY)
.InstancePerRequest();
// Register the type
builder.Register <MailChimpObjectContext>(c => new MailChimpObjectContext(DataSettings.Current.DataConnectionString))
.InstancePerRequest();
//Register repository
builder.RegisterType <EfRepository <MailChimpEventQueueRecord> >()
.As <IRepository <MailChimpEventQueueRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(MailChimpObjectContext.ALIASKEY))
.InstancePerRequest();
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
const string CONTEXT = "nop_object_context_Pl_product_location";
builder.RegisterType <ProductLocationRecordService>().As <IProductLocationRecordService>().InstancePerLifetimeScope();
builder.RegisterType <ServiceAreaService>().As <IServiceAreaService>().InstancePerLifetimeScope();
//data context
this.RegisterPluginDataContext <ProductLocationObjectContext>(builder, CONTEXT);
//override required repository with our custom context
builder.RegisterType <EfRepository <ServiceAreaRecord> >()
.As <IRepository <ServiceAreaRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <ProductLocationRecord> >()
.As <IRepository <ProductLocationRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT))
.InstancePerLifetimeScope();
}
private void RegisterServices(ContainerBuilder builder)
{
// repositories
//override required repository with our custom context
builder.RegisterType <EfRepository <Auction> >()
.As <IRepository <Auction> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(AUCTIONS_CONTEXT_NAME))
.InstancePerLifetimeScope();
//override required repository with our custom context
builder.RegisterType <EfRepository <Bid> >()
.As <IRepository <Bid> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(AUCTIONS_CONTEXT_NAME))
.InstancePerLifetimeScope();
///////////////////////////////////////////////////////////////////////////////////////////////
// services
builder.RegisterType <AuctionService>().As <IAuctionService>().InstancePerLifetimeScope();
builder.RegisterType <BidService>().As <IBidService>().InstancePerLifetimeScope();
///////////////////////////////////////////////////////////////////////////////////////////////
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
builder.RegisterType <ImportantNewsService>().As <IImportantNewsService>().InstancePerLifetimeScope();
builder.RegisterType <CarouselService>().As <ICarouselService>().InstancePerLifetimeScope();
builder.RegisterControllers(typeof(DependencyRegistrar).Assembly);
//data context
this.RegisterPluginDataContext <PluginContext>(builder, "ImportantNews");
//override required repository with our custom context
builder.RegisterType <EfRepository <ImportantNewsInfo> >()
.As <IRepository <ImportantNewsInfo> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("ImportantNews"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <CarouselInfo> >()
.As <IRepository <CarouselInfo> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("ImportantNews"))
.InstancePerLifetimeScope();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <MetadataReferenceCollector>()
.As <IMetadataReferenceCollector>()
.SingleInstance();
builder.RegisterType <CSharpFeatureDiscovery>()
.Keyed <IFeatureDiscovery>(LanguageNames.CSharp)
.SingleInstance();
builder.RegisterType <VisualBasicFeatureDiscovery>()
.Keyed <IFeatureDiscovery>(LanguageNames.VisualBasic)
.SingleInstance();
builder.RegisterType <CSharpSetup>()
.As <ILanguageSetup>()
.WithParameter(ResolvedParameter.ForKeyed <IFeatureDiscovery>(LanguageNames.CSharp))
.SingleInstance();
builder.RegisterType <VisualBasicSetup>()
.As <ILanguageSetup>()
.WithParameter(ResolvedParameter.ForKeyed <IFeatureDiscovery>(LanguageNames.VisualBasic))
.SingleInstance();
builder.RegisterType <CSharpDecompiler>().As <IDecompiler>().SingleInstance();
builder.RegisterType <VisualBasicDecompiler>().As <IDecompiler>().SingleInstance();
builder.RegisterType <ILDecompiler>().As <IDecompiler>().SingleInstance();
builder.RegisterType <JitAsmDecompiler>().As <IDecompiler>().SingleInstance();
builder.RegisterInstance(new RecyclableMemoryStreamManager())
.AsSelf();
builder.RegisterType <SlowUpdate>()
.As <ISlowUpdateExtension>()
.SingleInstance();
builder.RegisterType <SetOptionsFromClient>()
.As <ISetOptionsFromClientExtension>()
.SingleInstance();
}
public void Register(ContainerBuilder builder, ITypeFinder typeFinder, Core.Configuration.NopConfig config)
{
builder.RegisterType <GalleryService>().As <IGalleryService>().InstancePerHttpRequest();
Database.SetInitializer <GalleryObjectContext>(null);
//data layer
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
//register named context
builder.Register <IDbContext>(c => new GalleryObjectContext(dataProviderSettings.DataConnectionString))
.Named <IDbContext>("nop_object_context_gallery")
.InstancePerHttpRequest();
builder.Register <GalleryObjectContext>(c => new GalleryObjectContext(dataProviderSettings.DataConnectionString))
.InstancePerHttpRequest();
}
else
{
//register named context
builder.Register <IDbContext>(c => new GalleryObjectContext(c.Resolve <DataSettings>().DataConnectionString))
.Named <IDbContext>("nop_object_context_gallery")
.InstancePerHttpRequest();
builder.Register <GalleryObjectContext>(c => new GalleryObjectContext(c.Resolve <DataSettings>().DataConnectionString))
.InstancePerHttpRequest();
}
//override required repository with our custom context
builder.RegisterType <EfRepository <Galleries> >()
.As <IRepository <Galleries> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_gallery"))
.InstancePerHttpRequest();
builder.RegisterType <EfRepository <GalleryImages> >()
.As <IRepository <GalleryImages> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_gallery"))
.InstancePerHttpRequest();
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, bool isActiveModule)
{
builder.RegisterType <ShopConnectorService>().As <IShopConnectorService>().InstancePerRequest();
builder.RegisterType <ShopConnectorImportService>().As <IShopConnectorImportService>().InstancePerRequest();
builder.Register <IDbContext>(c => new ShopConnectorObjectContext(DataSettings.Current.DataConnectionString))
.Named <IDbContext>(ShopConnectorObjectContext.ALIASKEY)
.InstancePerRequest();
builder.Register <ShopConnectorObjectContext>(c => new ShopConnectorObjectContext(DataSettings.Current.DataConnectionString))
.InstancePerRequest();
builder.RegisterType <EfRepository <ShopConnectorConnectionRecord> >()
.As <IRepository <ShopConnectorConnectionRecord> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(ShopConnectorObjectContext.ALIASKEY))
.InstancePerRequest();
builder.RegisterType <EfRepository <ShopConnectorSkuMapping> >()
.As <IRepository <ShopConnectorSkuMapping> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(ShopConnectorObjectContext.ALIASKEY))
.InstancePerRequest();
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
builder.RegisterType <PriceForSizeService>().As <IPriceForSizeService>().InstancePerLifetimeScope();
//data context
this.RegisterPluginDataContext <PriceForSizeObjectContext>(builder, CONTEXT_NAME);
//override required repository with our custom context
builder.RegisterType <EfRepository <Product_PriceForSize> >()
.As <IRepository <Product_PriceForSize> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <ProductAttributeValue_PriceForSize> >()
.As <IRepository <ProductAttributeValue_PriceForSize> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <Nop.Plugin.Widgets.PriceForSize.Services.PriceCalculationService>().As <IPriceCalculationService>().InstancePerLifetimeScope();
// builder.RegisterType<Nop.Plugin.Widgets.PriceForSize.ActionFilters.ProductActionFilter>().As<System.Web.Mvc.IFilterProvider>();
}
private void Registration_Preparing(Object sender, PreparingEventArgs e)
{
Parameter parameter = new ResolvedParameter(
(pi, c) => pi.ParameterType == typeof(DbContext),
(pi, c) =>
{
if (pi.Name.Equals("dbContextA", StringComparison.OrdinalIgnoreCase))
{
return(c.ResolveNamed <DbContext>("databaseA"));
}
else if (pi.Name.Equals("dbContextB", StringComparison.OrdinalIgnoreCase))
{
return(c.ResolveNamed <DbContext>("databaseB"));
}
else
{
throw new NotSupportedException($"DbContext not found for '{pi.Name}' parameter name");
}
});
e.Parameters = e.Parameters.Concat(new Parameter[] { parameter });
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, ProConfig config)
{
//we cache presentation models between requests
builder.RegisterType <HomeController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
builder.RegisterType <SiteController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
//builder.RegisterType<BreakdownController>()
// .WithParameter(ResolvedParameter.ForNamed<ICacheManager>("pro_cache_static"));
builder.RegisterType <PreventiveMaintenanceController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
builder.RegisterType <Reports.ReportTemplate>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
builder.RegisterType <DownloadController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
builder.RegisterType <FormulationRequestController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
builder.RegisterType <ProductController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
builder.RegisterType <RMItemController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("pro_cache_static"));
}
protected override void Load(ContainerBuilder builder)
{
var pubSubType = Configuration.GetValue <string>("pubSub:type");
if (string.IsNullOrWhiteSpace(pubSubType))
{
throw new ConfigurationException("Configure the PubSub type with 'pubSub:type'.");
}
if (string.Equals(pubSubType, "Redis", StringComparison.OrdinalIgnoreCase))
{
var configuration = Configuration.GetValue <string>("pubsub:redis:configuration");
if (string.IsNullOrWhiteSpace(configuration))
{
throw new ConfigurationException("Configure PubSub Redis configuration with 'pubSub:redis:configuration'.");
}
builder.Register(c => Singletons <IConnectionMultiplexer> .GetOrAddLazy(configuration, s => ConnectionMultiplexer.Connect(s)))
.Named <Lazy <IConnectionMultiplexer> >(RedisRegistration)
.SingleInstance();
builder.RegisterType <RedisPubSub>()
.WithParameter(ResolvedParameter.ForNamed <Lazy <IConnectionMultiplexer> >(RedisRegistration))
.As <IPubSub>()
.As <IExternalSystem>()
.SingleInstance();
}
else if (string.Equals(pubSubType, "InMemory", StringComparison.OrdinalIgnoreCase))
{
builder.RegisterType <InMemoryPubSub>()
.As <IPubSub>()
.SingleInstance();
}
else
{
throw new ConfigurationException($"Unsupported value '{pubSubType}' for 'pubSub:type', supported: Redis, InMemory.");
}
}
public void CanConstructDecoratorChainFromOpenGenericTypes()
{
var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof(ConcreteSomething <>));
var decoratedSomethingArgument = new ResolvedParameter(
(pi, c) => pi.Name == "decorated",
(pi, c) => c.Resolve(typeof(ConcreteSomething <>).MakeGenericType(
pi.ParameterType.GetGenericArguments())));
builder.RegisterGeneric(typeof(SomethingDecorator <>))
.As(typeof(ISomething <>))
.WithParameter(decoratedSomethingArgument);
var container = builder.Build();
var concrete = container.Resolve <ISomething <int> >();
Assert.IsType <SomethingDecorator <int> >(concrete);
Assert.IsType <ConcreteSomething <int> >(((SomethingDecorator <int>)concrete).Decorated);
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder
.RegisterType <ApplicationConfiguration>()
.As <IApplicationConfiguration>()
.SingleInstance();
builder.Register(
context => context
.Resolve <IApplicationProfileService>()
.LocalMachine
.RegisterDirectory(@"Configuration", ApplicationProfileDirectoryUsage.Configuration))
.Named <IApplicationProfileDirectory>(@"configuration")
.SingleInstance();
builder.Register(
context => context
.Resolve <IApplicationProfileService>()
.LocalMachine
.RegisterDirectory(@"Database", ApplicationProfileDirectoryUsage.Database))
.Named <IApplicationProfileDirectory>(@"database")
.SingleInstance();
builder.RegisterSerializableConfiguration("Core", "TestParameters", TestParameters.Serializer, TestParameters.Defaults);
builder
.RegisterType <TestParametersUser>()
.SingleInstance()
.AsSelf();
builder
.RegisterType <RootApplicationConfigurationFile>()
.As <IApplicationConfigurationFile>()
.WithParameter(ResolvedParameter.ForNamed <IApplicationProfileDirectory>(@"configuration"))
.WithParameter(new NamedParameter(@"fileName", "FaceRecognizer.cfg"))
.SingleInstance();
}
public static IServiceProvider BuildDependenciesContainer(this IServiceCollection services)
{
var builder = new ContainerBuilder();
builder.Populate(services);
builder.RegisterType <AzureMLCarsClient>().Named <IAzureMLClient>(Constants.AZURE_ML_CARS_CLIENT);
builder.RegisterType <AzureMLIrisClient>().Named <IAzureMLClient>(Constants.AZURE_ML_IRIS_CLIENT);
builder.RegisterType <CarsController>()
.WithParameter(ResolvedParameter.ForNamed <IAzureMLClient>(Constants.AZURE_ML_CARS_CLIENT));
builder.RegisterType <IrisController>()
.WithParameter(ResolvedParameter.ForNamed <IAzureMLClient>(Constants.AZURE_ML_IRIS_CLIENT));
builder.RegisterType <AzureMlHub>();
var container = builder.Build();
return(new AutofacServiceProvider(container));
}
/// <summary>
/// InjectionConstructor 和 InjectionMethod 公用的参数列表分析过程
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
private List <object> BuildMethodParametersInfoList(MethodBase method)
{
List <object> paramList = new List <object>();
foreach (ParameterInfo parameter in method.GetParameters())
{
if (parameter.IsDefined(typeof(DependencyAttribute), false))
{
DependencyAttribute dep = (DependencyAttribute)
Attribute.GetCustomAttribute(
parameter, typeof(DependencyAttribute));
ResolvedParameter p =
new ResolvedParameter(parameter.ParameterType, dep.ResolveName);
paramList.Add(p);
}
else
{
paramList.Add(parameter.ParameterType);
}
}
return(paramList);
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
builder.RegisterType <ProductCommentService>().As <IProductCommentService>().InstancePerLifetimeScope();
builder.RegisterType <ProductCommentModelFactory>().As <IProductCommentModelFactory>().InstancePerLifetimeScope();
//data context
builder.RegisterPluginDataContext <ProductCommentsObjectContext>("nop_object_context_product_comments");
//override required repository with our custom context
builder.RegisterType <EfRepository <ProductComment> >()
.As <IRepository <ProductComment> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_product_comments"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <ProductCommentHelpfulness> >()
.As <IRepository <ProductCommentHelpfulness> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_product_comments"))
.InstancePerLifetimeScope();
builder.RegisterType <HostingEnvironment>().As <IHostingEnvironment>().SingleInstance();
}
public void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
this.RegisterPluginDataContext <AmazonObjectContext>(builder, CONTEXT_NAME);
builder.RegisterType <AmazonProvider>().As <IAmazonProvider>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
.InstancePerLifetimeScope();
builder.RegisterType <CategoryAmazonService>().As <ICategoryAmazonService>().InstancePerLifetimeScope();
builder.RegisterType <AffiliateAmazonImportManager>().As <IAffiliateAmazonImportManager>().InstancePerLifetimeScope();
builder.RegisterType <AmazonService>().As <IAmazonService>().InstancePerLifetimeScope();
builder.RegisterType <ProductAmazonService>().As <IProductAmazonService>().InstancePerLifetimeScope();
//data context
//override required repository with our custom context
builder.RegisterType <EfRepository <CategoryAmazon> >()
.As <IRepository <CategoryAmazon> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
}
protected override void Load(ContainerBuilder builder)
{
//Registering PdfExporter
builder
.RegisterType <PdfStreamWrapper>()
.WithParameter("directory", FileDirectory)
.Named <IPdfStream>("pdfstream");
builder.RegisterType <PdfSportscardsTableGenerator>().As <IPdfSportscardsTableGenerator>();
builder
.RegisterType <PdfSportscardsTableExporter>()
.WithParameter(ResolvedParameter.ForNamed <IPdfStream>("pdfstream"))
.As <IPdfSportscardsTableExporter>();
builder.RegisterType <PdfSportshallsTableGenerator>().As <IPdfSportshallsTableGenerator>();
builder
.RegisterType <PdfSportshallsTableExporter>()
.WithParameter(ResolvedParameter.ForNamed <IPdfStream>("pdfstream"))
.As <IPdfSportshallsTableExporter>();
builder
.RegisterType <StreamReaderWrapper>()
.WithParameter("filePath", FilePath)
.Named <IStreamReader>("jsonreader");
builder
.RegisterType <JsonDeserializerWrapper>()
.As <IJsonDeserializer>();
builder
.RegisterType <JsonReader>()
.WithParameter(ResolvedParameter.ForNamed <IStreamReader>("jsonreader")).As <IJsonReader>();
base.Load(builder);
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
//we cache presentation models between requests
builder.RegisterType <BlogController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <CatalogController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <CountryController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <CommonController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <NewsController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <PollController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <ShoppingCartController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
builder.RegisterType <TopicController>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"));
//installation localization service
builder.RegisterType <InstallationLocalizationService>().As <IInstallationLocalizationService>().InstancePerHttpRequest();
}
public static ILanguageFinder Initialize()
{
var builder = new ContainerBuilder();
builder.RegisterType <AnyLanguageSelector>()
.Named <ILanguageFinder>("Any Lng");
builder.RegisterType <PolishLanguageSelector>()
.Named <ILanguageFinder>("Pl Lng")
.WithParameter(ResolvedParameter.ForNamed <ILanguageFinder>("Any Lng"));
builder.RegisterType <EnglishLanguageSelector>()
.Named <ILanguageFinder>("En Lng")
.WithParameter(ResolvedParameter.ForNamed <ILanguageFinder>("Pl Lng"));
builder.RegisterType <SpecifiedLanguageSelector>()
.Named <ILanguageFinder>("Spec Lng")
.WithParameter(ResolvedParameter.ForNamed <ILanguageFinder>("En Lng"));
var container = builder.Build();
return(container.ResolveNamed <ILanguageFinder>("Spec Lng"));
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
// HTTP context and other related stuff
// Register FakeHttpContext when HttpContext is not available
builder.Register(c => HttpContext.Current != null ? (new HttpContextWrapper(HttpContext.Current) as HttpContextBase) : (new FakeHttpContext("~/") as HttpContextBase))
.As <HttpContextBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Request).As <HttpRequestBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Response).As <HttpResponseBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Server).As <HttpServerUtilityBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Session).As <HttpSessionStateBase>().InstancePerLifetimeScope();
// Work Context
builder.RegisterType <WebWorkContext>().As <IWorkContext>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("rxl_cache_per_request"))
.InstancePerLifetimeScope();
// Web Helper
builder.RegisterType <WebHelper>().As <IWebHelper>().InstancePerLifetimeScope();
// Controllers
builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
// Cache Managers
builder.RegisterType <MemoryCacheManager>().As <ICacheManager>().Named <ICacheManager>("rxl_cache_static").SingleInstance();
builder.RegisterType <PerRequestCacheManager>().As <ICacheManager>().Named <ICacheManager>("rxl_cache_per_request").InstancePerLifetimeScope();
builder.RegisterType <NullCacheManager>().As <ICacheManager>().Named <ICacheManager>("rxl_cache_none").InstancePerLifetimeScope();
// Repositories & Data Managers
builder.RegisterType <RxLocalSqlDataManager>().As <IDataManager>().InstancePerLifetimeScope();
// Services
builder.RegisterType <RxLocalServiceManager>().As <IServiceManager>().InstancePerLifetimeScope();
builder.RegisterType <FormsAuthenticationService>().As <IAuthenticationService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerService>().As <ICustomerService>().InstancePerLifetimeScope();
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
//data context
this.RegisterPluginDataContext <CategoryMappingObjectContext>(builder, "nop_object_context_affiliate_categorymapping");
builder.RegisterType <CategoryMappingService>().As <ICategoryMappingService>().InstancePerLifetimeScope().WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
.InstancePerLifetimeScope();;
builder.RegisterType <ProductMappingService>().As <IProductMappingService>().InstancePerLifetimeScope();
//override required repository with our custom context
builder.RegisterType <EfRepository <CategoryMapping> >()
.As <IRepository <CategoryMapping> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_affiliate_categorymapping"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <ProductMapping> >()
.As <IRepository <ProductMapping> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("nop_object_context_affiliate_categorymapping"))
.InstancePerLifetimeScope();
//builder.RegisterType<WB_PriceCalculationService>()
// .As<IPriceCalculationService>()
// .InstancePerLifetimeScope();
}
public void Register(Autofac.ContainerBuilder builder, Core.Infrastructure.TypeFinders.ITypeFinder typeFinder)
{
#region 数据库
const string MAIN_DB = "OrderingSystem";
builder.Register(c => new OrderingSystemDbContext(MAIN_DB))
.As <IDbContext>()
.Named <IDbContext>(MAIN_DB)
.SingleInstance();
builder.RegisterGeneric(typeof(EfRepository <>))
.As(typeof(IRepository <>))
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(MAIN_DB))
.SingleInstance();
#endregion
builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(IUserBusiness))).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(typeof(UserService).Assembly)
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()).AsImplementedInterfaces();
}
public void Register(ContainerBuilder containerBuilder)
{
var jobLoggerParameter = new ResolvedParameter(
(pi, ctx) => pi.ParameterType == typeof(ILogger),
(pi, ctx) => ctx.ResolveNamed <ILogger>("JobLogger"));
var userServiceParameter = new ResolvedParameter(
(pi, ctx) => pi.ParameterType == typeof(IUserService),
(pi, ctx) => ctx.ResolveNamed <IUserService>("WithJobLogger"));
var orderBatchServiceParameter = new ResolvedParameter(
(pi, ctx) => pi.ParameterType == typeof(IOrderBatchService),
(pi, ctx) => ctx.ResolveNamed <IOrderBatchService>("WithJobLogger"));
// Loggers
containerBuilder.RegisterType <JobLogger>().Named <ILogger>("JobLogger").InstancePerLifetimeScope();
// Services with JobLogger
containerBuilder.RegisterType <UserService>().Named <IUserService>("WithJobLogger")
.WithParameter(jobLoggerParameter).InstancePerLifetimeScope();
containerBuilder.RegisterType <OrderBatchService>().Named <IOrderBatchService>("WithJobLogger")
.WithParameter(jobLoggerParameter).InstancePerLifetimeScope();
// Workers
containerBuilder.RegisterType <EmployeeInfoSyncWorker>()
.WithParameter(jobLoggerParameter)
.WithParameter(userServiceParameter)
.InstancePerLifetimeScope();
containerBuilder.RegisterType <DataUpdateWorker>()
.WithParameter(jobLoggerParameter)
.WithParameter(userServiceParameter)
.WithParameter(orderBatchServiceParameter)
.InstancePerLifetimeScope();
}
public void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
this.RegisterPluginDataContext <CarMakeObjectContext>(builder, CONTEXT_NAME);
builder.RegisterType <EfRepository <CarMakeBulkImages> >()
.As <IRepository <CarMakeBulkImages> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <CarMakeImages> >()
.As <IRepository <CarMakeImages> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <ColorHex> >()
.As <IRepository <ColorHex> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <ExtraPictureCarMake> >()
.As <IRepository <ExtraPictureCarMake> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
builder.RegisterType <OrganizationalChangeService>().As <IOrganizationalChangeService>().InstancePerLifetimeScope();
builder.RegisterType <GovernmentPurchasingService>().As <IGovernmentPurchasingService>().InstancePerLifetimeScope();
builder.RegisterControllers(typeof(DependencyRegistrar).Assembly);
//data context
this.RegisterPluginDataContext <PluginContext>(builder, "OrganizationalChange");
this.RegisterPluginDataContext <PluginContext>(builder, "GovernmentPurchasing");
this.RegisterPluginDataContext <PluginContext>(builder, "MessageCenter");
//override required repository with our custom context
builder.RegisterType <EfRepository <OrganizationalChange> >()
.As <IRepository <OrganizationalChange> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("OrganizationalChange"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <GovernmentPurchasing> >()
.As <IRepository <GovernmentPurchasing> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("GovernmentPurchasing"))
.InstancePerLifetimeScope();
builder.RegisterType <EfRepository <MessageCenter> >()
.As <IRepository <MessageCenter> >()
.WithParameter(ResolvedParameter.ForNamed <IDbContext>("MessageCenter"))
.InstancePerLifetimeScope();
}
static IEnumerable<Parameter> AddDecoratedComponentParameter(Type decoratedParameterType, IComponentRegistration decoratedComponent, IEnumerable<Parameter> configuredParameters)
{
var parameter = new ResolvedParameter(
(pi, c) => pi.ParameterType == decoratedParameterType,
(pi, c) => c.ResolveComponent(decoratedComponent, Enumerable.Empty<Parameter>()));
return new[] { parameter }.Concat(configuredParameters);
}
public static void ConfigureContainer()
{
var builder = new ContainerBuilder();
//retrieve global properties
var LDAPAuthenticationEnabled = bool.Parse(ConfigurationManager.AppSettings["LDAPAuthenticationEnabled"] ?? "false");
var dbLoggingLevel = int.Parse(ConfigurationManager.AppSettings["dbLoggingLevel"] ?? "1");
var procTooLongmSec = int.Parse(ConfigurationManager.AppSettings["procTooLongmSec"] ?? "0");
var userIdParameter = new ResolvedParameter(
(pi, ctx) => pi.ParameterType == typeof(string) && pi.Name == "userId",
(pi, ctx) =>
{
var userId = ((ClaimsIdentity)HttpContext.Current.User.Identity).FindFirstValue(ClaimTypes.Sid);
return userId ?? "NotLoggedIn";
}
);
//following Krystian's advice - file storage on FTP is discontinued
//var ftpAddress = ConfigurationManager.AppSettings["ftpAddress"] ?? "";
//var ftpUserName = ConfigurationManager.AppSettings["ftpUserName"] ?? "";
//var ftpPwd = ConfigurationManager.AppSettings["ftpPwd"] ?? "";
//var ftpIsSSL = bool.Parse(ConfigurationManager.AppSettings["ftpIsSSL"] ?? "false");
//var ftpIsPassive = bool.Parse(ConfigurationManager.AppSettings["ftpIsPassive"] ?? "true");
//var maxConnections = int.Parse(ConfigurationManager.AppSettings["maxConnections"] ?? "3");
//register DB contexts
builder.RegisterType<EFDbContext>().AsSelf().InstancePerDependency();
//register Mehdime DBContextScope
builder.RegisterType<DbContextScopeFactory>().As<IDbContextScopeFactory>().SingleInstance();
builder.RegisterType<AmbientDbContextLocator>().As<IAmbientDbContextLocator>().SingleInstance();
//register repositories
//register infrastructure
// register services
builder.RegisterType<DBLogger>().As<ILogger>()
.WithParameter("dbLogginglevel", dbLoggingLevel)
.WithParameter("procTooLongmSec", procTooLongmSec)
.InstancePerDependency();
//builder.RegisterType<DbFtpRepoService>().As<IFileRepoService>()
// .WithParameter("ftpAddress", ftpAddress).WithParameter("ftpUserName", ftpUserName)
// .WithParameter("ftpPwd", ftpPwd).WithParameter("ftpIsSSL", ftpIsSSL)
// .WithParameter("maxConnections", maxConnections).WithParameter("ftpIsPassive", ftpIsPassive)
// .InstancePerDependency();
builder.RegisterType<DBUserService>().AsSelf()
.WithParameter("ldapAuthenticationEnabled", LDAPAuthenticationEnabled).InstancePerDependency();
builder.RegisterType<PersonService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<PersonGroupService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<PersonActivityTypeService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<PersonLogEntryService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<PersonLogEntryFileService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ProjectService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ProjectEventService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<DocumentService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<DocumentTypeService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<LocationService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<LocationTypeService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<AssemblyDbService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<AssemblyLogEntryService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<AssemblyModelService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<AssemblyStatusService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<AssemblyTypeService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ComponentService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ComponentLogEntryService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ComponentModelService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ComponentStatusService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
builder.RegisterType<ComponentTypeService>().AsSelf().WithParameter(userIdParameter).InstancePerDependency();
//----Identity Setup-----
builder.RegisterType<AppUserStore>().AsImplementedInterfaces().InstancePerRequest();
builder.Register<IdentityFactoryOptions<AppUserManager>>(c => new IdentityFactoryOptions<AppUserManager>()
{
DataProtectionProvider = new Microsoft.Owin.Security.DataProtection.DpapiDataProtectionProvider("SDDB")
});
builder.RegisterType<AppUserManager>().As<IAppUserManager>().InstancePerRequest();
builder.RegisterType<AppRoleStore>().AsSelf().InstancePerRequest();
builder.Register<IdentityFactoryOptions<AppRoleManager>>(c => new IdentityFactoryOptions<AppRoleManager>()
{
DataProtectionProvider = new Microsoft.Owin.Security.DataProtection.DpapiDataProtectionProvider("SDDB")
});
builder.RegisterType<AppRoleManager>().As<IAppRoleManager>().InstancePerRequest();
// Register your MVC controllers.
builder.RegisterControllers(typeof(MvcApplication).Assembly);
//Inject Properties into custom atttributes
builder.RegisterType<DBSrvAuthAttribute>().PropertiesAutowired();
// 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());
//Enable property injection into action filters.
builder.RegisterFilterProvider();
//Register global filters.
builder.RegisterType<DBExceptionAttribute>().PropertiesAutowired().AsExceptionFilterFor<Controller>().InstancePerRequest();
// Set the dependency resolver to be Autofac.
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
/// <summary>
/// Adds a parameter with a resolved value.
/// </summary>
/// <param name="name">The name of the parameter.</param>
/// <param name="valueAccessor">A function that supplies the parameter value.</param>
/// <returns>This GlobalParameterModule instance.</returns>
public GlobalParameterModule AddParameter(string name, Func<IComponentContext, object> valueAccessor)
{
if (name == null)
throw new ArgumentNullException(
"name",
"name should not be null.");
if (name.Length == 0)
throw new ArgumentException(
"name should not be an empty string.",
"name");
if (valueAccessor == null)
throw new ArgumentNullException(
"valueAccessor",
"valueAccessor should not be null.");
const StringComparison sc = StringComparison.Ordinal;
ResolvedParameter parameter = new ResolvedParameter(
(p, c) => String.Equals(p.Name, name, sc),
(p, c) => valueAccessor(c));
this.parameters.Add(parameter);
return this;
}
