Merge pull request #3 from ZFi88/LifeTimeAttributes

Added new features using Attributes to define if class is registered and with what ServiceLifetime

Author: JonPSmith

NetCore.AutoRegisterDi.sln

@@ -15,6 +15,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestAssembly", "TestAssembly\TestAssembly.csproj", "{2B4E7847-FFF8-472A-987D-6808B1DCE56F}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestBadAssembly", "TestBadAssembly\TestBadAssembly.csproj", "{0E090B35-D105-49C1-95BE-EDC2655D6399}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -33,6 +35,10 @@ Global
 		{2B4E7847-FFF8-472A-987D-6808B1DCE56F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2B4E7847-FFF8-472A-987D-6808B1DCE56F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2B4E7847-FFF8-472A-987D-6808B1DCE56F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

NetCore.AutoRegisterDi/Attributes/DoNotAutoRegisterAttribute.cs

@@ -0,0 +1,12 @@
+namespace NetCore.AutoRegisterDi.Attributes
+{
+    using System;
+
+    /// <summary>
+    /// Attribute for marking classes which no need to register in container 
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class DoNotAutoRegisterAttribute : Attribute
+    {
+    }
+}

NetCore.AutoRegisterDi/Attributes/RegisterAsScopedAttribute.cs

@@ -0,0 +1,12 @@
+namespace NetCore.AutoRegisterDi.Attributes
+{
+    using System;
+
+    /// <summary>
+    /// Attribute for marking classes which need to register with Scope lifetime
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class RegisterAsScopedAttribute : Attribute
+    {
+    }
+}

NetCore.AutoRegisterDi/Attributes/RegisterAsSingletonAttribute.cs

@@ -0,0 +1,12 @@
+namespace NetCore.AutoRegisterDi.Attributes
+{
+    using System;
+
+    /// <summary>
+    /// Attribute for marking classes which need to register with Singleton lifetime
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class RegisterAsSingletonAttribute : Attribute
+    {
+    }
+}

NetCore.AutoRegisterDi/Attributes/RegisterAsTransientAttribute.cs

@@ -0,0 +1,12 @@
+namespace NetCore.AutoRegisterDi.Attributes
+{
+    using System;
+
+    /// <summary>
+    /// Attribute for marking classes which need to register with Transient lifetime
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class RegisterAsTransientAttribute : Attribute
+    {
+    }
+}

NetCore.AutoRegisterDi/AutoRegisterHelpers.cs

@@ -20,13 +20,14 @@ public static class AutoRegisterHelpers
         /// <param name="services">the NET Core dependency injection service</param>
         /// <param name="assemblies">Each assembly you want scanned. If null then scans the the assembly that called the method</param>
         /// <returns></returns>
-        public static AutoRegisterData RegisterAssemblyPublicNonGenericClasses(this IServiceCollection services, params Assembly[] assemblies)
+        public static AutoRegisterData RegisterAssemblyPublicNonGenericClasses(this IServiceCollection services,
+            params Assembly[] assemblies)
         {
             if (assemblies.Length == 0)
                 assemblies = new[] {Assembly.GetCallingAssembly()};
 
             var allPublicTypes = assemblies.SelectMany(x => x.GetExportedTypes()
-                .Where(y => y.IsClass && !y.IsAbstract && !y.IsGenericType && !y.IsNested));
+                .Where(y => y.IsClass && !y.IsAbstract && !y.IsGenericType && !y.IsNested && !y.IsIgnoredType()));
             return new AutoRegisterData(services, allPublicTypes);
         }
 
