protected virtual void RegisterDependencies(ReposConfig config, IConfigOptions options) { var builder = new ContainerBuilder(); var container = builder.Build(); this._containerManager = new ContainerManager(container); //we create new instance of ContainerBuilder //because Build() or Update() method can only be called once on a ContainerBuilder. //dependencies var typeFinder = new WebAppTypeFinder(); builder = new ContainerBuilder(); if (config != null) { builder.RegisterInstance(config).As <ReposConfig>().SingleInstance(); } builder.RegisterInstance(this).As <IEngine>().SingleInstance(); builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance(); builder.Update(container); if (config != null && !config.DLLValidation) { options.Remove(enumConfigOpts.NoDLLValidation); } ReqisterDependencies.DependencyRegister(container, config, options); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register( #if DI_UNITY #else ContainerBuilder builder , IContainer Container #endif , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { // var appConfig = ConfigurationManager.OpenExeConfiguration("C:\\VSProjects\\Repos\\bin\\ReposServiceConfigures.dll"); // var local = appConfig.Sections.Cast<ConfigurationSection>().Where(s => s.SectionInformation.Name == "ServiceConfig"); var appConfig = ConfigurationManager.OpenExeConfiguration(this.GetType().Assembly.Location); //Assembly.GetExecutingAssembly().Location); var localconfig = appConfig.GetSection("ServiceConfig") as IConfigurationSectionHandler; //if (options.Contains( enumConfigOpts.RegAll)) // SetResolveNameFlag(ResolveDepName.YES); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { //we cache presentation models between requests builder .RegisterGeneric(typeof(EfRepository <>)) .As(typeof(IRepository <>)) .InstancePerLifetimeScope(); var lconfig = (ReposConfig)config; if (!Container.IsRegistered <IDbContext>()) { builder .Register <IDbContext>(c => new ReposContext(lconfig.ContextName)) .InstancePerLifetimeScope(); } builder .RegisterType <PerRequestCacheManager>() .As <ICacheManager>() .Named <ICacheManager>("repos_cache_per_request") .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 override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { if (!Container.IsRegistered<IRule>()) builder .RegisterType<DefaultDomainRule>() .As<IRule>() .InstancePerLifetimeScope(); if (!Container.IsRegistered<IDomainEdit>()) builder .RegisterType<DefaultServiceEntityEdit>() .As<IDomainEdit>() .InstancePerLifetimeScope(); if (!Container.IsRegistered<ICacheService>()) builder .RegisterType<CacheService>() .As<ICacheService>() .InstancePerLifetimeScope(); }
public string ResolveTypeName(Type t , string name = "" , string postFix = "" , IConfigOptions opts = null) { return(getResolveValue(t, name, postFix, opts)); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { ValidAssmPrefix(config); if (!Container.IsRegistered <IRule>()) { builder .RegisterType <DomainRule>() .As <IRule>() .InstancePerLifetimeScope(); } SetDependency <IEntityRule, IModelRule>( builder , Container , this .GetType() .Assembly .GetTypes() , EnumServiceTypes.Rules , options ); }
public static void DependencyRegister(dynamic container, dynamic Config, IConfigOptions options) { var typeFinder = new WebAppTypeFinder(); var drTypes = typeFinder.FindClassesOfType <IDependencyRegistrar>().AsEnumerable(); var drInstances = new List <IDependencyRegistrar>(); foreach (var drType in drTypes) { var dependency = (IDependencyRegistrar)Activator.CreateInstance(drType); dependency.IsAssemblyValid(Config); drInstances.Add(dependency); } //sort foreach (var regtype in Enum.GetValues(typeof(RegType))) { var byRegTypeInstances = drInstances .Where(w => w.RegisterType.ToString() == regtype.ToString()) .OrderBy(o => o.Order); foreach (var dr in byRegTypeInstances) { var builder = new ContainerBuilder(); if (options.Contains(enumConfigOpts.RegAll)) { dr.ResolveDependencyName = true; } dr.Register(builder, container, typeFinder, Config, options); builder.Update(container); dr.ApplyAdditionRuleToParent(byRegTypeInstances, Config, options); } } }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { if (!CallBaseResolver) { return; } var RegTypes = ResolveTypes <IBaseService>(typeFinder, options); SetDependency <IBaseService, INullResolver, INullResolver>( builder , Container , RegTypes , EnumServiceTypes.None //, "Handlers" , options ); //var services = this.GetType().Assembly.GetTypes() // .Where(t => typeof(IBaseService).IsAssignableFrom(t) // && !t.IsAbstract) // .Where(i => i.GetInterfaces() // .Any(g => g.IsGenericType // && g.GetType().GetInterfaces().Any())) // .Select(map => new // { // target = map // }); //IHttpContextAccessor builder .RegisterType <HttpContextAccessor>() .As <IHttpContextAccessor>() .AsImplementedInterfaces() .InstancePerDependency(); //ICacheService //foreach (var service in services) //{ // var serviceName = SetResolveName(service.target); // if (!Container.IsRegisteredWithName<IBaseService>(serviceName)) // builder // .RegisterType(service.target) // .Named<IBaseService>(serviceName) // .AsImplementedInterfaces() // .InstancePerDependency(); //} }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { //we cache presentation models between requests }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { base.Register(builder, Container, typeFinder, config, options); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { base.Register(builder, Container, typeFinder, config, options); //ValidAssmPrefix(config); //if (!CallBaseResolver) // return; //var RegTypes = ResolveTypes<IHandler>(typeFinder, options); //if (!Container.IsRegistered<ClientRefInfoHandler>()) // builder // .RegisterType<ClientRefInfoHandler>() // .As<IClientRefInfoHandler>() // .InstancePerLifetimeScope(); //var sup = RegTypes // .Where(w => !w.GetCustomAttributes(typeof(ServiceNoResolveAttribute), true) // .Any()).ToList<Type>(); //SetDependency<IEditFilter, INullResolver>( // builder // , Container // , sup // , EnumServiceTypes.None // , options // ); //SetDependency<IHandler, IServiceHandler, INullResolver>( // builder // , Container // , sup // , EnumServiceTypes.Handlers //, "Handlers" // , options // ); //SetDependency<IGenericHandler, INullResolver>( // builder // , Container // , sup // , EnumServiceTypes.None // , options // ); }
/// <summary> /// Determines if script generation is enabled /// </summary> /// <param name="projPath">The path of the project</param> /// <returns>True if enabled</returns> public static bool IsGenEnabledForProject(Project proj) { ThreadHelper.ThrowIfNotOnUIThread(); IConfigOptions opt = ScriptGenAssemblyCache.GetForProj(proj)?.ConfigManager.GetForProject(proj.FullName); if (opt != null && opt.Enabled) { return(true); } return(false); }
protected virtual void RegisterDependencies(ReposConfig config, IConfigOptions options) { var builder = new ContainerBuilder(); var container = builder.Build(); this._containerManager = new ContainerManager(container); //we create new instance of ContainerBuilder //because Build() or Update() method can only be called once on a ContainerBuilder. //dependencies var typeFinder = new WebAppTypeFinder(); builder = new ContainerBuilder(); builder.RegisterInstance(config).As <ReposConfig>().SingleInstance(); builder.RegisterInstance(this).As <IEngine>().SingleInstance(); builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance(); builder.Update(container); if (!config.DLLValidation) { options.Remove(enumConfigOpts.NoDLLValidation); } ReqisterDependencies.DependencyRegister(container, config, options); builder = new ContainerBuilder(); var assm = typeFinder.App.GetAssemblies().ToArray(); //set dependency resolver if (config.ResolverType == ResolverType) { builder.RegisterControllers(assm); builder.Update(container); // 10/27 somehow this broke // and had to use the full declaration System.Web.Mvc.DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); } else if (config.ResolverType == "WebWcf") { AutofacHostFactory.Container = container; } else { builder.RegisterApiControllers(assm); builder.Update(container); var webApiResolver = new AutofacWebApiDependencyResolver(container); GlobalConfiguration.Configuration.DependencyResolver = webApiResolver; } }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { if (!Container.IsRegistered <ICommonInfo>()) { builder .RegisterType <CommonInfo>() .As <ICommonInfo>() .SingleInstance(); } }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { ValidAssmPrefix(config); builder .RegisterType <TestFilterFactory>() .As <IFilterFactory>() .InstancePerLifetimeScope(); }
public Config(IConfigOptions configOptions) { string localStackHost = configOptions.LocalStackHost; string protocol = configOptions.UseSsl ? "https" : "http"; bool useLegacyPorts = configOptions.UseLegacyPorts; int edgePort = configOptions.EdgePort; int GetServicePort(int metadataPort) => useLegacyPorts ? metadataPort : edgePort; _awsServiceEndpoints = _serviceEndpointMetadata.Select(metadata => new AwsServiceEndpoint(metadata.ServiceId, metadata.CliName, metadata.Enum, GetServicePort(metadata.Port), localStackHost, metadata.GetServiceUrl(protocol, localStackHost, GetServicePort(metadata.Port)))); }
protected virtual IList<Type> ResolveTypes<TInterface>(ITypeFinder typeFinder ,IConfigOptions options) { IList<Type> RegTypes = new List<Type>(); // if (options.Contains(enumConfigOpts.RegAll)) RegTypes = typeFinder .FindClassesOfType<TInterface>() .Where(w=>!( w.IsAbstract || w.IsInterface)) .ToList(); //else // RegTypes = this.GetType() // .Assembly // .GetTypes() // .ToList<Type>(); return RegTypes; }
public void ApplyAdditionRuleToParent(IEnumerable <IDependencyRegistrar> dr , IConfigurationSectionHandler Config , IConfigOptions options) { if (CallBaseResolver == false) { foreach (var resolver in dr) { if (resolver.GetType() != this.GetType()) { if (resolver.GetType().IsAssignableFrom(this.GetType())) { ((BaseDependencyRegistrar)resolver).CallBaseResolver = false; } } } } }
protected virtual void SetDependency<TResolvingInterface, TGenericInterface> (ContainerBuilder builder , IContainer Container , IList<Type> DepTypes , EnumServiceTypes sPosfix , IConfigOptions opts ) { SetDependency<TResolvingInterface, TResolvingInterface, TGenericInterface> (builder , Container , DepTypes , sPosfix , opts ); }
public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { builder .RegisterType <PerRequestCacheManager>() .As <ICacheManager>() .Named <ICacheManager>("repos_cache_per_request") .InstancePerLifetimeScope(); builder .RegisterType <MemoryCacheManager>() .As <ICacheManager>() .Named <ICacheManager>("repos_cache_static") .SingleInstance(); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { ValidAssmPrefix(config); var RegTypes = ResolveTypes <IDomainEdit>(typeFinder, options); SetDependency <IDomainEdit, IServiceEntityEdit>( builder , Container , RegTypes , EnumServiceTypes.Edits , options ); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { var build = new ContainerBuilder(); builder .RegisterType <NewOrderCommonInfo>() .As <ICommonInfo>() .SingleInstance(); //build.Update(Container); // base.Register(builder, Container, typeFinder, config, options); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { var RegTypes = ResolveTypes <IFilter>(typeFinder, options); if (!Container.IsRegistered <IFilterFactory>()) { builder .RegisterType <FilterFactory>() .As <IFilterFactory>() .InstancePerLifetimeScope(); } if (!Container.IsRegistered <ClientConstBase>()) { builder .RegisterInstance(new ClientConstBase()) .As <ClientConstBase>() .SingleInstance(); } if (!Container.IsRegistered <IFilterConstants>()) { builder .RegisterType <FilterConstants>() .As <IFilterConstants>() .SingleInstance(); } SetDependency <IDomainActionFilter, INullResolver>( builder , Container , RegTypes , EnumServiceTypes.Filters , options ); }
/// <summary> /// Creates a config file for the given solution /// </summary> public static void CreateForProject(Project proj) { ThreadHelper.ThrowIfNotOnUIThread(); string configPath = ScriptGenAssemblyCache.GetForProj(proj)?.ConfigManager.GetConfigFilepath(proj.FullName); if (!File.Exists(configPath)) { IConfigOptions config = ScriptGenAssemblyCache.GetForProj(proj).ConfigManager.CreateNew(); FileInfo projFile = new FileInfo(proj.FullName); Uri projUri = new Uri(projFile.Directory.FullName, UriKind.Absolute); Uri fileUri = new Uri(Path.Combine(projFile.Directory.FullName, "Scripts"), UriKind.Absolute); string relative = projUri.MakeRelativeUri(fileUri).ToString(); relative = "." + relative.Substring(projFile.Directory.Name.Length); config.ServerObjectsResultFilepath = relative + "/ServerObjects.ts"; ScriptGenAssemblyCache.GetForProj(proj).ConfigManager.Save(config, configPath); } proj.ProjectItems.AddFromFile(configPath); }
/// <summary> /// Register dependencies /// </summary> /// <param name="config">Config</param> #if DI_UNITY protected virtual void RegisterDependencies(ReposConfig config, IConfigOptions options) { var container = new UnityContainer(); this._containerManager = new ContainerManager(container); //we create new instance of ContainerBuilder //because Build() or Update() method can only be called once on a ContainerBuilder. //dependencies var typeFinder = new WebAppTypeFinder(); container.RegisterInstance <IConfigurationSectionHandler>(config, new SingletonLifetimeManager()); container.RegisterInstance <IEngine>(this, new SingletonLifetimeManager()); container.RegisterInstance <ITypeFinder>(typeFinder, new SingletonLifetimeManager()); if (!config.DLLValidation) { options.Remove(enumConfigOpts.NoDLLValidation); } ReqisterDependencies.DependencyRegister(container, config, options); //set dependency resolver if (config.ResolverType == ResolverType) { var resolver = new UnityDependencyResolver(container); System.Web.Mvc.DependencyResolver.SetResolver(resolver); } else { var resolver = new UnityDependencyResolver(container); GlobalConfiguration.Configuration.DependencyResolver = resolver; } }
public string SetResolveName(Type t , string Name = "" , string postFix = "" , IConfigOptions Opts = default(IConfigOptions)) { string TypeName = t.Name; if (!ResolveDependencyName && (Opts != null && !Opts.Contains(enumConfigOpts.ForceNameResolve)) ) { return(TypeName); } if (!string.IsNullOrEmpty(Name)) { TypeName = Name; } string name; var temp = t.FullName.Split('.'); if (!string.IsNullOrEmpty(postFix)) { name = temp.First(); } else { name = string.Join(".", temp.Take(temp.Length - 1)); } var sreturn = name + "." + (string.IsNullOrEmpty(postFix) ? "" : postFix + ".") + TypeName; return(sreturn); }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { if (!Container.IsRegistered <IListFactory>()) { builder .RegisterType <DefaultListFactory>() .As <IListFactory>() .InstancePerLifetimeScope(); } if (!Container.IsRegistered <FilterKeyPair>()) { builder .RegisterType <FilterKeyPair>() .As <IFilterKeyPair>() .InstancePerLifetimeScope(); } }
/// <summary> /// Saves the config options /// </summary> /// <param name="options">The config options to save</param> /// <param name="toPath">The path to save to</param> public void Save(IConfigOptions options, string toPath) { ConfigOptions configOpts = options as ConfigOptions; ConfigParser.Save(configOpts, toPath); }
//public static void SetResolveNameFlag(ResolveDepName resolveName) //{ // if (resolveName == ResolveDepName.YES) // ResolveDepencyName = true; //} // public static string ResolveRuleName(string prefix, Type t) // { // } public static string GetResolveName(Type t , string Name = "" , EnumServiceTypes postFix = null , IConfigOptions Opts = default(IConfigOptions)) { string TypeName = t.Name; if (!string.IsNullOrEmpty(Name)) { TypeName = Name; } else if (t.IsInterface) { TypeName = TypeName.Substring(1); } //if (!ResolveDepencyName && !(Opts != null // && Opts // .Contains(enumConfigOpts.ForceNameResolve)) // ) // return TypeName; string name; var temp = t.FullName.Split('.'); if (postFix != null) { name = temp.First(); } else { name = string.Join(".", temp.Take(temp.Length - 1)); } string sreturn = string.Empty; var Typeprefix = String .Join(".", t.FullName.Split('.') .DefaultIfEmpty(".") .Take(2)); // return prefix + '.' + TypeName; //need only dll base assm name & service type name var compare = String.Join(".", name.Split('.').Take(2)); if (TypeName.Split('.').Length > 2) { sreturn = TypeName; } else if (compare.Contains(Typeprefix)) { sreturn = Typeprefix + '.' + TypeName; } else { sreturn = name + "." + (postFix == null ? "" : postFix + ".") + TypeName; } return(sreturn); }
public CommonInitialization(IConfigOptions configOptions) { _configOptions = configOptions; }
/// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> /// <param name="config">Config</param> public override void Register(ContainerBuilder builder , IContainer Container , ITypeFinder typeFinder , IConfigurationSectionHandler config , IConfigOptions options) { // ValidAssmPrefix(config); if (!CallBaseResolver) { return; } var RegTypes = new IList <Type>[] { ResolveTypes <IHandler>(typeFinder, options) , ResolveTypes <IEditFilter>(typeFinder, options) }.SelectMany(s => s) .ToList(); var sup = RegTypes .Where(w => !w.GetCustomAttributes(typeof(ServiceNoResolveAttribute), true) .Any()).ToList <Type>(); SetDependency <IEditFilter, INullResolver>( builder , Container , sup , EnumServiceTypes.None , options ); SetDependency <IHandler, IServiceHandler, INullResolver>( builder , Container , sup , EnumServiceTypes.Handlers //, "Handlers" , options ); SetDependency <IGenericHandler, INullResolver>( builder , Container , sup , EnumServiceTypes.None , options ); if (!Container.IsRegistered <IServiceHandlerFactory>()) { builder .RegisterType <ServiceHandlerFactory>() .As <IServiceHandlerFactory>() .InstancePerLifetimeScope(); } if (!Container.IsRegistered(typeof(IGenericHandler <>))) { builder .RegisterGeneric(typeof(GenericReposHandler <>)) .As(typeof(IGenericHandler <>)) .InstancePerLifetimeScope(); } if (!Container.IsRegistered <IServiceGenericHandler>()) { builder .RegisterType <GenericHandler>() .As <IServiceGenericHandler>() .InstancePerLifetimeScope(); } }