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();
}
}
