Merge pull request #925 from jbogard/fixing-behavior-registration

jbogard · web-flow · commit c295291c4e81 · 2023-07-10T10:57:39.000-05:00
Fixing registration problem; moving exception behaviors first so that…
diff --git a/src/MediatR/MicrosoftExtensionsDI/MediatrServiceConfiguration.cs b/src/MediatR/MicrosoftExtensionsDI/MediatrServiceConfiguration.cs
@@ -5,6 +5,7 @@
 using MediatR;
 using MediatR.NotificationPublishers;
 using MediatR.Pipeline;
+using MediatR.Registration;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -133,15 +134,14 @@ public MediatRServiceConfiguration AddBehavior<TImplementationType>(ServiceLifet
     /// <returns>This</returns>
     public MediatRServiceConfiguration AddBehavior(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
     {
-        var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());
-        var implementedBehaviorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IPipelineBehavior<,>)));
+        var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IPipelineBehavior<,>)).ToList();
 
-        if (implementedBehaviorTypes.Count == 0)
+        if (implementedGenericInterfaces.Count == 0)
         {
             throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IPipelineBehavior<,>).FullName}");
         }
 
-        foreach (var implementedBehaviorType in implementedBehaviorTypes)
+        foreach (var implementedBehaviorType in implementedGenericInterfaces)
         {
             BehaviorsToRegister.Add(new ServiceDescriptor(implementedBehaviorType, implementationType, serviceLifetime));
         }
@@ -233,15 +233,14 @@ public MediatRServiceConfiguration AddStreamBehavior<TImplementationType>(Servic
     /// <returns>This</returns>
     public MediatRServiceConfiguration AddStreamBehavior(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
     {
-        var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());
-        var implementedBehaviorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IStreamPipelineBehavior<,>)));
+        var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IStreamPipelineBehavior<,>)).ToList();
 
-        if (implementedBehaviorTypes.Count == 0)
+        if (implementedGenericInterfaces.Count == 0)
         {
             throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IStreamPipelineBehavior<,>).FullName}");
         }
 
-        foreach (var implementedBehaviorType in implementedBehaviorTypes)
+        foreach (var implementedBehaviorType in implementedGenericInterfaces)
         {
             StreamBehaviorsToRegister.Add(new ServiceDescriptor(implementedBehaviorType, implementationType, serviceLifetime));
         }
@@ -320,15 +319,14 @@ public MediatRServiceConfiguration AddRequestPreProcessor<TImplementationType>(
     /// <returns>This</returns>
     public MediatRServiceConfiguration AddRequestPreProcessor(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
     {
-        var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());
-        var implementedPreProcessorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IRequestPreProcessor<>)));
+        var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IRequestPreProcessor<>)).ToList();
 
-        if (implementedPreProcessorTypes.Count == 0)
+        if (implementedGenericInterfaces.Count == 0)
         {
             throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IRequestPreProcessor<>).FullName}");
         }
 
-        foreach (var implementedPreProcessorType in implementedPreProcessorTypes)
+        foreach (var implementedPreProcessorType in implementedGenericInterfaces)
         {
             RequestPreProcessorsToRegister.Add(new ServiceDescriptor(implementedPreProcessorType, implementationType, serviceLifetime));
         }
@@ -406,15 +404,14 @@ public MediatRServiceConfiguration AddRequestPostProcessor<TImplementationType>(
     /// <returns>This</returns>
     public MediatRServiceConfiguration AddRequestPostProcessor(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
     {
-        var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());
-        var implementedPostProcessorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IRequestPostProcessor<,>)));
+        var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IRequestPostProcessor<,>)).ToList();
 
-        if (implementedPostProcessorTypes.Count == 0)
+        if (implementedGenericInterfaces.Count == 0)
         {
             throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IRequestPostProcessor<,>).FullName}");
         }
 
