Merge pull request #602 from johelvisguzman/GH-601

GH-601 Allow IOC extension projects to scan for additional types

Author: johelvisguzman

src/DotNetToolkit.Repository.Extensions.Microsoft.DependencyInjection/ServiceCollectionExtensions.cs

@@ -6,12 +6,9 @@
     using Configuration.Options.Internal;
     using global::Microsoft.Extensions.DependencyInjection;
     using JetBrains.Annotations;
-    using Services;
     using System;
-    using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
-    using Transactions;
     using Utility;
 
     /// <summary>
@@ -75,6 +72,7 @@ public static IServiceCollection AddRepositories([NotNull] this IServiceCollecti
 
             var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
 
+            // Register scanned types
             scanResults.ForEach(scanResult =>
             {
                 foreach (var implementationType in scanResult.ImplementationTypes)
@@ -93,27 +91,7 @@ public static IServiceCollection AddRepositories([NotNull] this IServiceCollecti
                 }
             });
 
-            // Register other services
-            services.Add(new ServiceDescriptor(
-                typeof(IRepositoryFactory),
-                sp => new RepositoryFactory(sp.GetRequiredService<IRepositoryOptions>()),
-                serviceLifetime));
-
-            services.Add(new ServiceDescriptor(
-                typeof(IUnitOfWork),
-                sp => new UnitOfWork(sp.GetRequiredService<IRepositoryOptions>()),
-                serviceLifetime));
-
-            services.Add(new ServiceDescriptor(
-                typeof(IUnitOfWorkFactory),
-                sp => new UnitOfWorkFactory(sp.GetRequiredService<IRepositoryOptions>()),
-                serviceLifetime));
-
-            services.Add(new ServiceDescriptor(
-                typeof(IServiceFactory),
-                sp => new ServiceFactory(sp.GetRequiredService<IRepositoryOptions>()),
-                serviceLifetime));
-
+            // Register options services
             services.Add(new ServiceDescriptor(
                 typeof(IRepositoryOptions),
                 sp =>

src/DotNetToolkit.Repository.Extensions.Ninject/KernelExtensions.cs

@@ -68,27 +68,17 @@ public static void BindRepositories([NotNull] this IKernel kernel, [NotNull] Act
 
             var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
 
+            // Binds scanned types
             scanResults.ForEach(scanResult =>
             {
                 foreach (var implementationType in scanResult.ImplementationTypes)
                 {
-                    if (scanResult.InterfaceType == typeof(IRepositoryInterceptor))
-                    {
-                        kernel.Bind(implementationType).ToSelf();
-                        kernel.Bind(scanResult.InterfaceType).To(implementationType);
-                    }
-                    else
-                    {
-                        kernel.Bind(scanResult.InterfaceType).To(implementationType);
-                    }
+                    kernel.Bind(implementationType).ToSelf();
+                    kernel.Bind(scanResult.InterfaceType).To(implementationType);
                 }
             });
 
-            // Binds other services
-            kernel.Bind<IRepositoryFactory>().ToMethod(c => new RepositoryFactory(c.Kernel.Get<IRepositoryOptions>()));
-            kernel.Bind<IUnitOfWork>().ToMethod(c => new UnitOfWork(c.Kernel.Get<IRepositoryOptions>()));
-            kernel.Bind<IUnitOfWorkFactory>().ToMethod(c => new UnitOfWorkFactory(c.Kernel.Get<IRepositoryOptions>()));
-            kernel.Bind<IServiceFactory>().ToMethod(c => new ServiceFactory(c.Kernel.Get<IUnitOfWorkFactory>()));
+            // Binds options services
             kernel.Bind<IRepositoryOptions>().ToMethod(c =>
             {
                 var options = new RepositoryOptions(optionsBuilder.Options);

src/DotNetToolkit.Repository.Extensions.Unity/UnityContainerExtensions.cs

@@ -75,13 +75,15 @@ public static void RegisterRepositories([NotNull] this IUnityContainer container
 
             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(implementationType, implementationType);
                         container.RegisterType(scanResult.InterfaceType, implementationType, implementationType.FullName);
                     }
                     else
@@ -91,11 +93,7 @@ public static void RegisterRepositories([NotNull] this IUnityContainer container
                 }
             });
 
-            // Register other services
-            container.RegisterFactory<IRepositoryFactory>(c => new RepositoryFactory(c.Resolve<IRepositoryOptions>()), factorylifetimeManager);
-            container.RegisterFactory<IUnitOfWork>(c => new UnitOfWork(c.Resolve<IRepositoryOptions>()), factorylifetimeManager);
-            container.RegisterFactory<IUnitOfWorkFactory>(c => new UnitOfWorkFactory(c.Resolve<IRepositoryOptions>()), factorylifetimeManager);
-            container.RegisterFactory<IServiceFactory>(c => new ServiceFactory(c.Resolve<IUnitOfWorkFactory>()), factorylifetimeManager);
+            // Register options services
             container.RegisterFactory<IRepositoryOptions>(c =>
             {
                 var options = new RepositoryOptions(optionsBuilder.Options);

src/DotNetToolkit.Repository/Services/ServiceFactory.cs

@@ -1,6 +1,5 @@
 namespace DotNetToolkit.Repository.Services
 {
-    using Configuration.Options;
     using JetBrains.Annotations;
     using System;
     using Transactions;
@@ -20,18 +19,6 @@ public class ServiceFactory : IServiceFactory
 
         #region Constructors
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ServiceFactory" /> class.
-        /// </summary>
-        /// <param name="optionsAction">A builder action used to create or modify options for this service factory.</param>
-        public ServiceFactory([NotNull] Action<RepositoryOptionsBuilder> optionsAction) : this(new UnitOfWorkFactory(Guard.NotNull(optionsAction, nameof(optionsAction)))) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ServiceFactory" /> class.
-        /// </summary>
-        /// <param name="options">The service options.</param>
-        public ServiceFactory([NotNull] IRepositoryOptions options) : this(new UnitOfWorkFactory(Guard.NotNull(options, nameof(options)))) { }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ServiceFactory"/> class.
         /// </summary>

src/DotNetToolkit.Repository/Transactions/IUnitOfWork.cs

@@ -6,10 +6,49 @@
     /// Maintains business objects in-memory which have been changed (inserted, updated, or deleted) in a single transaction.
     /// Once the transaction is completed, the changes will be sent to the database in one single unit of work.
     /// </summary>
-    /// <seealso cref="IRepositoryFactory" />
     /// <seealso cref="System.IDisposable" />
-    public interface IUnitOfWork : IRepositoryFactory, IDisposable
+    public interface IUnitOfWork : IDisposable
     {
+        /// <summary>
+        /// Creates a new repository for the specified entity type.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <returns>The new repository.</returns>
+        IRepository<TEntity> Create<TEntity>() where TEntity : class;
+
+        /// <summary>
+        /// Creates a new repository for the specified entity and primary key type.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <typeparam name="TKey">The type of the key primary key value.</typeparam>
+        /// <returns>The new repository.</returns>
+        IRepository<TEntity, TKey> Create<TEntity, TKey>() where TEntity : class;
+
+        /// <summary>
+        /// Creates a new repository for the specified entity and a composite primary key type.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <typeparam name="TKey1">The type of the first part of the composite primary key.</typeparam>
+        /// <typeparam name="TKey2">The type of the second part of the composite primary key.</typeparam>
+        /// <returns>The new repository.</returns>
+        IRepository<TEntity, TKey1, TKey2> Create<TEntity, TKey1, TKey2>() where TEntity : class;
+
+        /// <summary>
+        /// Creates a new repository for the specified entity and a composite primary key type.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <typeparam name="TKey1">The type of the first part of the composite primary key.</typeparam>
+        /// <typeparam name="TKey2">The type of the second part of the composite primary key.</typeparam>
+        /// <typeparam name="TKey3">The type of the third part of the composite primary key.</typeparam>
+        /// <returns>The new repository.</returns>
+        IRepository<TEntity, TKey1, TKey2, TKey3> Create<TEntity, TKey1, TKey2, TKey3>() where TEntity : class;
+
+        /// <summary>
+        /// Creates a new repository for the specified type.
+        /// </summary>
+        /// <returns>The new repository.</returns>
+        T CreateInstance<T>() where T : class;
+
         /// <summary>
         /// Commits all changes made in this unit of work.
         /// </summary>

src/DotNetToolkit.Repository/Transactions/UnitOfWork.cs

@@ -94,37 +94,6 @@ private void Initialize([NotNull] IRepositoryOptions options)
 
         #region Implementation of IUnitOfWork
 
-        /// <summary>
-        /// Commits all changes made in this unit of work.
-        /// </summary>
-        public virtual void Commit()
-        {
-            ThrowIfDisposed();
-
-            if (_transactionManager == null)
-                throw new InvalidOperationException("The transaction has already been committed.");
-
-            _transactionManager.Commit();
-            _transactionManager = null;
-        }
-
-        #endregion
-
-        #region Implementation of IDisposable
-
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
-        /// </summary>
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        #endregion
-
-        #region Implementation of IRepositoryFactory
-
         /// <summary>
         /// Creates a new repository for the specified entity type.
         /// </summary>
@@ -191,6 +160,33 @@ public T CreateInstance<T>() where T : class
             return (T)Activator.CreateInstance(typeof(T), new object[] { _options });
         }
 
+        /// <summary>
+        /// Commits all changes made in this unit of work.
+        /// </summary>
+        public virtual void Commit()
+        {
+            ThrowIfDisposed();
+
+            if (_transactionManager == null)
+                throw new InvalidOperationException("The transaction has already been committed.");
+
+            _transactionManager.Commit();
+            _transactionManager = null;
+        }
+
+        #endregion
+
+        #region Implementation of IDisposable
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
         #endregion
 
         #region Nested Type: RepositoryContextFactory

src/DotNetToolkit.Repository/Utility/AssemblyScanner.cs

@@ -10,6 +10,7 @@
     using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
+    using Transactions;
 
     /// <summary>
     /// A helper class for scanning all repositories and interceptors from a specified assembly collection.
@@ -51,6 +52,10 @@ private AssemblyScanner([NotNull] IEnumerable<Type> types)
                 typeof(IReadOnlyRepository<,,,>),
                 typeof(IRepositoryInterceptor),
                 typeof(ILoggerProvider),
+                typeof(IRepositoryFactory),
+                typeof(IServiceFactory),
+                typeof(IUnitOfWork),
+                typeof(IUnitOfWorkFactory),
             };
         }