Added result for DI registering + updated docs

Author: JonPSmith

NetCore.AutoRegisterDi/NetCore.AutoRegisterDi.csproj

@@ -14,14 +14,14 @@
     <RepositoryType>GitHub</RepositoryType>
     <PackageTags>NetCore DependencyInjection di</PackageTags>
     <Authors>Jon P Smith</Authors>
-    <Copyright>Copyright (c) 2018 Selective Analytics Ltd.</Copyright>
+    <Copyright>Copyright (c) 2020 Selective Analytics Ltd.</Copyright>
     <Company>Selective Analytics</Company>
     <Description>Extension method to find/register classes in an assembly into Microsoft.Extensions.DependencyInjection</Description>
     <PackageReleaseNotes>
-      - New feature: IgnoreThisInterface method allows you to state that the given interface will not be registered against a class
-      - Improvement: Adds ISerializable interface base list interfaces to ignore (IDisposable is already in base ignore list)
-      - Improvement: You can use muliple have Where methods to filter
-      - Improvement: Returns a list of the classes that were registered with the DI provider (and what interfaces were ignored)
+      - New feature: IgnoreThisInterface method adds a interface to its interface ignore list.
+      - Improvement: Added ISerializable interface to the default interface ignore list (IDisposable is already in base ignore list)
+      - Improvement: You can use muliple have Where methods to filter out classes
+      - Improvement: Returns a list of the classes/interfaces registered with the DI provider (useful for debugging)
     </PackageReleaseNotes>
     <PackageIconUrl>https://raw.githubusercontent.com/JonPSmith/NetCore.AutoRegisterDi/master/AutoRegisterDiIcon128.png</PackageIconUrl>
   </PropertyGroup>

READMe.md

@@ -4,22 +4,24 @@ This [NuGet library](https://www.nuget.org/packages/NetCore.AutoRegisterDi/) con
 
 I have written a simple version of AutoFac's `RegisterAssemblyTypes` method that works directly with Microsoft's DI provider. Here are an example of me using this with ASP.NET Core.
 
-**Version 2 update**: New attributes for defining the `ServiceLifetime` of your classes, e.g. adding the `[RegisterAsScoped]` attribute to a class will mean its `ServiceLifetime` in the DI will be set to `Scoped`. *Added by Fedor Zhekov (GitHub @ZFi88)*.
+**Version 2.0.0 update**: New attributes for defining the `ServiceLifetime` of your classes, e.g. adding the `[RegisterAsScoped]` attribute to a class will mean its `ServiceLifetime` in the DI will be set to `Scoped`. *Added by Fedor Zhekov (GitHub @ZFi88)*.
 
-#### Example 1 - scan the calling assembly
+**Version 2.1.0 update**: Added ability ignore an interface, plus added `ISerializable` interface to list of ignored interfaces and outputs results so that you can check it is registering the correct things.
+
+## Example 1 - scan the calling assembly
 
 ```c#
 public void ConfigureServices(IServiceCollection services)
 {
    //... other configure code removed
 
    service.RegisterAssemblyPublicNonGenericClasses()
-     .Where(c => c.Name.EndsWith("Service"))
+     .Where(c => c.Name.EndsWith("Service"))  //optional
+     .IgnoreThisInterface<IMyInterface>()     //optional
      .AsPublicImplementedInterfaces();
 ```
 
-
-#### Example 2 - scaning multiple assemblies
+## Example 2 - scanning multiple assemblies
 
 ```c#
 public void ConfigureServices(IServiceCollection services)
@@ -34,17 +36,17 @@ public void ConfigureServices(IServiceCollection services)
    };   
 
    service.RegisterAssemblyPublicNonGenericClasses(assembliesToScan)
-     .Where(c => c.Name.EndsWith("Service"))
+     .Where(c => c.Name.EndsWith("Service"))  //optional
+     .IgnoreThisInterface<IMyInterface>()     //optional
      .AsPublicImplementedInterfaces(); 
 ```
 
-
 Licence: MIT.
 
 **See [this article](https://www.thereformedprogrammer.net/asp-net-core-fast-and-automatic-dependency-injection-setup/)
 for a bigger coverage of Microsoft DI and the use of this library in real applications.**
 
-## Why have I written this extension?
+## Why have I written this extension
 
 There are two reasons:
 
@@ -57,66 +59,114 @@ which showed the Microsoft's DI provider was much faster than AutoFac.
 I therefore implemented a similar (but not exactly the same) feature for the
 Microsoft.Extensions.DependencyInjection library.
 
+## Detailed information
 
-### Detailed information
-
-There are four parts:
+There are five parts:
 1. `RegisterAssemblyPublicNonGenericClasses`, which finds all the public classes that : 
     - Aren't abstract
     - Aren't a generic type, e.g. MyClass\<AnotherClass\>
     - Isn't nested. e.g. It won't look at classes defined inside other classes
-2. An options `Where` method, which allows you to filter the classes to be considered.
-3. The `AsPublicImplementedInterfaces` method which finds ant interfaces on a class and registers those interfaces as pointing to the class.
-4. Various attributes that you can add to your classes to tell `NetCore.AutoRegisterDi` what to do:
+2. An `Where` extension method, which allows you to filter the classes to be considered.
+3. An `IgnoreThisInterface<IMyInterface>` extension method that allows you to add an interface to be ignored. This allows you to stop a class being registered 
+4. The `AsPublicImplementedInterfaces` method which finds ant interfaces on a class and registers those interfaces as pointing to the class. It also returns a list of results that allows you check what classes have been registered with the DI provider.
+5. Various attributes that you can add to your classes to tell `NetCore.AutoRegisterDi` what to do:
    i) Set the `ServiceLifetime` of your class, e.g. `[RegisterAsSingleton]` to apply a `Singleton` lifetime to your class.
    ii) A `[DoNotAutoRegister]` attribute to stop library your class from being registered with the DI.
 