-        foreach (var implementedPostProcessorType in implementedPostProcessorTypes)
+        foreach (var implementedPostProcessorType in implementedGenericInterfaces)
         {
             RequestPostProcessorsToRegister.Add(new ServiceDescriptor(implementedPostProcessorType, implementationType, serviceLifetime));
         }
diff --git a/src/MediatR/MicrosoftExtensionsDI/ServiceCollectionExtensions.cs b/src/MediatR/MicrosoftExtensionsDI/ServiceCollectionExtensions.cs
@@ -30,14 +30,26 @@ public static IServiceCollection AddMediatR(this IServiceCollection services,
 
         configuration.Invoke(serviceConfig);
 
-        if (!serviceConfig.AssembliesToRegister.Any())
+        return services.AddMediatR(serviceConfig);
+    }
+    
+    /// <summary>
+    /// Registers handlers and mediator types from the specified assemblies
+    /// </summary>
+    /// <param name="services">Service collection</param>
+    /// <param name="configuration">Configuration options</param>
+    /// <returns>Service collection</returns>
+    public static IServiceCollection AddMediatR(this IServiceCollection services, 
+        MediatRServiceConfiguration configuration)
+    {
+        if (!configuration.AssembliesToRegister.Any())
         {
             throw new ArgumentException("No assemblies found to scan. Supply at least one assembly to scan for handlers.");
         }
 
-        ServiceRegistrar.AddMediatRClasses(services, serviceConfig);
+        ServiceRegistrar.AddMediatRClasses(services, configuration);
 
-        ServiceRegistrar.AddRequiredServices(services, serviceConfig);
+        ServiceRegistrar.AddRequiredServices(services, configuration);
 
         return services;
     }
diff --git a/src/MediatR/Registration/ServiceRegistrar.cs b/src/MediatR/Registration/ServiceRegistrar.cs
@@ -138,7 +138,7 @@ private static void AddConcretionsThatCouldBeClosed(Type @interface, List<Type>
         }
     }
 
-    private static bool CouldCloseTo(this Type openConcretion, Type closedInterface)
+    internal static bool CouldCloseTo(this Type openConcretion, Type closedInterface)
     {
         var openInterface = closedInterface.GetGenericTypeDefinition();
         var arguments = closedInterface.GenericTypeArguments;
@@ -161,7 +161,7 @@ private static bool IsOpenGeneric(this Type type)
         return type.IsGenericTypeDefinition || type.ContainsGenericParameters;
     }
 
-    private static IEnumerable<Type> FindInterfacesThatClose(this Type pluggedType, Type templateType)
+    internal static IEnumerable<Type> FindInterfacesThatClose(this Type pluggedType, Type templateType)
     {
         return FindInterfacesThatClosesCore(pluggedType, templateType).Distinct();
     }
@@ -221,6 +221,17 @@ public static void AddRequiredServices(IServiceCollection services, MediatRServi
         services.TryAdd(notificationPublisherServiceDescriptor);
 
         // Register pre processors, then post processors, then behaviors
+        if (serviceConfiguration.RequestExceptionActionProcessorStrategy == RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions)
+        {
+            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));
+            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));
+        }
+        else
+        {
+            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));
+            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));
+        }
+
         if (serviceConfiguration.RequestPreProcessorsToRegister.Any())
         {
             services.TryAddEnumerable(new ServiceDescriptor(typeof(IPipelineBehavior<,>), typeof(RequestPreProcessorBehavior<,>), ServiceLifetime.Transient));
@@ -242,17 +253,6 @@ public static void AddRequiredServices(IServiceCollection services, MediatRServi
         {
             services.TryAddEnumerable(serviceDescriptor);
         }
-
-        if (serviceConfiguration.RequestExceptionActionProcessorStrategy == RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions)
-        {
-            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));
-            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));
-        }
-        else
-        {
-            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));
-            RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));
-        }
     }
 
     private static void RegisterBehaviorIfImplementationsExist(IServiceCollection services, Type behaviorType, Type subBehaviorType)
