void ILocatorConfigure.Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
if (RegisterScopedHttpContext)
{
registry.Add(typeof(System.Web.HttpContextBase), _ => new System.Web.HttpContextWrapper(System.Web.HttpContext.Current), Lifecycle.Scoped);
}
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine configArgs)
{
configArgs.OnStartupComplete += () =>
{
// hack: needed for injecting func params
#if LIGHTINJECT_LOCATOR
if (registry.InternalContainer is LightInject.IServiceContainer lightInjectContainer)
{
lightInjectContainer.RegisterConstructorDependency((factory, info, runtimeArgs) => (IInjectable)(runtimeArgs[0]));
}
#elif LAMAR_LOCATOR
if (registry.InternalContainer is Lamar.Container lamarContainer)
{
lamarContainer.Configure(c =>
{
c.AddTransient((provider) =>
{
return(new System.Func <IInjectable, TestFuncCreationComplex>(
(i) => new TestFuncCreationComplex(i,
provider.GetService(typeof(IStartupConfiguration)) as IStartupConfiguration,
provider.GetService(typeof(IShutdownHandler)) as IShutdownHandler)
));
});
});
}
#endif
};
}
/// <summary>
/// Registers ILocatorConfigure modules
/// </summary>
/// <param name="registry"></param>
protected void RegisterLocatorConfigureCollection(ILocatorRegistry registry)
{
if (LocatorConfigureModuleCollection?.Count > 0)
{
foreach (var module in LocatorConfigureModuleCollection)
{
registry.Add(LocatorConfigureType, module);
}
}
}
private bool AddRegistration(Registration registration, ILocatorRegistry registry)
{
registry.Add
(
registration.ServiceType, // service
registration.ImplementationType, // implementation
lifecycle: registration.Lifecycle
);
return(true);
}
public void Configure(ILocatorRegistry locator, IStartupEngine engine)
{
_Locator = locator;
#if NETCOREAPP1_1
var mOptions = new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions()
{
CompactOnMemoryPressure = true, ExpirationScanFrequency = new System.TimeSpan(0, 0, 10)
};
locator.Add(typeof(Microsoft.Extensions.Options.IOptions <Microsoft.Extensions.Caching.Memory.MemoryCacheOptions>), new Microsoft.Extensions.Options.OptionsWrapper <Microsoft.Extensions.Caching.Memory.MemoryCacheOptions>(mOptions));
#endif
}
void ILocatorConfigure.Configure(ILocatorRegistry registry, ILocatorConfigureEngine args)
{
var scannedRegistrations = args.Configuration.AssemblyScanner.GetTypesFor(RegistrationType);
var registrations = args.Configuration.DependencySorter
.Sort <RegistrationAttribute>(scannedRegistrations.OfType <object>())
.SelectMany(ConvertNodeToRegistration)
.ToList();
args.Configuration.RegistrationsModifier?.Modify(registrations);
registrations.All(r => AddRegistration(r, registry));
args.Configuration.Environment.Items.Set <ICollection <Registration> >(registrations);
}
void ILocatorConfigure.Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
engine.OnLocatorStartupComplete += () =>
{
IEnumerable <Type> renderingTypes = engine.Configuration
.AssemblyScanner.GetTypesFor(typeof(RenderingDocumentAliasAttribute));
foreach (var rendering in renderingTypes.Where(x => !x.IsAbstract() && !x.IsInterface()))
{
registry?.Add(rendering, rendering, lifecycle: Lifecycle.Transient);
}
};
}
/// <summary>
/// Registers canned modules
/// </summary>
/// <param name="registry"></param>
/// <param name="modules"></param>
protected static void RegisterScannedModules(ILocatorRegistry registry, IEnumerable <Type> modules)
{
foreach (var module in modules)
{
if (StartupModuleType.IsAssignableFromCheck(module))
{
registry.Add(StartupModuleType, module, null, Lifecycle.Singleton);
}
if (LocatorConfigureType.IsAssignableFromCheck(module))
{
registry.Add(LocatorConfigureType, module, null, Lifecycle.Singleton);
}
}
}
/// <summary>
/// Registers IStartupModules
/// </summary>
/// <param name="registry"></param>
protected void RegisterStartupModuleCollection(ILocatorRegistry registry)
{
if (StartupModuleCollection?.Count > 0)
{
foreach (var module in StartupModuleCollection)
{
if (module.ModuleInstance is object)
{
registry.Add(StartupModuleType, module.ModuleInstance);
}
else if (module.ModuleType is object)
{
registry.Add(StartupModuleType, module.ModuleType, null, Lifecycle.Singleton);
}
}
}
}
/// <summary>
/// Assigns default instances to the locator
/// </summary>
/// <param name="registry"></param>
/// <param name="filteredModules"></param>
/// <param name="configuration"></param>
public virtual void Configure(ILocatorRegistry registry, IEnumerable <IDependencyNode> filteredModules, IStartupConfiguration configuration)
{
var modules = filteredModules.Select(x => x.Node).OfType <Type>();
RegisterScannedModules(registry, modules);
RegisterStartupModuleCollection(registry);
RegisterLocatorConfigureCollection(registry);
// add default instances
registry
.AddInstance(configuration)
.AddInstance(configuration.Environment)
.AddInstance(configuration.Logger)
.AddInstance(configuration.AssemblyScanner)
.AddInstance(configuration.DependencyFinder)
.AddInstance(configuration.DependencySorter)
.AddTransient <ITimedTask, TimedTask>();
}
void ILocatorConfigure.Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
engine.OnLocatorStartupComplete += () =>
{
IApiControllerRegistrationSetup controllerRegistrationSetup = GetApiControllerRegistrationSetup?.Invoke() ??
new ApiControllerRegistrationSetup();
if (controllerRegistrationSetup.EnableApiControllerRegistrations == true)
{
IEnumerable <Type> controllerTypes = engine.Configuration.AssemblyScanner.GetTypesFor(typeof(ApiController));
foreach (var controller in controllerTypes.Where(x => x.IsAbstract == false))
{
registry?.Add(controller, controller, lifecycle: Lifecycle.Transient);
}
}
};
}
public void Configure(ILocatorRegistry container, ILocatorConfigureEngine engine)
{
try
{
container.Add(typeof(IRemove), typeof(BaseImpl), null, Lifecycle.Singleton);
}
catch
{
RegisterException = true;
}
if (container is ILocatorRegistryWithRemove removable)
{
removable.Remove(typeof(IRemove));
SupportsServiceRemoval = true;
}
container.Add <BaseTest, BaseImpl>(lifecycle: Lifecycle.Singleton);
container.Add(typeof(IFooTwo), locator => FooTwoFactory.CreateFoo(), Lifecycle.Transient);
}
internal static void AddServicesToLocator(IServiceCollection services, ILocatorRegistry locator)
{
for (int i = 0; i < services.Count; i++)
{
var service = services[i];
var lifetime = ConvertLifeTime(service.Lifetime);
if (service.ImplementationType is object)
{
locator.Add(service.ServiceType, service.ImplementationType, lifecycle: lifetime);
}
else if (service.ImplementationFactory is object)
{
locator.Add(service.ServiceType,
l => service.ImplementationFactory(l.GetServiceProvider()),
lifetime);
}
else
{
locator.Add(service.ServiceType, service.ImplementationInstance);
}
}
}
void ILocatorConfigure.Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
// use scoped to not create many per web request, also cannot use given locator to resolve scoped items
registry.Add(typeof(UmbracoContext), locator => EnsureUmbracoContext(), Lifecycle.Scoped);
registry.Add(typeof(UmbracoHelper), locator => new UmbracoHelper(EnsureUmbracoContext()), Lifecycle.Scoped);
}
/// <summary>
/// Adds a transient lifecycle service
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <param name="registry"></param>
/// <returns></returns>
public static ILocatorRegistry AddTransient <TService, TImplementation>(this ILocatorRegistry registry) where TImplementation : TService
{
registry.Add <TService, TImplementation>(lifecycle: Lifecycle.Transient);
return(registry);
}
/// <summary>
/// Adds a transient lifecycle service
/// </summary>
/// <param name="registry"></param>
/// <param name="serviceType"></param>
/// <param name="implementationType"></param>
/// <returns></returns>
public static ILocatorRegistry AddTransient(this ILocatorRegistry registry, Type serviceType, Type implementationType)
{
registry.Add(serviceType, implementationType, lifecycle: Lifecycle.Transient);
return(registry);
}
public void Configure(ILocatorRegistry container, ILocatorConfigureEngine engine)
{
engine.OnLocatorStartupComplete += Engine_OnContainerStarted;
}
void ILocatorConfigure.Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
AddServicesToLocator(_serviceCollection, registry);
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
throw new NotImplementedException();
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
engine.OnLocatorStartupComplete += () => FiredLocator = true;
engine.OnStartupComplete += () => FiredStartup = true;
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
registry.Add <TestFoo, TestFoo>();
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine configArgs)
{
configArgs.Configuration.Environment.Items.Set <StringBuilder>(new StringBuilder());
configArgs.Configuration.Environment.Items.Get <StringBuilder>().AppendLine("Configured Item!");
}
/// <summary>
/// Adds an instance
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <param name="registry"></param>
/// <param name="instance"></param>
/// <returns></returns>
public static ILocatorRegistry AddInstance <TService>(this ILocatorRegistry registry, TService instance)
{
registry.Add(typeof(TService), instance);
return(registry);
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
Executed = true;
}
/// <summary> /// Returns typed container, only use when container type is known /// </summary> /// <typeparam name="TContainer"></typeparam> /// <param name="registry"></param> /// <returns></returns> public static TContainer GetContainer <TContainer>(this ILocatorRegistry registry) => (TContainer)registry.InternalContainer;
/// <summary>
/// Adds a singleton lifecycle service
/// </summary>
/// <param name="registry"></param>
/// <param name="serviceType"></param>
/// <param name="implementationType"></param>
/// <returns></returns>
public static ILocatorRegistry AddSingleton(this ILocatorRegistry registry, Type serviceType, Type implementationType)
{
registry.Add(serviceType, implementationType, lifecycle: Lifecycle.Singleton);
return(registry);
}
public void Configure(ILocatorRegistry registry, ILocatorConfigureEngine engine)
{
var x = DotNetStarter.ApplicationContext.Default;
}
/// <summary>
/// Adds a singleton lifecycle service
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <param name="registry"></param>
/// <returns></returns>
public static ILocatorRegistry AddSingleton <TService, TImplementation>(this ILocatorRegistry registry) where TImplementation : TService
{
registry.Add <TService, TImplementation>(lifecycle: Lifecycle.Singleton);
return(registry);
}
