enable <GenerateDocumentationFile> and add most of the missing docume…

…ntation (2)

src/PipelineNet.ServiceProvider/MiddlewareResolver/ActivatorUtilitiesMiddlewareResolver.cs

@@ -12,12 +12,17 @@ public class ActivatorUtilitiesMiddlewareResolver : IMiddlewareResolver
     {
         private readonly IServiceProvider _serviceProvider;
 
+        /// <summary>
+        /// Creates a new <see cref="ServiceProviderMiddlewareResolver"/>.
+        /// </summary>
+        /// <param name="serviceProvider">The service provider.</param>
         public ActivatorUtilitiesMiddlewareResolver(IServiceProvider serviceProvider)
         {
             _serviceProvider = serviceProvider ?? throw new ArgumentNullException("serviceProvider",
                 "An instance of IServiceProvider must be provided."); ;
         }
 
+        /// <inheritdoc/>
         public MiddlewareResolverResult Resolve(Type type)
         {
             var middleware = ActivatorUtilities.CreateInstance(_serviceProvider, type);

src/PipelineNet.ServiceProvider/MiddlewareResolver/ServiceProviderMiddlewareResolver.cs

@@ -12,12 +12,17 @@ public class ServiceProviderMiddlewareResolver : IMiddlewareResolver
     {
         private readonly IServiceProvider _serviceProvider;
 
+        /// <summary>
+        /// Creates a new <see cref="ServiceProviderMiddlewareResolver"/>.
+        /// </summary>
+        /// <param name="serviceProvider">The service provider.</param>
         public ServiceProviderMiddlewareResolver(IServiceProvider serviceProvider)
         {
             _serviceProvider = serviceProvider ?? throw new ArgumentNullException("serviceProvider",
                 "An instance of IServiceProvider must be provided."); ;
         }
 
+        /// <inheritdoc/>
         public MiddlewareResolverResult Resolve(Type type)
         {
             var middleware = _serviceProvider.GetRequiredService(type);

src/PipelineNet.Tests/ChainsOfResponsibility/AsyncResponsibilityChainTests.cs

@@ -172,15 +172,14 @@ public void Chain_AddTypeThatIsNotAMiddleware_ThrowsException()
         /// Try to generate a deadlock in synchronous middleware.
         /// </summary>
         [Fact]
-        public void Execute_SynchronousChainOfResponsibility_SuccessfullyExecute()
+        public async Task Execute_SynchronousChainOfResponsibility_SuccessfullyExecute()
         {
             var responsibilityChain = new AsyncResponsibilityChain<string, string>(new ActivatorMiddlewareResolver())
                 .Chain<SyncReplaceNewLineMiddleware>()
                 .Chain<SyncTrimMiddleware>()
                 .Finally(input => Task.FromResult(input));
 
-            var resultTask = responsibilityChain.Execute("  Test\nwith spaces\n and new lines \n ");
-            var result = resultTask.Result;
+            var result = await responsibilityChain.Execute("  Test\nwith spaces\n and new lines \n ");
 
             Assert.Equal("Test with spaces  and new lines", result);
         }

src/PipelineNet.Tests/Pipelines/AsyncPipelineTests.cs

@@ -123,7 +123,7 @@ public async Task Execute_RunSamePipelineTwice_SuccessfullyExecute()
                 Gender = Gender.Other
             };
 
-            pipeline.Execute(personModel);
+            await pipeline.Execute(personModel);
 
             // Check if the level of 'personModel' is 4, which is configured by 'PersonWithGenderProperty' middleware.
             Assert.Equal(4, personModel.Level);

src/PipelineNet/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs

@@ -4,17 +4,23 @@
 
 namespace PipelineNet.PipelineFactories
 {
+    /// <inheritdoc/>
     public class AsyncResponsibilityChainFactory<TParameter, TReturn>
         : IAsyncResponsibilityChainFactory<TParameter, TReturn>
     {
         private readonly IMiddlewareResolver _middlewareResolver;
 
+        /// <summary>
+        /// Creates a new asynchronous chain of responsibility factory.
+        /// </summary>
+        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
         public AsyncResponsibilityChainFactory(IMiddlewareResolver middlewareResolver)
         {
             _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
                 "An instance of IMiddlewareResolver must be provided.");
         }
 
+        /// <inheritdoc/>
         public IAsyncResponsibilityChain<TParameter, TReturn> Create() =>
             new AsyncResponsibilityChain<TParameter, TReturn>(_middlewareResolver);
     }

src/PipelineNet/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs

@@ -4,17 +4,23 @@
 
 namespace PipelineNet.PipelineFactories
 {
+    /// <inheritdoc/>
     public class ResponsibilityChainFactory<TParameter, TReturn>
         : IResponsibilityChainFactory<TParameter, TReturn>
     {
         private readonly IMiddlewareResolver _middlewareResolver;
 
+        /// <summary>
+        /// Creates a new chain of responsibility factory.
+        /// </summary>
+        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
         public ResponsibilityChainFactory(IMiddlewareResolver middlewareResolver)
         {
             _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
                 "An instance of IMiddlewareResolver must be provided.");
         }
 
+        /// <inheritdoc/>
         public IResponsibilityChain<TParameter, TReturn> Create() =>
             new ResponsibilityChain<TParameter, TReturn>(_middlewareResolver);
     }

src/PipelineNet/MiddlewareResolver/ActivatorMiddlewareResolver.cs

@@ -8,6 +8,7 @@ namespace PipelineNet.MiddlewareResolver
     /// </summary>
     public class ActivatorMiddlewareResolver : IMiddlewareResolver
     {
+        /// <inheritdoc/>
         public MiddlewareResolverResult Resolve(Type type)
         {
             var middleware = Activator.CreateInstance(type);

src/PipelineNet/PipelineFactories/AsyncPipelineFactory.cs

@@ -4,17 +4,23 @@
 
 namespace PipelineNet.PipelineFactories
 {
+    /// <inheritdoc/>
     public class AsyncPipelineFactory<TParameter>
         : IAsyncPipelineFactory<TParameter>
     {
         private readonly IMiddlewareResolver _middlewareResolver;
 
+        /// <summary>
+        /// Creates a new asynchronous pipeline factory.
+        /// </summary>
+        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
         public AsyncPipelineFactory(IMiddlewareResolver middlewareResolver)
         {
             _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
                 "An instance of IMiddlewareResolver must be provided.");
         }
 
+        /// <inheritdoc/>
         public IAsyncPipeline<TParameter> Create() =>
             new AsyncPipeline<TParameter>(_middlewareResolver);
     }

src/PipelineNet/PipelineFactories/PipelineFactory.cs

@@ -4,17 +4,23 @@
 
 namespace PipelineNet.PipelineFactories
 {
+    /// <inheritdoc/>
     public class PipelineFactory<TParameter>
         : IPipelineFactory<TParameter>
     {
         private readonly IMiddlewareResolver _middlewareResolver;
 
+        /// <summary>
+        /// Creates a new chain of responsibility factory.
+        /// </summary>
+        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
         public PipelineFactory(IMiddlewareResolver middlewareResolver)
         {
             _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
                 "An instance of IMiddlewareResolver must be provided.");
         }
 
+        /// <inheritdoc/>
         public IPipeline<TParameter> Create() =>
             new Pipeline<TParameter>(_middlewareResolver);
     }