diff --git a/test/MediatR.Tests/MicrosoftExtensionsDI/PipelineTests.cs b/test/MediatR.Tests/MicrosoftExtensionsDI/PipelineTests.cs
@@ -361,6 +361,11 @@ public class NotAnOpenBehavior : IPipelineBehavior<Ping, Pong>
         public Task<Pong> Handle(Ping request, RequestHandlerDelegate<Pong> next, CancellationToken cancellationToken) => next();
     }
 
+    public class ThrowingBehavior : IPipelineBehavior<Ping, Pong>
+    {
+        public Task<Pong> Handle(Ping request, RequestHandlerDelegate<Pong> next, CancellationToken cancellationToken) => throw new Exception(request.Message);
+    }
+
     public class NotAnOpenStreamBehavior : IStreamPipelineBehavior<Ping, Pong>
     {
         public IAsyncEnumerable<Pong> Handle(Ping request, StreamHandlerDelegate<Pong> next, CancellationToken cancellationToken) => next();
@@ -524,6 +529,27 @@ public void Should_pick_up_base_exception_behaviors()
         output.Messages.ShouldContain("Logging generic exception");
     }
 
+    [Fact]
+    public void Should_handle_exceptions_from_behaviors()
+    {
+        var output = new Logger();
+        IServiceCollection services = new ServiceCollection();
+        services.AddSingleton(output);
+        services.AddMediatR(cfg =>
+        {
+            cfg.RegisterServicesFromAssembly(typeof(Ping).Assembly);
+            cfg.AddBehavior<ThrowingBehavior>();
+        });
+        var provider = services.BuildServiceProvider();
+
+        var mediator = provider.GetRequiredService<IMediator>();
+
+        Should.Throw<Exception>(async () => await mediator.Send(new Ping {Message = "Ping"}));
+
+        output.Messages.ShouldContain("Ping Logged by Generic Type");
+        output.Messages.ShouldContain("Logging generic exception");
+    }
+
     [Fact]
     public void Should_pick_up_exception_actions()
     {
@@ -648,6 +674,16 @@ public void Should_handle_open_behavior_registration()
         cfg.StreamBehaviorsToRegister[0].ImplementationFactory.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[0].ImplementationInstance.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[0].Lifetime.ShouldBe(ServiceLifetime.Transient);
+
+        var services = new ServiceCollection();
+
+        cfg.RegisterServicesFromAssemblyContaining<Ping>();
+
+        Should.NotThrow(() =>
+        {
+            services.AddMediatR(cfg);
+            services.BuildServiceProvider();
+        });
     }
     
     [Fact]
@@ -659,16 +695,26 @@ public void Should_handle_inferred_behavior_registration()
 
         cfg.BehaviorsToRegister.Count.ShouldBe(2);
 
-        cfg.BehaviorsToRegister[0].ServiceType.ShouldBe(typeof(IPipelineBehavior<,>));
+        cfg.BehaviorsToRegister[0].ServiceType.ShouldBe(typeof(IPipelineBehavior<Ping, Pong>));
         cfg.BehaviorsToRegister[0].ImplementationType.ShouldBe(typeof(InnerBehavior));
         cfg.BehaviorsToRegister[0].ImplementationFactory.ShouldBeNull();
         cfg.BehaviorsToRegister[0].ImplementationInstance.ShouldBeNull();
         cfg.BehaviorsToRegister[0].Lifetime.ShouldBe(ServiceLifetime.Transient);
-        cfg.BehaviorsToRegister[1].ServiceType.ShouldBe(typeof(IPipelineBehavior<,>));
+        cfg.BehaviorsToRegister[1].ServiceType.ShouldBe(typeof(IPipelineBehavior<Ping, Pong>));
         cfg.BehaviorsToRegister[1].ImplementationType.ShouldBe(typeof(OuterBehavior));
         cfg.BehaviorsToRegister[1].ImplementationFactory.ShouldBeNull();
         cfg.BehaviorsToRegister[1].ImplementationInstance.ShouldBeNull();
         cfg.BehaviorsToRegister[1].Lifetime.ShouldBe(ServiceLifetime.Transient);
