public static void AddIfNot <TService, TImplement>(this IServiceCollection services, ServiceLifetime lifetime)
where TImplement : class, TService
{
Throw.IfArgumentNull(services, nameof(services));
if (!services.IsRegistered(typeof(TService)))
{
services.Add(ServiceDescriptor.Describe(typeof(TService), typeof(TImplement), lifetime));
}
}
/// <summary>
/// Adds and configures a IMultiTenantStore to the application using a factory method.
/// </summary>
/// <param name="lifetime">The service lifetime.</param>
/// <param name="factory">A delegate that will create and configure the store.</param>
/// <returns>The same MultiTenantBuilder passed into the method.</returns>
public FinbuckleMultiTenantBuilder <TTenantInfo> WithStore <TStore>(ServiceLifetime lifetime, Func <IServiceProvider, TStore> factory)
where TStore : IMultiTenantStore <TTenantInfo>
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
// Note: can't use TryAddEnumerable here because ServiceDescriptor.Describe with a factory can't set implementation type.
Services.Add(ServiceDescriptor.Describe(typeof(IMultiTenantStore <TTenantInfo>), sp => factory(sp), lifetime));
return(this);
}
/// <summary>
/// Adds and configures a IMultiTenantStrategy to the application using a factory method.
/// </summary>
/// <param name="lifetime">The service lifetime.</param>
/// <param name="factory">A delegate that will create and configure the strategy.</param>
/// <returns>The same MultiTenantBuilder passed into the method.</returns>
public FinbuckleMultiTenantBuilder <TTenantInfo> WithStrategy <TStrategy>(ServiceLifetime lifetime, Func <IServiceProvider, TStrategy> factory)
where TStrategy : IMultiTenantStrategy
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
// Potential for multiple entries per service is intended.
Services.Add(ServiceDescriptor.Describe(typeof(IMultiTenantStrategy), sp => factory(sp), lifetime));
return(this);
}
/// <summary>
/// Adds and configures a IMultiTenantStrategy to the application using a factory method.
/// </summary>
/// <param name="lifetime">The service lifetime.</param>
/// <param name="factory">A delegate that will create and configure the strategy.</param>
/// <returns>The same MultiTenantBuilder passed into the method.</returns>
public FinbuckeMultiTenantBuilder WithStrategy <TStrategy>(ServiceLifetime lifetime, Func <IServiceProvider, TStrategy> factory)
where TStrategy : IMultiTenantStrategy
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
services.TryAdd(ServiceDescriptor.Describe(typeof(IMultiTenantStrategy),
sp => new MultiTenantStrategyWrapper <TStrategy>(factory(sp), sp.GetService <ILogger <TStrategy> >()), lifetime));
return(this);
}
public static IServiceCollection AddTriggeredDbContext <TContext>(this IServiceCollection serviceCollection, Action <DbContextOptionsBuilder>?optionsAction = null, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped)
where TContext : DbContext
{
serviceCollection.TryAdd(ServiceDescriptor.Describe(
serviceType: typeof(TContext),
implementationFactory: serviceProvider => CreateContextFactory(serviceProvider, typeof(TContext)),
lifetime: contextLifetime));
serviceCollection.AddDbContext <TContext>(options => {
optionsAction?.Invoke(options);
options.UseTriggers();
}, contextLifetime, optionsLifetime);
return(serviceCollection);
}
private static void AddType(IServiceCollection services, Type type)
{
var autoBindAttribute = GetAutoBindAttributeOrNull(type);
var lifeTime = GetLifeTimeOrNull(type, autoBindAttribute);
if (lifeTime == null)
{
return;
}
foreach (var serviceType in GetDefaultExposedServices(services, type))
{
var serviceDescriptor = ServiceDescriptor.Describe(serviceType, type, lifeTime.Value);
services.Add(serviceDescriptor);
}
}
internal bool TryCreateFacadeImplementation(ServiceDescriptor descriptor, Func <IServiceProvider, object> implementationFactory, out ServiceDescriptor proxyServiceDescriptor)
{
ServiceDescriptor CreateServiceDescriptor(ServiceDescriptor x, Type type)
{
var setInstance = type.CreateInstanceSetter();
var factory = type.CreateFacadeInstanceCreator();
return(ServiceDescriptor.Describe(x.ServiceType, i =>
{
var proxy = factory(i);
setInstance(proxy, implementationFactory(i));
return proxy;
}, x.Lifetime));
}
return(TryCreateImplementation(ProxyTypes.Facade, descriptor.ServiceType, descriptor, CreateServiceDescriptor, out proxyServiceDescriptor));
}
public static bool TryCreateProxyDescriptor(Dictionary <Type, Type> defaultInterfaceImplementDict, Dictionary <Type, Type> proxyDict, ServiceDescriptor origin, out ServiceDescriptor proxy)
{
proxy = origin;
var serviceType = proxy.ServiceType.IsGenericType ? proxy.ServiceType.GetGenericTypeDefinition() : proxy.ServiceType;
if (proxy.ImplementationType == typeof(DefaultImplementAttribute) &&
defaultInterfaceImplementDict.TryGetValue(serviceType, out var implementType))
{
proxy = ServiceDescriptor.Describe(proxy.ServiceType, proxy.ServiceType.IsGenericType ? implementType.MakeGenericType(proxy.ServiceType.GetGenericArguments()) : implementType, proxy.Lifetime);
}
if (proxyDict.ContainsKey(serviceType))
{
proxy = ToImplementationServiceDescriptor(proxy, proxy.ServiceType.IsGenericType ? proxyDict[serviceType].MakeGenericType(proxy.ServiceType.GetGenericArguments()) : proxyDict[serviceType]);
}
return(proxy != origin);
}
public static IServiceCollection AddXrmFramework(this IServiceCollection serviceCollection, Action <XrmFrameworkOptionBuilder> optionsBuilderAction = null)
{
var optionsBuilder = new XrmFrameworkOptionBuilder();
optionsBuilderAction?.Invoke(optionsBuilder);
serviceCollection.TryAdd(new ServiceDescriptor(typeof(IOrganizationService), sp =>
#if NETCOREAPP
new Microsoft.PowerPlatform.Dataverse.Client.ServiceClient(optionsBuilder.ConnectionString)
#else
new Xrm.Tooling.Connector.CrmServiceClient(optionsBuilder.ConnectionString)
#endif
, ServiceLifetime.Singleton));
serviceCollection.TryAdd(new ServiceDescriptor(typeof(IServiceContext), sp =>
{
var orgService = sp.GetService <IOrganizationService>();
return(new ServiceContextBase(orgService));
}, ServiceLifetime.Singleton));
var assembly = typeof(IService).Assembly;
var serviceType = typeof(IService);
var serviceTypes = assembly.GetModules().SelectMany(m => m.GetTypes().Where(t => serviceType.IsAssignableFrom(t) && t.IsInterface)).ToList();
var serviceImplementationTypes = assembly.GetModules().SelectMany(m => m.GetTypes().Where(type => !type.IsAbstract && type.IsClass && serviceType.IsAssignableFrom(type))).ToList();
foreach (var type in serviceTypes)
{
var serviceImplementationType = serviceImplementationTypes.FirstOrDefault(t => type.IsAssignableFrom(t));
if (serviceImplementationType != null)
{
var descriptor = ServiceDescriptor.Describe(type,
(sp) =>
DynamicProxyLoggingDecorator.Decorate(type,
ActivatorUtilities.GetServiceOrCreateInstance(sp, serviceImplementationType)),
ServiceLifetime.Scoped);
serviceCollection.Add(descriptor);
}
}
return(serviceCollection);
}
public static IServiceCollection AddSciterArchivesFromAssembly(this IServiceCollection services,
Assembly assembly)
{
var attributes = assembly?.GetCustomAttributes <SciterCoreArchiveAttribute>()?.ToList();
if (attributes?.Any() == true)
{
foreach (var attribute in attributes)
{
services.Add(ServiceDescriptor.Describe(
serviceType: typeof(LazySciterArchive),
implementationFactory: provider => new LazySciterArchive(attribute.Uri, assembly,
attribute.ResourceName, attribute.InitScripts), lifetime: ServiceLifetime.Singleton));
}
}
return(services);
}
private void Setup(ServiceLifetime lifetime)
{
IServiceCollection services = new ServiceCollection();
for (int i = 0; i < 10; i++)
{
services.Add(ServiceDescriptor.Describe(typeof(A), typeof(A), lifetime));
}
services.Add(ServiceDescriptor.Describe(typeof(B), typeof(B), lifetime));
services.Add(ServiceDescriptor.Describe(typeof(C), typeof(C), lifetime));
_serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions()
{
#if INTERNAL_DI
Mode = ServiceProviderMode
#endif
}).CreateScope().ServiceProvider;
}
public static IServiceCollection DiscoverService <TService>(this IServiceCollection services, ServiceLifetime serviceLifetime = ServiceLifetime.Transient) where TService : class
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
services.Add(ServiceDescriptor.Describe(typeof(TService), ResolveService, serviceLifetime));
return(services);
object ResolveService(IServiceProvider serviceProvider)
{
var discoveryService = serviceProvider.GetRequiredService <IDiscoveryService>();
var service = discoveryService.Discover <TService>();
return(service);
}
}
public static IServiceCollection DiscoverServiceUsingAdapter <TService>(this IServiceCollection services, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
where TService : class
{
services.Add(ServiceDescriptor.Describe(typeof(TService), ResolveService, serviceLifetime));
return(services);
object ResolveService(IServiceProvider serviceProvider)
{
var discoveryService = serviceProvider.GetRequiredService <IDiscoveryService>();
var bindingFactory = serviceProvider.GetRequiredService <IBindingFactory>();
var binding = bindingFactory.Create(typeof(TService));
var service = discoveryService.Discover <TService>(binding);
return(service);
}
}
private static IServiceCollection AddHostEventHandler <THost>(this IServiceCollection services)
where THost : SciterHost
{
var hostEventHandlerAttribute =
typeof(THost).GetCustomAttributes <SciterHostEventHandlerAttribute>().FirstOrDefault();
if (hostEventHandlerAttribute == null)
{
return(services);
}
if (HostEventHandlerRegistry.Instance.TryAdd(typeof(THost),
hostEventHandlerAttribute.EventHandlerType))
{
services.Add(ServiceDescriptor.Describe(hostEventHandlerAttribute.EventHandlerType,
hostEventHandlerAttribute.EventHandlerType, ServiceLifetime.Transient));
}
return(services);
}
public static ILetsEncryptBuilder AddHttpChallengeResponse(this ILetsEncryptBuilder builder)
{
builder.Services.AddLogging();
builder.Services.AddSingleton <HttpChallenge>();
builder.Services
.AddOptions <KestrelServerOptions>()
.Configure <KestrelCertificateSelector>((options, certificateSelector) =>
{
options.ConfigureHttpsDefaults(o => o.ServerCertificateSelector = certificateSelector.Select);
});
builder.Services
.AddSingleton <DevelopmentCertificate>()
.AddSingleton(sp =>
{
var validator = sp.GetRequiredService <ICertificateValidator>();
return(new KestrelCertificateSelector(builder.Name, validator));
});
builder.Services.Add(ServiceDescriptor.Describe(
typeof(IHostedService),
sp => new StartupCertificateLoader(builder.Name, sp),
ServiceLifetime.Singleton));
builder.Services
.AddSingleton <IStartupFilter, HttpChallengeStartupFilter>();
builder.Services
.AddOptions <HttpChallengeResponseOptions>(string.Empty) // TODO: figure out how to tie it to builder.Name
.Configure <IServiceProvider>((options, sp) =>
{
options.ChallengeStore = sp.GetServices <IAcmeChallengeStore>().First(x => x is InMemoryChallengeStore);
});
builder.Services.AddSchedulerJob <AcmeRenewalJob, AcmeRenewalJobOptions>(sectionName: "LetsEncrypt");
return(builder);
}
public static IServiceCollection AddOrReplace <TContract, TImplementation>(this IServiceCollection services, ServiceLifetime lifetime, Func <IServiceProvider, TContract> factory)
where TContract : class
where TImplementation : TContract
{
var found = services.FirstOrDefault(p => p.ServiceType == typeof(TContract) && (p.ImplementationType ?? p.ImplementationFactory?.Method?.ReturnType) == typeof(TImplementation) && p.Lifetime == lifetime);
var service = ServiceDescriptor.Describe(typeof(TContract), factory, lifetime);
if (found != null)
{
var index = services.IndexOf(found);
services.RemoveAt(index);
services.Insert(index, service);
}
else
{
services.Add(service);
}
return(services);
}
public static IServiceCollection AddTriggeredDbContextPool <TContext>(this IServiceCollection serviceCollection, Action <DbContextOptionsBuilder>?optionsAction = null, int poolSize = 128)
where TContext : DbContext
{
serviceCollection.AddDbContextPool <TContext>(options => {
optionsAction?.Invoke(options);
options.UseTriggers();
}, poolSize);
var serviceDescriptor = serviceCollection.FirstOrDefault(x => x.ServiceType == typeof(TContext));
if (serviceDescriptor?.ImplementationFactory != null)
{
serviceCollection.Replace(ServiceDescriptor.Describe(
serviceType: typeof(TContext),
implementationFactory: serviceProvider => SetApplicationTriggerServiceProviderAccessor(serviceDescriptor.ImplementationFactory(serviceProvider), serviceProvider),
lifetime: ServiceLifetime.Scoped
));
}
return(serviceCollection);
}
public static IServiceCollection AddTriggeredPooledDbContextFactory <TContext>(this IServiceCollection serviceCollection, Action <DbContextOptionsBuilder>?optionsAction = null, int poolSize = 128)
where TContext : DbContext
{
serviceCollection.AddPooledDbContextFactory <TContext>(options => {
optionsAction?.Invoke(options);
options.UseTriggers();
}, poolSize);
var serviceDescriptor = serviceCollection.FirstOrDefault(x => x.ServiceType == typeof(IDbContextFactory <TContext>));
if (serviceDescriptor?.ImplementationType != null)
{
var triggeredFactoryType = typeof(TriggeredDbContextFactory <,>).MakeGenericType(typeof(TContext), serviceDescriptor.ImplementationType);
serviceCollection.TryAdd(ServiceDescriptor.Describe(
serviceType: serviceDescriptor.ImplementationType,
implementationType: serviceDescriptor.ImplementationType,
lifetime: serviceDescriptor.Lifetime
));
serviceCollection.Replace(ServiceDescriptor.Describe(
serviceType: typeof(IDbContextFactory <TContext>),
implementationFactory: serviceProvider => ActivatorUtilities.CreateInstance(serviceProvider, triggeredFactoryType, serviceProvider.GetRequiredService(serviceDescriptor.ImplementationType), serviceProvider),
lifetime: ServiceLifetime.Scoped
));
}
if (serviceDescriptor?.ImplementationFactory != null)
{
var triggeredFactoryType = typeof(TriggeredDbContextFactory <>).MakeGenericType(typeof(TContext));
serviceCollection.Replace(ServiceDescriptor.Describe(
serviceType: typeof(IDbContextFactory <TContext>),
implementationFactory: serviceProvider => ActivatorUtilities.CreateInstance(serviceProvider, triggeredFactoryType, serviceDescriptor.ImplementationFactory),
lifetime: ServiceLifetime.Scoped
));
}
return(serviceCollection);
}
private static IModelPredictionEngineBuilder <TInput, TPrediction> AddModelLoader <TInput, TPrediction, TLoader>(
this IModelPredictionEngineBuilder <TInput, TPrediction> builder,
Action <ModelLoderFileOptions>?configure = null,
ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
where TInput : class
where TPrediction : class, new()
where TLoader : ModelLoader
{
// adds model loader to DI
builder.Services.TryAdd(ServiceDescriptor.Describe(typeof(TLoader), typeof(TLoader), serviceLifetime));
// adds configuration for model file and model result file
builder.Services.Configure <ModelLoderFileOptions>(
builder.ModelName,
options =>
{
options.ModelName = builder.ModelName;
options.ModelResultFileName = $"{options.ModelName}.json";
options.ModelFileName = $"{options.ModelName}.zip";
// overrides the defaults
configure?.Invoke(options);
});
// adds model loader options to be used.
builder.Services.AddOptions <ModelLoaderOptions>(builder.ModelName)
.Configure <IServiceProvider, TLoader>(
(options, sp, loader) =>
{
var setupOptions = sp.GetRequiredService <IOptionsMonitor <ModelLoderFileOptions> >().Get(builder.ModelName);
loader.Setup(setupOptions);
options.ModalLoader = loader;
});
return(builder);
}
public static IServiceCollection AddModelLoader <TInput, TLoader>(
this IServiceCollection services,
string modelName,
Action <ModelLoderFileOptions>?configure = null,
ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
where TInput : class
where TLoader : ModelLoader
{
// adds model loader to DI
services.TryAdd(ServiceDescriptor.Describe(typeof(TLoader), typeof(TLoader), serviceLifetime));
// adds configuration for model file and model result file
services.Configure <ModelLoderFileOptions>(
modelName,
options =>
{
options.ModelName = modelName;
options.WatchForChanges = false;
options.ModelResultFileName = $"{options.ModelName}.json";
options.ModelFileName = $"{options.ModelName}.zip";
configure?.Invoke(options);
});
// adds model loader options to be used.
services.AddOptions <ModelLoaderOptions>(modelName)
.Configure <IServiceProvider, TLoader>(
(options, sp, loader) =>
{
var setupOptions = sp.GetRequiredService <IOptionsMonitor <ModelLoderFileOptions> >().Get(modelName);
loader.Setup(setupOptions);
options.ModalLoader = loader;
});
return(services);
}
public static IServiceCollection AddSourceLoader <TInput, TLoader>(
this IServiceCollection services,
string modelName,
Action <SourceLoaderFileOptions <TInput> > configure,
ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
where TInput : class
where TLoader : SourceLoader <TInput>
{
// adds source loader into DI
services.TryAdd(ServiceDescriptor.Describe(typeof(TLoader), typeof(TLoader), serviceLifetime));
// add file options configurations.
services.Configure <SourceLoaderFileOptions <TInput> >(modelName, options => configure(options));
// create source loader options
services.AddOptions <SourceLoaderOptions <TInput> >(modelName)
.Configure <IServiceProvider, TLoader>(
(options, sp, loader) =>
{
loader.Setup(sp, modelName);
options.SourceLoader = loader;
});
return(services);
}
/// <summary>
/// Adds Web Api Header Authetnication.
/// </summary>
/// <typeparam name="TApiUserStore"></typeparam>
/// <param name="services"></param>
/// <param name="configure"></param>
/// <param name="configApiUserStoreOptions"></param>
/// <returns></returns>
public static IServiceCollection AddApiKeyHeaderAuthentication <TApiUserStore>(
this IServiceCollection services,
Action <ApiKeyAuthenticationOptions> configure,
Action <ApiUserStoreOptions, IConfiguration>?configApiUserStoreOptions = default)
where TApiUserStore : IApiUserStore
{
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = ApiKeyAuthenticationOptions.DefaultScheme;
options.DefaultChallengeScheme = ApiKeyAuthenticationOptions.DefaultScheme;
}).AddApiKeyHeaderSupport(configure);
services.AddChangeTokenOptions <ApiUserStoreOptions>(
nameof(ApiUserStoreOptions),
nameof(InMemoryApiUserStore),
(o, c) => configApiUserStoreOptions?.Invoke(o, c));
services.TryAdd(ServiceDescriptor.Describe(
typeof(IApiUserStore),
typeof(TApiUserStore),
ServiceLifetime.Scoped));
return(services);
}
public static IServiceCollection AddDestinyInterface(this IServiceCollection sc, Type serviceType, ServiceLifetime lifetime = ServiceLifetime.Singleton)
{
sc.Add(ServiceDescriptor.Describe(serviceType, typeof(DefaultImplementAttribute), lifetime));
return(sc);
}
private static ServiceDescriptor CreateDecoratorDescriptor(this ServiceDescriptor innerDescriptor, Type decoratorType)
{
Func <IServiceProvider, object> factory = provider => provider.CreateInstance(decoratorType, provider.GetInstance(innerDescriptor));
return(ServiceDescriptor.Describe(innerDescriptor.ServiceType, factory, innerDescriptor.Lifetime));
}
public static IServiceCollection TryAdd(this IServiceCollection services, Type serviceType, ServiceLifetime lifetime)
{
services.TryAdd(ServiceDescriptor.Describe(serviceType, serviceType, lifetime));
return(services);
}
private static ServiceDescriptor WithFactory(this ServiceDescriptor descriptor, Func <IServiceProvider, object> factory)
{
return(ServiceDescriptor.Describe(descriptor.ServiceType, factory, descriptor.Lifetime));
}
public static IServiceCollection AddNpoiOffice(this IServiceCollection services, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton)
{
services.TryAdd(ServiceDescriptor.Describe(typeof(IOffice), typeof(NPOIOffice), serviceLifetime));
return(services);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TSourceImplementation"></typeparam>
/// <typeparam name="TDestinationImplementation"></typeparam>
/// <param name="services"></param>
/// <param name="lifetime"></param>
/// <returns></returns>
public static IServiceCollection ReplaceEnumerable <TService, TSourceImplementation, TDestinationImplementation>(this IServiceCollection services, ServiceLifetime lifetime = ServiceLifetime.Transient)
where TService : class
where TSourceImplementation : class, TService
where TDestinationImplementation : class, TService => services.ReplaceEnumerable(ServiceDescriptor.Transient <TService, TSourceImplementation>(), ServiceDescriptor.Describe(typeof(TService), typeof(TDestinationImplementation), lifetime));
public static IServiceCollection TryAdd <TService>(this IServiceCollection services, ServiceLifetime lifetime) where TService : class
{
services.TryAdd(ServiceDescriptor.Describe(typeof(TService), typeof(TService), lifetime));
return(services);
}
private static IServiceCollection Add(this IServiceCollection services, ServiceDefinition service)
{
services.Add(ServiceDescriptor.Describe(service.ServiceType, service.ImplementationType, service.Lifetime));
return(services);
}
