Merge branch 'jbogard:master' into master

src/MediatR/Entities/OpenBehavior.cs

@@ -0,0 +1,20 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MediatR.Entities;
+/// <summary>
+/// Creates open behavior entity.
+/// </summary>
+public class OpenBehavior
+{
+    public OpenBehavior(Type openBehaviorType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
+    {
+        OpenBehaviorType = openBehaviorType;
+        ServiceLifetime = serviceLifetime;
+    }
+
+    public Type? OpenBehaviorType { get; } 
+    public ServiceLifetime ServiceLifetime { get; }
+
+
+}

src/MediatR/IPipelineBehavior.cs

@@ -9,7 +9,7 @@ namespace MediatR;
 /// </summary>
 /// <typeparam name="TResponse">Response type</typeparam>
 /// <returns>Awaitable task returning a <typeparamref name="TResponse"/></returns>
-public delegate Task<TResponse> RequestHandlerDelegate<TResponse>();
+public delegate Task<TResponse> RequestHandlerDelegate<TResponse>(CancellationToken t = default);
 
 /// <summary>
 /// Pipeline behavior to surround the inner handler.

src/MediatR/MicrosoftExtensionsDI/MediatrServiceConfiguration.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using MediatR;
+using MediatR.Entities;
 using MediatR.NotificationPublishers;
 using MediatR.Pipeline;
 using MediatR.Registration;
@@ -92,7 +93,7 @@ public class MediatRServiceConfiguration
     /// <summary>
     /// Flag that controlls whether MediatR will attempt to register handlers that containg generic type parameters.
     /// </summary>
-    public bool RegisterGenericHandlers { get; set; } = true;
+    public bool RegisterGenericHandlers { get; set; } = false;
 
     /// <summary>
     /// Register various handlers from assembly containing given type
@@ -222,6 +223,37 @@ public MediatRServiceConfiguration AddOpenBehavior(Type openBehaviorType, Servic
         return this;
     }
 
+    /// <summary>
+    /// Registers multiple open behavior types against the <see cref="IPipelineBehavior{TRequest,TResponse}"/> open generic interface type
+    /// </summary>
+    /// <param name="openBehaviorTypes">An open generic behavior type list includes multiple open generic behavior types.</param>
+    /// <param name="serviceLifetime">Optional service lifetime, defaults to <see cref="ServiceLifetime.Transient"/>.</param>
+    /// <returns>This</returns>
+    public MediatRServiceConfiguration AddOpenBehaviors(IEnumerable<Type> openBehaviorTypes, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
+    {
+        foreach (var openBehaviorType in openBehaviorTypes)
+        {
+            AddOpenBehavior(openBehaviorType, serviceLifetime);
+        }
+
+        return this;
+    }
+
+    /// <summary>
+    /// Registers open behaviors against the <see cref="IPipelineBehavior{TRequest,TResponse}"/> open generic interface type
+    /// </summary>
+    /// <param name="openBehaviors">An open generic behavior list includes multiple <see cref="OpenBehavior"/> open generic behaviors.</param>
+    /// <returns>This</returns>
+    public MediatRServiceConfiguration AddOpenBehaviors(IEnumerable<OpenBehavior> openBehaviors)
+    {
+        foreach (var openBehavior in openBehaviors)
+        {
+            AddOpenBehavior(openBehavior.OpenBehaviorType!, openBehavior.ServiceLifetime);
+        }
+
+        return this;
+    }
+
     /// <summary>
     /// Register a closed stream behavior type
     /// </summary>

src/MediatR/Registration/ServiceRegistrar.cs

@@ -228,10 +228,7 @@ private static (Type Service, Type Implementation) GetConcreteRegistrationTypes(
         var constraintsForEachParameter = openRequestHandlerImplementation
             .GetGenericArguments()
             .Select(x => x.GetGenericParameterConstraints())
-            .ToList();
-
-        if (constraintsForEachParameter.Count > 2 && constraintsForEachParameter.Any(constraints => !constraints.Where(x => x.IsInterface || x.IsClass).Any()))
-            throw new ArgumentException($"Error registering the generic handler type: {openRequestHandlerImplementation.FullName}. When registering generic requests with more than two type parameters, each type parameter must have at least one constraint of type interface or class.");
+            .ToList();
 
         var typesThatCanCloseForEachParameter = constraintsForEachParameter
             .Select(constraints => assembliesToScan

src/MediatR/Wrappers/RequestHandlerWrapper.cs

@@ -34,14 +34,14 @@ public class RequestHandlerWrapperImpl<TRequest, TResponse> : RequestHandlerWrap
     public override Task<TResponse> Handle(IRequest<TResponse> request, IServiceProvider serviceProvider,
         CancellationToken cancellationToken)
     {
-        Task<TResponse> Handler() => serviceProvider.GetRequiredService<IRequestHandler<TRequest, TResponse>>()
-            .Handle((TRequest) request, cancellationToken);
+        Task<TResponse> Handler(CancellationToken t = default) => serviceProvider.GetRequiredService<IRequestHandler<TRequest, TResponse>>()
+            .Handle((TRequest) request, t == default ? cancellationToken : t);
 
         return serviceProvider
             .GetServices<IPipelineBehavior<TRequest, TResponse>>()
             .Reverse()
             .Aggregate((RequestHandlerDelegate<TResponse>) Handler,
-                (next, pipeline) => () => pipeline.Handle((TRequest) request, next, cancellationToken))();
+                (next, pipeline) => (t) => pipeline.Handle((TRequest) request, next, t == default ? cancellationToken : t))();
     }
 }
 
@@ -55,10 +55,10 @@ public class RequestHandlerWrapperImpl<TRequest> : RequestHandlerWrapper
     public override Task<Unit> Handle(IRequest request, IServiceProvider serviceProvider,
         CancellationToken cancellationToken)
     {
-        async Task<Unit> Handler()
+        async Task<Unit> Handler(CancellationToken t = default)
         {
             await serviceProvider.GetRequiredService<IRequestHandler<TRequest>>()
-                .Handle((TRequest) request, cancellationToken);
+                .Handle((TRequest) request, t == default ? cancellationToken : t);
 
             return Unit.Value;
         }
@@ -67,6 +67,6 @@ await serviceProvider.GetRequiredService<IRequestHandler<TRequest>>()
             .GetServices<IPipelineBehavior<TRequest, Unit>>()
             .Reverse()
             .Aggregate((RequestHandlerDelegate<Unit>) Handler,
-                (next, pipeline) => () => pipeline.Handle((TRequest) request, next, cancellationToken))();
+                (next, pipeline) => (t) => pipeline.Handle((TRequest) request, next, t == default ? cancellationToken : t))();
     }
 }

