// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
// Passes service provide to SharpRepository
RepositoryDependencyResolver.SetDependencyResolver(app.ApplicationServices);
}
public void ResolveWithDefaultResolver()
{
RepositoryDependencyResolver.SetResolver(new RepositoryDependencyResolver.DefaultDependencyResolver());
Assert.NotNull(RepositoryDependencyResolver.Current.Resolve <ClassToResolve>());
Assert.NotNull((ClassToResolve)RepositoryDependencyResolver.Current.Resolve(typeof(ClassToResolve)));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();
app.UseRouting();
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
// Passes service provide to SharpRepository
// https://github.com/SharpRepository/SharpRepository/blob/develop/SharpRepository.Samples.Core3Mvc/Startup.cs
RepositoryDependencyResolver.SetDependencyResolver(app.ApplicationServices);
}
public void ResolveWithDelegateResolver()
{
RepositoryDependencyResolver.SetResolver(type => new ClassToResolve());
Assert.NotNull(RepositoryDependencyResolver.Current.Resolve <ClassToResolve>());
Assert.NotNull((ClassToResolve)RepositoryDependencyResolver.Current.Resolve(typeof(ClassToResolve)));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
DatabaseConfiguration.RegisterServices(services, Configuration);
RepositoryDependencyResolver.RegisterServices(services);
}
public static IServiceProvider UseSharpRepository(this IServiceCollection services, ISharpRepositoryConfiguration sharpRepoConfig, string repositoryName = null)
{
var container = new Container();
container.Configure(config =>
{
config.Scan(x =>
{
x.TheCallingAssembly();
x.AssembliesAndExecutablesFromApplicationBaseDirectory();
x.LookForRegistries();
});
config.ForRepositoriesUseSharpRepository(sharpRepoConfig, repositoryName);
config.Populate(services);
});
var resolver = container.GetInstance <IServiceProvider>();
RepositoryDependencyResolver.SetDependencyResolver(resolver);
// Finally, make sure we return an IServiceProvider. This makes
// ASP.NET use the StructureMap container to resolve its services.
return(resolver);
}
public static void RegisterServices(IServiceCollection services)
{
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
DomainDependencyResolver.RegisterServices(services);
RepositoryDependencyResolver.RegisterServices(services);
}
public void ThrowsIfDefaultResolverResolvesAbstractClasses()
{
RepositoryDependencyResolver.SetResolver(new RepositoryDependencyResolver.DefaultDependencyResolver());
var ex = Assert.Throws <InvalidOperationException>(() => RepositoryDependencyResolver.Current.Resolve <AbstractClassToResolve>());
Assert.Equal($"Unable to resolve an instance for '{typeof(AbstractClassToResolve).FullName}'. Please consider using the RepositoryDependencyResolver to use an IOC container.", ex.Message);
}
public void ThrowsIfUnitOfWorkCreateWithDefaultDependencyResolverForResolvingOptions()
{
RepositoryDependencyResolver.SetResolver(new RepositoryDependencyResolver.DefaultDependencyResolver());
var ex = Assert.Throws <InvalidOperationException>(() => new UnitOfWork());
Assert.Equal($"Unable to resolve an instance for '{typeof(IRepositoryOptions).FullName}'. Please consider using the RepositoryDependencyResolver to use an IOC container.", ex.Message);
}
public static void Register()
{
IKernel kernel = CreateNinjectKernel();
DependencyResolver.SetResolver(new NinjectDependencyResolver(kernel));
RepositoryDependencyResolver.SetDependencyResolver(
new SharpRepository.Ioc.Ninject.NinjectDependencyResolver(kernel));
}
public void Setup()
{
var dbPath = EfDataDirectoryFactory.Build();
// structure map
container = new Container(x =>
{
x.AddRegistry(new StructureMapRegistry(dbPath));
x.ForRepositoriesUseSharpRepository();
});
RepositoryDependencyResolver.SetDependencyResolver(new StructureMapRepositoryDependencyResolver(container));
}
public void Setup()
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
var options = new DbContextOptionsBuilder <TestObjectContextCore>()
.UseSqlite(connection)
.Options;
var config = new ConfigurationBuilder()
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile("appsettings.json")
.Build();
var sectionName = "sharpRepository";
IConfigurationSection sharpRepoSection = config.GetSection(sectionName);
if (sharpRepoSection == null)
{
throw new ConfigurationErrorsException("Section " + sectionName + " is not found.");
}
var sharpRepoConfig = RepositoryFactory.BuildSharpRepositoryConfiguation(sharpRepoSection);
sharpRepoConfig.DefaultRepository = "efCoreRepos";
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var dbContext = new TestObjectContextCore(options);
// structure map
container = new Container(x =>
{
x.Scan(_ => {
_.TheCallingAssembly();
_.WithDefaultConventions();
});
x.For <DbContext>()
.Use(dbContext);
x.For <TestObjectContextCore>()
.Use(dbContext);
x.For <IMemoryCache>().Use(memoryCache);
x.ForRepositoriesUseSharpRepository(sharpRepoConfig);
});
RepositoryDependencyResolver.SetDependencyResolver(new StructureMapProvider(container));
}
public void Setup()
{
var dbPath = EfDataDirectoryFactory.Build();
Database.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
// structure map
container = new Container(x =>
{
x.AddRegistry(new StructureMapRegistry(dbPath));
x.ForRepositoriesUseSharpRepository();
});
RepositoryDependencyResolver.SetDependencyResolver(new StructureMapRepositoryDependencyResolver(container));
}
private static StandardKernel CreateKernel()
{
var kernel = new StandardKernel();
kernel.BindSharpRepository();
RepositoryDependencyResolver.SetDependencyResolver(new NinjectDependencyResolver(kernel));
var connectionString = ConfigurationManager.ConnectionStrings["SolutionTemplate"].ConnectionString;
kernel.Bind <DbContext>()
.To <SolutionTemplateContext>()
.InRequestScope()
.WithConstructorArgument("connectionString", connectionString);
kernel.Bind <IWidgetService>().To <WidgetService>();
return(kernel);
}
/// <summary>
/// Configures DependencyResolver with configured SharpRepository as implementation of IRepository and ICompoundRepository instances
/// </summary>
/// <param name="sharpConfig"></param>
/// <param name="repositoryName">name of repository implementation in configuration, null tell to use default in configuration</param>
/// <param name="lifecycle">StructureMap coping of variables default is Lifecycle.Transient</param>
public static void ForRepositoriesUseSharpRepository(ISharpRepositoryConfiguration sharpConfig, string repositoryName = null, ILifecycle lifecycle = null)
{
var container = new Container(c =>
{
c.Scan(s =>
{
s.TheCallingAssembly();
s.AssembliesAndExecutablesFromApplicationBaseDirectory();
s.LookForRegistries();
});
c.ForRepositoriesUseSharpRepository(sharpConfig, repositoryName, lifecycle);
});
var dependencyResolver = new StructureMapDependencyResolver(container);
DependencyResolver.SetResolver(dependencyResolver);
GlobalConfiguration.Configuration.DependencyResolver = dependencyResolver;
RepositoryDependencyResolver.SetDependencyResolver(dependencyResolver);
}
/// <summary>
/// Adds all the repository services using the specified options builder.
/// </summary>
/// <param name="services">The service collection.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="assembliesToScan">The assemblies to scan.</param>
/// <param name="serviceLifetime">The Microsoft.Extensions.DependencyInjection.ServiceLifetime of the service.</param>
/// <returns>The same instance of the service collection which has been configured with the repositories.</returns>
/// <remarks>
/// This method will scan for repositories and interceptors from the specified assemblies collection, and will register them to the container.
/// </remarks>
public static IServiceCollection AddRepositories([NotNull] this IServiceCollection services, [NotNull] Action <RepositoryOptionsBuilder> optionsAction, [NotNull] Assembly[] assembliesToScan, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
{
Guard.NotNull(services, nameof(services));
Guard.NotNull(optionsAction, nameof(optionsAction));
Guard.NotEmpty(assembliesToScan, nameof(assembliesToScan));
var optionsBuilder = new RepositoryOptionsBuilder();
optionsAction(optionsBuilder);
var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
// Register scanned types
scanResults.ForEach(scanResult =>
{
foreach (var implementationType in scanResult.ImplementationTypes)
{
// Register as interface
services.Add(new ServiceDescriptor(
scanResult.InterfaceType,
implementationType,
serviceLifetime));
// Register as self
services.Add(new ServiceDescriptor(
implementationType,
implementationType,
serviceLifetime));
}
});
// Register options services
services.Add(new ServiceDescriptor(
typeof(IRepositoryOptions),
sp =>
{
var options = new RepositoryOptions(optionsBuilder.Options);
foreach (var interceptorType in scanResults.OfType <IRepositoryInterceptor>())
{
if (!options.Interceptors.ContainsKey(interceptorType))
{
options = options.With(interceptorType, () => (IRepositoryInterceptor)sp.GetService(interceptorType));
}
}
if (options.LoggerProvider == null)
{
var loggerProviderType = scanResults.OfType <ILoggerProvider>().FirstOrDefault();
if (loggerProviderType != null)
{
options = options.With((ILoggerProvider)sp.GetService(loggerProviderType));
}
}
if (options.CachingProvider == null)
{
var cacheProviderType = scanResults.OfType <ICacheProvider>().FirstOrDefault();
if (cacheProviderType != null)
{
options = options.With((ICacheProvider)sp.GetService(cacheProviderType));
}
}
return(options);
},
serviceLifetime));
// Register resolver
var serviceProvider = services.BuildServiceProvider();
RepositoryDependencyResolver.SetResolver(type => serviceProvider.GetService(type));
services.AddSingleton <IRepositoryDependencyResolver>(sp => RepositoryDependencyResolver.Current);
return(services);
}
/// <summary>
/// Register all the repositories services using the specified options builder.
/// </summary>
/// <param name="container">The unity container.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="assembliesToScan">The assemblies to scan.</param>
/// <param name="typelifetimeManager">The type lifetime manager for the service.</param>
/// <param name="factorylifetimeManager">The factory lifetime manager for the service.</param>
/// <remarks>
/// This method will scan for repositories and interceptors from the specified assemblies collection, and will register them to the container.
/// </remarks>
public static void RegisterRepositories([NotNull] this IUnityContainer container, [NotNull] Action <RepositoryOptionsBuilder> optionsAction, [NotNull] Assembly[] assembliesToScan, ITypeLifetimeManager typelifetimeManager = null, IFactoryLifetimeManager factorylifetimeManager = null)
{
Guard.NotNull(container, nameof(container));
Guard.NotNull(optionsAction, nameof(optionsAction));
Guard.NotEmpty(assembliesToScan, nameof(assembliesToScan));
var optionsBuilder = new RepositoryOptionsBuilder();
optionsAction(optionsBuilder);
var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
// Register scanned types
scanResults.ForEach(scanResult =>
{
foreach (var implementationType in scanResult.ImplementationTypes)
{
container.RegisterType(implementationType);
if (scanResult.InterfaceType == typeof(IRepositoryInterceptor))
{
container.RegisterType(scanResult.InterfaceType, implementationType, implementationType.FullName);
}
else
{
container.RegisterType(scanResult.InterfaceType, implementationType);
}
}
});
// Register options services
container.RegisterFactory <IRepositoryOptions>(c =>
{
var options = new RepositoryOptions(optionsBuilder.Options);
foreach (var interceptorType in scanResults.OfType <IRepositoryInterceptor>())
{
if (!options.Interceptors.ContainsKey(interceptorType))
{
options = options.With(interceptorType, () => (IRepositoryInterceptor)c.Resolve(interceptorType));
}
}
if (options.LoggerProvider == null)
{
var loggerProviderType = scanResults.OfType <ILoggerProvider>().FirstOrDefault();
if (loggerProviderType != null)
{
options = options.With((ILoggerProvider)c.Resolve(loggerProviderType));
}
}
if (options.CachingProvider == null)
{
var cacheProviderType = scanResults.OfType <ICacheProvider>().FirstOrDefault();
if (cacheProviderType != null)
{
options = options.With((ICacheProvider)c.Resolve(cacheProviderType));
}
}
return(options);
}, factorylifetimeManager);
// Register resolver
RepositoryDependencyResolver.SetResolver(type => container.Resolve(type));
container.RegisterFactory <IRepositoryDependencyResolver>(c => RepositoryDependencyResolver.Current, new ContainerControlledLifetimeManager());
}
public static void RegisterServices(IServiceCollection services)
{
CommonDependencyResolver.RegisterServices(services);
RepositoryDependencyResolver.RegisterServices(services);
}
/// <summary>
/// Register all the repositories services using the specified options builder.
/// </summary>
/// <param name="container">The unity container.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="assembliesToScan">The assemblies to scan.</param>
/// <remarks>
/// This method will scan for repositories and interceptors from the specified assemblies collection, and will register them to the container.
/// </remarks>
public static void RegisterRepositories([NotNull] this IUnityContainer container, [NotNull] Action<RepositoryOptionsBuilder> optionsAction, [NotNull] params Assembly[] assembliesToScan)
{
Guard.NotNull(container, nameof(container));
Guard.NotNull(optionsAction, nameof(optionsAction));
Guard.NotEmpty(assembliesToScan, nameof(assembliesToScan));
var baseAssembly = Assembly.Load("DotNetToolkit.Repository");
var assToScan = !assembliesToScan.Any(x => x.FullName.Equals(baseAssembly.FullName))
? assembliesToScan.Concat(new[] { baseAssembly })
: assembliesToScan;
var types = assToScan.SelectMany(x => x.GetAccessibleTypes());
var interfaceTypesToScan = new[]
{
typeof(IService<>),
typeof(IService<,>),
typeof(IService<,,>),
typeof(IService<,,,>),
typeof(IRepository<>),
typeof(IRepository<,>),
typeof(IRepository<,,>),
typeof(IRepository<,,,>),
typeof(IReadOnlyService<>),
typeof(IReadOnlyService<,>),
typeof(IReadOnlyService<,,>),
typeof(IReadOnlyService<,,,>),
typeof(IReadOnlyRepository<>),
typeof(IReadOnlyRepository<,>),
typeof(IReadOnlyRepository<,,>),
typeof(IReadOnlyRepository<,,,>),
typeof(IRepositoryInterceptor)
};
// Gets all the interfaces that inherent from IRepository<> or IRepositoryInterceptor
var interfaceTypes = interfaceTypesToScan
.SelectMany(interfaceType => types.Where(t => !t.IsClass && t.ImplementsInterface(interfaceType)))
.Distinct();
var serviceTypesMapping = interfaceTypes
.SelectMany(interfaceType => types.Where(t => t.IsClass && !t.IsAbstract && t.ImplementsInterface(interfaceType))
.GroupBy(t => interfaceType, t => t));
// Register the repositories and interceptors that have been scanned
var optionsBuilder = new RepositoryOptionsBuilder();
optionsAction(optionsBuilder);
var registeredInterceptorTypes = new List<Type>();
foreach (var t in serviceTypesMapping)
{
var serviceType = t.Key;
var implementationTypes = t.Where(x => x.IsGenericType == serviceType.IsGenericType &&
x.GetGenericArguments().Length == serviceType.GetGenericArguments().Length &&
x.IsVisible && !x.IsAbstract);
foreach (var implementationType in implementationTypes)
{
if (serviceType == typeof(IRepositoryInterceptor))
{
if (container.IsRegistered(implementationType) || optionsBuilder.Options.Interceptors.ContainsKey(implementationType))
continue;
container.RegisterType(implementationType, implementationType);
container.RegisterType(serviceType, implementationType, implementationType.FullName);
registeredInterceptorTypes.Add(implementationType);
}
else
{
container.RegisterType(serviceType, implementationType);
}
}
}
// Register other services
container.RegisterFactory<IRepositoryFactory>(c => new RepositoryFactory(c.Resolve<IRepositoryOptions>()));
container.RegisterFactory<IUnitOfWork>(c => new UnitOfWork(c.Resolve<IRepositoryOptions>()));
container.RegisterFactory<IUnitOfWorkFactory>(c => new UnitOfWorkFactory(c.Resolve<IRepositoryOptions>()));
container.RegisterFactory<IServiceFactory>(c => new ServiceFactory(c.Resolve<IUnitOfWorkFactory>()));
container.RegisterFactory<IRepositoryOptions>(c =>
{
var options = new RepositoryOptions(optionsBuilder.Options);
foreach (var interceptorType in registeredInterceptorTypes)
{
options = options.With(interceptorType, () => (IRepositoryInterceptor)c.Resolve(interceptorType));
}
return options;
});
// Register resolver
RepositoryDependencyResolver.SetResolver(type => container.Resolve(type));
container.RegisterFactory<IRepositoryDependencyResolver>(c => RepositoryDependencyResolver.Current);
}
/// <summary>
/// Binds all the repositories services using the specified options builder.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="assembliesToScan">The assemblies to scan.</param>
/// <remarks>
/// This method will scan for repositories and interceptors from the specified assemblies collection, and will bind them to the container.
/// </remarks>
public static void BindRepositories([NotNull] this IKernel kernel, [NotNull] Action <RepositoryOptionsBuilder> optionsAction, [NotNull] params Assembly[] assembliesToScan)
{
Guard.NotNull(kernel, nameof(kernel));
Guard.NotNull(optionsAction, nameof(optionsAction));
Guard.NotEmpty(assembliesToScan, nameof(assembliesToScan));
var optionsBuilder = new RepositoryOptionsBuilder();
optionsAction(optionsBuilder);
var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
// Binds scanned types
scanResults.ForEach(scanResult =>
{
foreach (var implementationType in scanResult.ImplementationTypes)
{
kernel.Bind(implementationType).ToSelf();
kernel.Bind(scanResult.InterfaceType).To(implementationType);
}
});
// Binds options services
kernel.Bind <IRepositoryOptions>().ToMethod(c =>
{
var options = new RepositoryOptions(optionsBuilder.Options);
foreach (var interceptorType in scanResults.OfType <IRepositoryInterceptor>())
{
if (!options.Interceptors.ContainsKey(interceptorType))
{
options = options.With(interceptorType, () => (IRepositoryInterceptor)c.Kernel.Get(interceptorType));
}
}
if (options.LoggerProvider == null)
{
var loggerProviderType = scanResults.OfType <ILoggerProvider>().FirstOrDefault();
if (loggerProviderType != null)
{
options = options.With((ILoggerProvider)c.Kernel.Get(loggerProviderType));
}
}
if (options.CachingProvider == null)
{
var cacheProviderType = scanResults.OfType <ICacheProvider>().FirstOrDefault();
if (cacheProviderType != null)
{
options = options.With((ICacheProvider)c.Kernel.Get(cacheProviderType));
}
}
return(options);
});
// Binds resolver
RepositoryDependencyResolver.SetResolver(type => kernel.Get(type));
kernel.Bind <IRepositoryDependencyResolver>().ToMethod(c => RepositoryDependencyResolver.Current);
}
public void SetCurrentResolver()
{
RepositoryDependencyResolver.SetResolver(new RepositoryDependencyResolver.DefaultDependencyResolver());
Assert.Equal(typeof(RepositoryDependencyResolver.DefaultDependencyResolver), RepositoryDependencyResolver.Current.GetType());
}