+        
+        var services = new ServiceCollection();
+
+        cfg.RegisterServicesFromAssemblyContaining<Ping>();
+
+        Should.NotThrow(() =>
+        {
+            services.AddMediatR(cfg);
+            services.BuildServiceProvider();
+        });
     }
 
         
@@ -681,16 +727,26 @@ public void Should_handle_inferred_stream_behavior_registration()
 
         cfg.StreamBehaviorsToRegister.Count.ShouldBe(2);
 
-        cfg.StreamBehaviorsToRegister[0].ServiceType.ShouldBe(typeof(IStreamPipelineBehavior<,>));
+        cfg.StreamBehaviorsToRegister[0].ServiceType.ShouldBe(typeof(IStreamPipelineBehavior<Ping, Pong>));
         cfg.StreamBehaviorsToRegister[0].ImplementationType.ShouldBe(typeof(InnerStreamBehavior));
         cfg.StreamBehaviorsToRegister[0].ImplementationFactory.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[0].ImplementationInstance.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[0].Lifetime.ShouldBe(ServiceLifetime.Transient);
-        cfg.StreamBehaviorsToRegister[1].ServiceType.ShouldBe(typeof(IStreamPipelineBehavior<,>));
+        cfg.StreamBehaviorsToRegister[1].ServiceType.ShouldBe(typeof(IStreamPipelineBehavior<Ping, Pong>));
         cfg.StreamBehaviorsToRegister[1].ImplementationType.ShouldBe(typeof(OuterStreamBehavior));
         cfg.StreamBehaviorsToRegister[1].ImplementationFactory.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[1].ImplementationInstance.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[1].Lifetime.ShouldBe(ServiceLifetime.Transient);
+        
+        var services = new ServiceCollection();
+
+        cfg.RegisterServicesFromAssemblyContaining<Ping>();
+
+        Should.NotThrow(() =>
+        {
+            services.AddMediatR(cfg);
+            services.BuildServiceProvider();
+        });
     }
     
     [Fact]
@@ -702,16 +758,26 @@ public void Should_handle_inferred_pre_processor_registration()
 
         cfg.RequestPreProcessorsToRegister.Count.ShouldBe(2);
 
-        cfg.RequestPreProcessorsToRegister[0].ServiceType.ShouldBe(typeof(IRequestPreProcessor<>));
+        cfg.RequestPreProcessorsToRegister[0].ServiceType.ShouldBe(typeof(IRequestPreProcessor<Ping>));
         cfg.RequestPreProcessorsToRegister[0].ImplementationType.ShouldBe(typeof(FirstConcretePreProcessor));
         cfg.RequestPreProcessorsToRegister[0].ImplementationFactory.ShouldBeNull();
         cfg.RequestPreProcessorsToRegister[0].ImplementationInstance.ShouldBeNull();
         cfg.RequestPreProcessorsToRegister[0].Lifetime.ShouldBe(ServiceLifetime.Transient);
-        cfg.RequestPreProcessorsToRegister[1].ServiceType.ShouldBe(typeof(IRequestPreProcessor<>));
+        cfg.RequestPreProcessorsToRegister[1].ServiceType.ShouldBe(typeof(IRequestPreProcessor<Ping>));
         cfg.RequestPreProcessorsToRegister[1].ImplementationType.ShouldBe(typeof(NextConcretePreProcessor));
         cfg.RequestPreProcessorsToRegister[1].ImplementationFactory.ShouldBeNull();
         cfg.RequestPreProcessorsToRegister[1].ImplementationInstance.ShouldBeNull();
         cfg.RequestPreProcessorsToRegister[1].Lifetime.ShouldBe(ServiceLifetime.Transient);