@@ -48,17 +49,19 @@ public static AutoRegisterData Where(this AutoRegisterData autoRegData, Func<Typ
         /// This registers the classes against any public interfaces (other than IDisposable) implemented by the class
         /// </summary>
         /// <param name="autoRegData">AutoRegister data produced by <see cref="RegisterAssemblyPublicNonGenericClasses"/></param> method
-        /// <param name="lifetime">Allows you to define the lifetime of the service - defaults to ServiceLifetime.Transient</param>
         /// <returns></returns>
-        public static IServiceCollection AsPublicImplementedInterfaces(this AutoRegisterData autoRegData, 
-            ServiceLifetime lifetime = ServiceLifetime.Transient)
+        public static IServiceCollection AsPublicImplementedInterfaces(this AutoRegisterData autoRegData)
         {
             if (autoRegData == null) throw new ArgumentNullException(nameof(autoRegData));
-            foreach (var classType in (autoRegData.TypeFilter == null 
-                ? autoRegData.TypesToConsider 
+            foreach (var classType in (autoRegData.TypeFilter == null
+                ? autoRegData.TypesToConsider
                 : autoRegData.TypesToConsider.Where(autoRegData.TypeFilter)))
             {
+                if (classType.IsMultipleLifetime())
+                    throw new ArgumentException($"Class {classType.FullName} has multiple life time attributes");
+
                 var interfaces = classType.GetTypeInfo().ImplementedInterfaces;
+                var lifetime = classType.GetTypeLiteTime();
                 foreach (var infc in interfaces.Where(i => i != typeof(IDisposable) && i.IsPublic && !i.IsNested))
                 {
                     autoRegData.Services.Add(new ServiceDescriptor(infc, classType, lifetime));
@@ -68,4 +71,4 @@ public static IServiceCollection AsPublicImplementedInterfaces(this AutoRegister
             return autoRegData.Services;
         }
     }
-}
+}

NetCore.AutoRegisterDi/TypeExtensions.cs

@@ -0,0 +1,78 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Test")]
+
+namespace NetCore.AutoRegisterDi
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Attributes;
+    using Microsoft.Extensions.DependencyInjection;
+
+
+    /// <summary>
+    /// Extensions for <see cref="Type"/>
+    /// </summary>
+    internal static class TypeExtensions
+    {
+        /// <summary>
+        /// Check if type marked by <see cref="DoNotAutoRegisterAttribute"/>
+        /// </summary>
+        /// <param name="type">type</param>
+        public static bool IsIgnoredType(this Type type)
+        {
+            var doNotAutoRegisterAttribute = type.GetCustomAttribute<DoNotAutoRegisterAttribute>();
+            return doNotAutoRegisterAttribute != null;
+        }
+
+        /// <summary>
+        /// Check if class marked by multiple lifetime attributes
+        /// </summary>
+        /// <param name="type">type</param>
+        /// <returns></returns>
+        public static bool IsMultipleLifetime(this Type type)
+        {
+            var attributes = type.GetCustomAttributes(true)
+                .Select(x => x.GetType())
+                .ToList();
+            if (attributes.Any())
+            {
+                return new List<bool>
+                {
+                    attributes.Contains(typeof(RegisterAsTransientAttribute)),
+                    attributes.Contains(typeof(RegisterAsScopedAttribute)),
+                    attributes.Contains(typeof(RegisterAsSingletonAttribute))
+                }.Count(x => x) > 1;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns service lifetime
+        /// </summary>
+        /// <param name="type">type</param>
+        /// <returns></returns>
+        public static ServiceLifetime GetTypeLiteTime(this Type type)
+        {
+            if (type.GetCustomAttribute<RegisterAsTransientAttribute>() != null)
+            {
+                return ServiceLifetime.Transient;
+            }
+
+            if (type.GetCustomAttribute<RegisterAsScopedAttribute>() != null)
+            {
+                return ServiceLifetime.Scoped;
+            }
+
+            if (type.GetCustomAttribute<RegisterAsSingletonAttribute>() != null)
+            {
+                return ServiceLifetime.Singleton;
+            }
+
+            return ServiceLifetime.Transient;
+        }
+    }
+}

Test/Extensions.AssertExtensions/ActionAssertionsExtensions.cs

@@ -0,0 +1,22 @@
+namespace Test.Extensions.AssertExtensions
+{
+    using System;
+    using Xunit;
+
+    /// <summary>
+    /// Extensions which provide assertions to classes derived from <see cref="Action"/>.
+    /// </summary>
+    public static class ActionAssertionsExtensions
+    {
+        /// <summary>
+        /// Verifies that the action throws exception.
+        /// </summary>
+        /// <param name="action">The action to be tested</param>
+        /// <exception cref="ThrowsException">Thrown if the action is throw exception</exception>
+        public static void ShouldThrow<T>(this Action action)
+            where T : Exception
+        {
+            Assert.Throws<T>(action);
+        }
+    }
+}

Test/LocalIgnoredService.cs

@@ -0,0 +1,13 @@
+namespace Test
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [DoNotAutoRegister]
+    public class LocalIgnoredService : ILocalService
+    {
+        public bool IsPositive(int i)
+        {
+            return i > 1;
+        }
+    }
+}

Test/LocalScopeService.cs

@@ -0,0 +1,13 @@
+namespace Test
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsScoped]
+    public class LocalScopeService : ILocalService
+    {
+        public bool IsPositive(int i)
+        {
+            return i > 1;
+        }
+    }
+}