test/MediatR.Tests/GenericRequestHandlerTests.cs

@@ -32,6 +32,7 @@ public void ShouldResolveAllCombinationsOfGenericHandler(int numberOfClasses, in
             services.AddMediatR(cfg =>
             {
                 cfg.RegisterServicesFromAssemblies(dynamicAssembly);
+                cfg.RegisterGenericHandlers = true;
             });
 
             var provider = services.BuildServiceProvider();
@@ -93,24 +94,6 @@ public void ShouldNotRegisterDuplicateHandlers(int numberOfClasses, int numberOf
             hasDuplicates.ShouldBeFalse();
         }
 
-        [Fact]
-        public void ShouldThrowExceptionWhenRegisterningHandlersWithNoConstraints()
-        {
-            IServiceCollection services = new ServiceCollection();
-            services.AddSingleton(new Logger());
-
-            var assembly = GenerateMissingConstraintsAssembly();
-
-            Should.Throw<ArgumentException>(() =>
-            {
-                services.AddMediatR(cfg =>
-                {
-                    cfg.RegisterServicesFromAssembly(assembly);
-                });
-            })
-            .Message.ShouldContain("When registering generic requests with more than two type parameters, each type parameter must have at least one constraint of type interface or class.");
-        }
-
         [Fact]
         public void ShouldThrowExceptionWhenTypesClosingExceedsMaximum()
         {
@@ -124,6 +107,7 @@ public void ShouldThrowExceptionWhenTypesClosingExceedsMaximum()
                 services.AddMediatR(cfg =>
                 {
                     cfg.RegisterServicesFromAssembly(assembly);
+                    cfg.RegisterGenericHandlers = true;
                 });
             })
             .Message.ShouldContain("One of the generic type parameter's count of types that can close exceeds the maximum length allowed");
@@ -142,6 +126,7 @@ public void ShouldThrowExceptionWhenGenericHandlerRegistrationsExceedsMaximum()
                 services.AddMediatR(cfg =>
                 {
                     cfg.RegisterServicesFromAssembly(assembly);
+                    cfg.RegisterGenericHandlers = true;
                 });
             })
             .Message.ShouldContain("The total number of generic type registrations exceeds the maximum allowed");
@@ -160,6 +145,7 @@ public void ShouldThrowExceptionWhenGenericTypeParametersExceedsMaximum()
                 services.AddMediatR(cfg =>
                 {
                     cfg.RegisterServicesFromAssembly(assembly);
+                    cfg.RegisterGenericHandlers = true;
                 });
             })
             .Message.ShouldContain("The number of generic type parameters exceeds the maximum allowed");
@@ -181,6 +167,7 @@ public void ShouldThrowExceptionWhenTimeoutOccurs()
                     cfg.MaxGenericTypeRegistrations = 0;
                     cfg.MaxTypesClosing = 0;
                     cfg.RegistrationTimeout = 1000;
+                    cfg.RegisterGenericHandlers = true;
                     cfg.RegisterServicesFromAssembly(assembly);
                 });
             })

test/MediatR.Tests/MicrosoftExtensionsDI/AssemblyResolutionTests.cs

@@ -15,7 +15,11 @@ public AssemblyResolutionTests()
     {
         IServiceCollection services = new ServiceCollection();
         services.AddSingleton(new Logger());
-        services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Ping).Assembly));
+        services.AddMediatR(cfg =>
+        {
+            cfg.RegisterServicesFromAssembly(typeof(Ping).Assembly);
+            cfg.RegisterGenericHandlers = true;
+        });
         _provider = services.BuildServiceProvider();
     }
 

test/MediatR.Tests/MicrosoftExtensionsDI/BaseGenericRequestHandlerTests.cs

@@ -9,11 +9,7 @@
 namespace MediatR.Tests.MicrosoftExtensionsDI
 {
     public abstract class BaseGenericRequestHandlerTests
-    {      
-
-        protected static Assembly GenerateMissingConstraintsAssembly() =>
-           CreateAssemblyModuleBuilder("MissingConstraintsAssembly", 3, 3, CreateHandlerForMissingConstraintsTest);
-
+    { 
         protected static Assembly GenerateTypesClosingExceedsMaximumAssembly() =>
             CreateAssemblyModuleBuilder("ExceedsMaximumTypesClosingAssembly", 201, 1, CreateHandlerForExceedsMaximumClassesTest);