+        
+        var services = new ServiceCollection();
+
+        cfg.RegisterServicesFromAssemblyContaining<Ping>();
+
+        Should.NotThrow(() =>
+        {
+            services.AddMediatR(cfg);
+            services.BuildServiceProvider();
+        });
     }
     
     [Fact]
@@ -723,16 +789,26 @@ public void Should_handle_inferred_post_processor_registration()
 
         cfg.RequestPostProcessorsToRegister.Count.ShouldBe(2);
 
-        cfg.RequestPostProcessorsToRegister[0].ServiceType.ShouldBe(typeof(IRequestPostProcessor<,>));
+        cfg.RequestPostProcessorsToRegister[0].ServiceType.ShouldBe(typeof(IRequestPostProcessor<Ping, Pong>));
         cfg.RequestPostProcessorsToRegister[0].ImplementationType.ShouldBe(typeof(FirstConcretePostProcessor));
         cfg.RequestPostProcessorsToRegister[0].ImplementationFactory.ShouldBeNull();
         cfg.RequestPostProcessorsToRegister[0].ImplementationInstance.ShouldBeNull();
         cfg.RequestPostProcessorsToRegister[0].Lifetime.ShouldBe(ServiceLifetime.Transient);
-        cfg.RequestPostProcessorsToRegister[1].ServiceType.ShouldBe(typeof(IRequestPostProcessor<,>));
+        cfg.RequestPostProcessorsToRegister[1].ServiceType.ShouldBe(typeof(IRequestPostProcessor<Ping, Pong>));
         cfg.RequestPostProcessorsToRegister[1].ImplementationType.ShouldBe(typeof(NextConcretePostProcessor));
         cfg.RequestPostProcessorsToRegister[1].ImplementationFactory.ShouldBeNull();
         cfg.RequestPostProcessorsToRegister[1].ImplementationInstance.ShouldBeNull();
         cfg.RequestPostProcessorsToRegister[1].Lifetime.ShouldBe(ServiceLifetime.Transient);
+        
+        var services = new ServiceCollection();
+
+        cfg.RegisterServicesFromAssemblyContaining<Ping>();
+
+        Should.NotThrow(() =>
+        {
+            services.AddMediatR(cfg);
+            services.BuildServiceProvider();
+        });
     }
     
     [Fact]
@@ -756,5 +832,15 @@ public void Should_handle_open_behaviors_registration_from_a_single_type()
         cfg.StreamBehaviorsToRegister[0].ImplementationFactory.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[0].ImplementationInstance.ShouldBeNull();
         cfg.StreamBehaviorsToRegister[0].Lifetime.ShouldBe(ServiceLifetime.Singleton);