+The following sections describes each part in detail.
 
-#### 1. The `RegisterAssemblyPublicNonGenericClasses` method
+### 1. The `RegisterAssemblyPublicNonGenericClasses` method
 
 The `RegisterAssemblyPublicNonGenericClasses` method will find all the classes in
 
 1. If no assemblies are provided then it scans the assembly that called this method.
 2. You can provide one or more assemblies to be scanned. The easiest way to reference an assembly is to use something like this `Assembly.GetAssembly(typeof(MyService))`, which gets the assembly that `MyService` was defined in.
 
-I only consider classes which match ALL of the critera below:
+I only consider classes which match ALL of the criteria below:
 
 - Public access
 - Not nested, e.g. It won't look at classes defined inside other classes
 - Not Generic, e.g. MyClass\<T\>
 - Not Abstract
 
-
-#### 2. The `Where` method
+### 2. The `Where` method
 
 Pretty straightforward - you are provided with the `Type` of each class and you can filter by any of the `Type` properties etc. This allows you to do things like only registering certain classes, e.g `Where(c => c.Name.EndsWith("Service"))`
 
-*NOTE: Useful also if you want to register some classes with a different timetime scope - See next section.*
+*NOTES:*
+
+- Useful also if you want to register some classes with a different lifetime scope: See section 4.
+- You can use multiple `Where` methods. They have an `&&` effect, e.g. the following code would register all the classes other than `Class1` and `Class2`:  
+
+```c#
+service.RegisterAssemblyPublicNonGenericClasses()
+    .Where(c => c.Name != "Class1"))
+    .Where(c => c.Name != "Class2"))
+    .AsPublicImplementedInterfaces();
+```
+
+### 3. The `IgnoreThisInterface<IMyInterface>` method
+
+There are some interfaces that you don't want your classes to be registered, for instance `IDisposable` and `ISerializable` and these are already registered in NetCore.AutoRegisterDi. This means that no class will be registered against these two interfaces.
+
+You can add extra interfaces to the interface ignore list using the `IgnoreThisInterface<IMyInterface>`, e.g. the following code would add the two interfaces  `IMyInterface1` and `IMyInterface2` to the  interface ignore list.
+
+```c#
+service.RegisterAssemblyPublicNonGenericClasses()
+    .IgnoreThisInterface<IMyInterface1>()
+    .IgnoreThisInterface<IMyInterface2>()
+    .AsPublicImplementedInterfaces();
+```
 
-#### 3. The `AsPublicImplementedInterfaces` method
+### 4. The `AsPublicImplementedInterfaces` method
 
 The `AsPublicImplementedInterfaces` method finds any public, non-nested interfaces 
-(apart from `IDisposable`) that each class implements and registers each
-interface, known as *service type*, against the class, known as the *implementation type*.
-This means if you use an interface in a constructor (or other DI-enabled places)
-then the Microsoft DI resolver will provide an instance of the class that interface
+(apart from the interfaces in the interface ignore list) that each class implements and registers each interface, known as *service type*, against the class, known as the *implementation type*. This means if you use an interface in a constructor (or other DI-enabled places) then the Microsoft DI resolver will provide an instance of the class that interface
 was linked to.
+
 *See [Microsoft DI Docs](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-2.1) for more on this*.*
 