+        
+        var services = new ServiceCollection();
+
+        cfg.RegisterServicesFromAssemblyContaining<Ping>();
+
+        Should.NotThrow(() =>
+        {
+            services.AddMediatR(cfg);
+            services.BuildServiceProvider();
+        });
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using MediatR;`
`6`	`6`	`using MediatR.NotificationPublishers;`
`7`	`7`	`using MediatR.Pipeline;`
	`8`	`+using MediatR.Registration;`
`8`	`9`
`9`	`10`	`namespace Microsoft.Extensions.DependencyInjection;`
`10`	`11`
`@@ -133,15 +134,14 @@ public MediatRServiceConfiguration AddBehavior<TImplementationType>(ServiceLifet`
`133`	`134`	`/// <returns>This</returns>`
`134`	`135`	`public MediatRServiceConfiguration AddBehavior(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)`
`135`	`136`	`{`
`136`		`- var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());`
`137`		`- var implementedBehaviorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IPipelineBehavior<,>)));`
	`137`	`+ var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IPipelineBehavior<,>)).ToList();`
`138`	`138`
`139`		`- if (implementedBehaviorTypes.Count == 0)`
	`139`	`+ if (implementedGenericInterfaces.Count == 0)`
`140`	`140`	`{`
`141`	`141`	`throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IPipelineBehavior<,>).FullName}");`
`142`	`142`	`}`
`143`	`143`
`144`		`- foreach (var implementedBehaviorType in implementedBehaviorTypes)`
	`144`	`+ foreach (var implementedBehaviorType in implementedGenericInterfaces)`
`145`	`145`	`{`
`146`	`146`	`BehaviorsToRegister.Add(new ServiceDescriptor(implementedBehaviorType, implementationType, serviceLifetime));`
`147`	`147`	`}`
`@@ -233,15 +233,14 @@ public MediatRServiceConfiguration AddStreamBehavior<TImplementationType>(Servic`
`233`	`233`	`/// <returns>This</returns>`
`234`	`234`	`public MediatRServiceConfiguration AddStreamBehavior(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)`
`235`	`235`	`{`
`236`		`- var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());`
`237`		`- var implementedBehaviorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IStreamPipelineBehavior<,>)));`
	`236`	`+ var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IStreamPipelineBehavior<,>)).ToList();`
`238`	`237`
`239`		`- if (implementedBehaviorTypes.Count == 0)`
	`238`	`+ if (implementedGenericInterfaces.Count == 0)`
`240`	`239`	`{`
`241`	`240`	`throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IStreamPipelineBehavior<,>).FullName}");`
`242`	`241`	`}`
`243`	`242`
`244`		`- foreach (var implementedBehaviorType in implementedBehaviorTypes)`
	`243`	`+ foreach (var implementedBehaviorType in implementedGenericInterfaces)`
`245`	`244`	`{`
`246`	`245`	`StreamBehaviorsToRegister.Add(new ServiceDescriptor(implementedBehaviorType, implementationType, serviceLifetime));`
`247`	`246`	`}`
`@@ -320,15 +319,14 @@ public MediatRServiceConfiguration AddRequestPreProcessor<TImplementationType>(`
`320`	`319`	`/// <returns>This</returns>`
`321`	`320`	`public MediatRServiceConfiguration AddRequestPreProcessor(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)`
`322`	`321`	`{`
`323`		`- var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());`
`324`		`- var implementedPreProcessorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IRequestPreProcessor<>)));`
	`322`	`+ var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IRequestPreProcessor<>)).ToList();`
`325`	`323`
`326`		`- if (implementedPreProcessorTypes.Count == 0)`
	`324`	`+ if (implementedGenericInterfaces.Count == 0)`
`327`	`325`	`{`
`328`	`326`	`throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IRequestPreProcessor<>).FullName}");`
`329`	`327`	`}`
`330`	`328`
`331`		`- foreach (var implementedPreProcessorType in implementedPreProcessorTypes)`
	`329`	`+ foreach (var implementedPreProcessorType in implementedGenericInterfaces)`
`332`	`330`	`{`
`333`	`331`	`RequestPreProcessorsToRegister.Add(new ServiceDescriptor(implementedPreProcessorType, implementationType, serviceLifetime));`
`334`	`332`	`}`
`@@ -406,15 +404,14 @@ public MediatRServiceConfiguration AddRequestPostProcessor<TImplementationType>(`
`406`	`404`	`/// <returns>This</returns>`
`407`	`405`	`public MediatRServiceConfiguration AddRequestPostProcessor(Type implementationType, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)`
`408`	`406`	`{`
`409`		`- var implementedGenericInterfaces = implementationType.GetInterfaces().Where(i => i.IsGenericType).Select(i => i.GetGenericTypeDefinition());`
`410`		`- var implementedPostProcessorTypes = new HashSet<Type>(implementedGenericInterfaces.Where(i => i == typeof(IRequestPostProcessor<,>)));`
	`407`	`+ var implementedGenericInterfaces = implementationType.FindInterfacesThatClose(typeof(IRequestPostProcessor<,>)).ToList();`
`411`	`408`
`412`		`- if (implementedPostProcessorTypes.Count == 0)`
	`409`	`+ if (implementedGenericInterfaces.Count == 0)`
`413`	`410`	`{`
`414`	`411`	`throw new InvalidOperationException($"{implementationType.Name} must implement {typeof(IRequestPostProcessor<,>).FullName}");`
`415`	`412`	`}`
`416`	`413`
`417`		`- foreach (var implementedPostProcessorType in implementedPostProcessorTypes)`
	`414`	`+ foreach (var implementedPostProcessorType in implementedGenericInterfaces)`
`418`	`415`	`{`
`419`	`416`	`RequestPostProcessorsToRegister.Add(new ServiceDescriptor(implementedPostProcessorType, implementationType, serviceLifetime));`
`420`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ private static void AddConcretionsThatCouldBeClosed(Type @interface, List<Type>`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`- private static bool CouldCloseTo(this Type openConcretion, Type closedInterface)`
	`141`	`+ internal static bool CouldCloseTo(this Type openConcretion, Type closedInterface)`
`142`	`142`	`{`
`143`	`143`	`var openInterface = closedInterface.GetGenericTypeDefinition();`
`144`	`144`	`var arguments = closedInterface.GenericTypeArguments;`
`@@ -161,7 +161,7 @@ private static bool IsOpenGeneric(this Type type)`
`161`	`161`	`return type.IsGenericTypeDefinition \|\| type.ContainsGenericParameters;`
`162`	`162`	`}`
`163`	`163`
`164`		`- private static IEnumerable<Type> FindInterfacesThatClose(this Type pluggedType, Type templateType)`
	`164`	`+ internal static IEnumerable<Type> FindInterfacesThatClose(this Type pluggedType, Type templateType)`
`165`	`165`	`{`
`166`	`166`	`return FindInterfacesThatClosesCore(pluggedType, templateType).Distinct();`
`167`	`167`	`}`
`@@ -221,6 +221,17 @@ public static void AddRequiredServices(IServiceCollection services, MediatRServi`
`221`	`221`	`services.TryAdd(notificationPublisherServiceDescriptor);`
`222`	`222`
`223`	`223`	`// Register pre processors, then post processors, then behaviors`
	`224`	`+ if (serviceConfiguration.RequestExceptionActionProcessorStrategy == RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions)`
	`225`	`+ {`
	`226`	`+ RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));`
	`227`	`+ RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));`
	`228`	`+ }`
	`229`	`+ else`
	`230`	`+ {`
	`231`	`+ RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));`
	`232`	`+ RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));`
	`233`	`+ }`
	`234`	`+`
`224`	`235`	`if (serviceConfiguration.RequestPreProcessorsToRegister.Any())`
`225`	`236`	`{`
`226`	`237`	`services.TryAddEnumerable(new ServiceDescriptor(typeof(IPipelineBehavior<,>), typeof(RequestPreProcessorBehavior<,>), ServiceLifetime.Transient));`
`@@ -242,17 +253,6 @@ public static void AddRequiredServices(IServiceCollection services, MediatRServi`
`242`	`253`	`{`
`243`	`254`	`services.TryAddEnumerable(serviceDescriptor);`
`244`	`255`	`}`
`245`		`-`
`246`		`- if (serviceConfiguration.RequestExceptionActionProcessorStrategy == RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions)`
`247`		`- {`
`248`		`- RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));`
`249`		`- RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));`
`250`		`- }`
`251`		`- else`
`252`		`- {`
`253`		`- RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionProcessorBehavior<,>), typeof(IRequestExceptionHandler<,,>));`
`254`		`- RegisterBehaviorIfImplementationsExist(services, typeof(RequestExceptionActionProcessorBehavior<,>), typeof(IRequestExceptionAction<,>));`
`255`		`- }`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`private static void RegisterBehaviorIfImplementationsExist(IServiceCollection services, Type behaviorType, Type subBehaviorType)`