-By default it will register the classes as having a lifetime of `ServiceLifetime.Transient`,
-but there is a parameter that allows you to override that.
+#### 4a. Debugging what classes/interfaces have been registered
+
+The `AsPublicImplementedInterfaces` method returns a list of `AutoRegisteredResult` classes, which shows what classes have been registered with the DI provider. By catching this result you can quickly see what the NetCore.AutoRegisterDi library has registered. 
+
+The following code would capture the list of results
+
+```c#
+var results = service.RegisterAssemblyPublicNonGenericClasses()
+     .IgnoreThisInterface<IMyInterface>()
+     .AsPublicImplementedInterfaces();
+```
+
+If you hover of the `results` list it will show a list similar to the one below, but with you own classes/interfaces.
+
+```text
+The interface IDisposable is ignored
+The interface ISerializable is ignored
+The interface IMyInterface is ignored
+LocalScopeService : ILocalService (Scoped)
+LocalService : ILocalService (Transient)
+LocalService : IAnotherInterface (Transient)
+```
+
+##### 4b. Changing the default ServiceLifetime
+
+The default lifetime of  registered class is `ServiceLifetime.Transient`, there are two ways to change this.
+
+- Add a NetCore.AutoRegisterDi lifetime attribute to your class (see section 5).
+- You can provide a `ServiceLifetime` to the `AsPublicImplementedInterfaces` method, e.g. `AsPublicImplementedInterfaces(ServiceLifetime.Scoped)`, which will change the default lifetime to the parameter value you provide.
 
 *See this [useful article](https://joonasw.net/view/aspnet-core-di-deep-dive)
 on what lifetime (and other terms) means.*
 
-#### 4. The attributes
+### 5. The attributes
 
-Fedor Zhekov, (GitHub @ZFi88) added attributes to allow you to define the `ServiceLifetime` of your class, and also exclude your class from being registered with the DI. 
+Fedor Zhekov, (GitHub @ZFi88) added attributes to allow you to define the `ServiceLifetime` of your class, and also exclude your class from being registered with the DI.
 
 Here are the attributes that sets the `ServiceLifetime` to be used when `NetCore.AutoRegisterDi` registers your class with the DI.
 
 1. `[RegisterAsSingleton]` - Singleton lifetime.
 2. `[RegisterAsTransient]` - Transient lifetime.
 3. `[RegisterAsScoped]` - Scoped lifetime.
 
-The last attribute is `[DoNotAutoRegister]`, which stops `NetCore.AutoRegisterDi` registered that class with the DI. 
+The last attribute is `[DoNotAutoRegister]`, which stops `NetCore.AutoRegisterDi` registered that class with the DI.

Test/DifferentServices/MyException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Test.DifferentServices
+{
+    public class MyException : Exception
+    {
+        
+    }
+}

Test/TestAutoRegisterDiCallingAssembly.cs

@@ -31,11 +31,13 @@ public void TestRegisterAssemblyPublicNonGenericClasses()
                 {
                     typeof(TestAutoRegisterDiCallingAssembly),
                     typeof(TestAutoRegisterDiDifferentAssembly),
+                    typeof(TestAutoRegisterResult),
                     typeof(TestTypeExtensions),
                     typeof(ClassWithJustIDisposable),
                     typeof(ClassWithJustISerializable),
                     typeof(LocalScopeService), typeof(LocalService),
                     typeof(LocalSingletonService), typeof(LocalTransientService),
+                    typeof(MyException)
                 });
         }
 

Test/TestAutoRegisterResult.cs

@@ -6,12 +6,19 @@
 using NetCore.AutoRegisterDi;
 using Test.DifferentServices;
 using Xunit;
+using Xunit.Abstractions;
 using Xunit.Extensions.AssertExtensions;
 
 namespace Test
 {
     public class TestAutoRegisterResult
     {
+        private ITestOutputHelper _output;
+
+        public TestAutoRegisterResult(ITestOutputHelper output)
+        {
+            _output = output;
+        }
 
         [Fact]
         public void TestAsPublicImplementedInterfacesMyService()
@@ -34,6 +41,11 @@ public void TestAsPublicImplementedInterfacesMyService()
             resultsAsString.ShouldContain("LocalSingletonService : ILocalService (Singleton)");
             resultsAsString.ShouldContain("LocalTransientService : ILocalService (Transient)");
             resultsAsString.ShouldContain("LocalScopeService : ILocalService (Scoped)");
+
+            foreach (var result in resultsAsString)
+            {
+                _output.WriteLine(result);
+            }
         }
 
         [Fact]