Update main before release.

src/CatchBlockHandlers/CatchBlockFilter.cs

@@ -10,7 +10,7 @@ public class CatchBlockFilter
 	{
 		public static CatchBlockFilter Empty() => new CatchBlockFilter();
 
-		internal PolicyProcessor.ExceptionFilter ErrorFilter { get; } = new PolicyProcessor.ExceptionFilter();
+		internal PolicyProcessor.ExceptionFilter ErrorFilter { get; set; } = new PolicyProcessor.ExceptionFilter();
 
 		public CatchBlockFilter ExcludeError<TException>(ErrorType errorType = ErrorType.Error) where TException : Exception
 		{

src/CatchBlockHandlers/ErrorContext.cs

@@ -1,6 +1,6 @@
 namespace PoliNorError
 {
-	internal abstract class ErrorContext<T>
+	public abstract class ErrorContext<T>
 	{
 		protected ErrorContext(T t)
 		{

src/CatchBlockHandlers/PolicyProcessorCatchBlockAsyncHandler.cs

@@ -16,13 +16,14 @@ public PolicyProcessorCatchBlockAsyncHandler(PolicyResult policyResult, IBulkErr
 
 		public async Task<HandleCatchBlockResult> HandleAsync(Exception ex, ErrorContext<T> errorContext = null)
 		{
-			var (Result, CanProcess) = PreHandle(ex, errorContext);
-			if (!CanProcess)
-				return Result;
+			var shouldHandleResult = ShouldHandleException(ex, errorContext);
+			if(shouldHandleResult != HandleCatchBlockResult.Success)
+				return shouldHandleResult;
 
 			var bulkProcessResult = await _bulkErrorProcessor.ProcessAsync(ex, errorContext.ToProcessingErrorContext(), _configAwait, _cancellationToken).ConfigureAwait(_configAwait);
 
-			return PostHandle(bulkProcessResult, Result);
+			_policyResult.AddBulkProcessorErrors(bulkProcessResult);
+			return bulkProcessResult.IsCanceled ? HandleCatchBlockResult.Canceled : shouldHandleResult;
 		}
 	}
 }

src/CatchBlockHandlers/PolicyProcessorCatchBlockHandlerBase.cs

@@ -22,6 +22,18 @@ protected PolicyProcessorCatchBlockHandlerBase(PolicyResult policyResult, IBulkE
 			_policyRuleFunc = policyRuleFunc ?? ((_) => true);
 		}
 
+		protected HandleCatchBlockResult ShouldHandleException(Exception ex, ErrorContext<T> errorContext)
+		{
+			if (_cancellationToken.IsCancellationRequested)
+			{
+				return HandleCatchBlockResult.Canceled;
+			}
+			return CanHandle(ex, errorContext);
+		}
+
+#pragma warning disable S1133 // Deprecated code should be removed
+		[Obsolete("This method is obsolete")]
+#pragma warning restore S1133 // Deprecated code should be removed
 		protected (HandleCatchBlockResult Result, bool CanProcess) PreHandle(Exception ex, ErrorContext<T> errorContext)
 		{
 			if (_cancellationToken.IsCancellationRequested)
@@ -45,6 +57,9 @@ private HandleCatchBlockResult CanHandle(Exception ex, ErrorContext<T> errorCont
 				return HandleCatchBlockResult.Success;
 		}
 
+#pragma warning disable S1133 // Deprecated code should be removed
+		[Obsolete("This method is obsolete")]
+#pragma warning restore S1133 // Deprecated code should be removed
 		protected HandleCatchBlockResult PostHandle(BulkProcessResult bulkProcessResult, HandleCatchBlockResult resultIfNotCanceled)
 		{
 			_policyResult.AddBulkProcessorErrors(bulkProcessResult);

src/CatchBlockHandlers/PolicyProcessorCatchBlockSyncHandler.cs

@@ -12,13 +12,14 @@ public PolicyProcessorCatchBlockSyncHandler(PolicyResult policyResult, IBulkErro
 
 		public HandleCatchBlockResult Handle(Exception ex, ErrorContext<T> errorContext = null)
 		{
-			var (Result, CanProcess) = PreHandle(ex, errorContext);
-			if (!CanProcess)
-				return Result;
+			var shouldHandleResult = ShouldHandleException(ex, errorContext);
+			if (shouldHandleResult != HandleCatchBlockResult.Success)
+				return shouldHandleResult;
 
 			var bulkProcessResult = _bulkErrorProcessor.Process(ex, errorContext.ToProcessingErrorContext(), _cancellationToken);
 
-			return PostHandle(bulkProcessResult, Result);
+			_policyResult.AddBulkProcessorErrors(bulkProcessResult);
+			return bulkProcessResult.IsCanceled ? HandleCatchBlockResult.Canceled : shouldHandleResult;
 		}
 	}
 }

src/ConvertExceptionDelegates.cs

@@ -17,5 +17,17 @@ public static bool ToInnerException<TException>(Exception exception, out TExcept
 				return false;
 			}
 		}
+
+		public static bool ToSubException<TException>(Exception exception, out TException typedException) where TException : Exception
+		{
+			if (exception is TException found)
+			{
+				typedException = found;
+				return true;
+			}
+
+			typedException = null;
+			return false;
+		}
 	}
 }

src/ErrorProcessorRegistration.ForErrorContext.cs

@@ -4,41 +4,27 @@
 
 namespace PoliNorError
 {
-	public static partial class ErrorProcessorRegistration
-	{
-		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Action<Exception, ProcessingErrorInfo<TErrorContext>> actionProcessor) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorContextProcessorOf(actionProcessor, _addErrorProcessorAction);
-		}
-
-		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Action<Exception, ProcessingErrorInfo<TErrorContext>> actionProcessor, CancellationType cancellationType) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorContextProcessorOf(actionProcessor, cancellationType, _addErrorProcessorAction);
-		}
-
-		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Action<Exception, ProcessingErrorInfo<TErrorContext>, CancellationToken> actionProcessor) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorContextProcessorOf(actionProcessor, _addErrorProcessorAction);
-		}
-
-		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Func<Exception, ProcessingErrorInfo<TErrorContext>, Task> funcProcessor) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorContextProcessorOf(funcProcessor, _addErrorProcessorAction);
-		}
-
-		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Func<Exception, ProcessingErrorInfo<TErrorContext>, Task> funcProcessor, CancellationType cancellationType) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorContextProcessorOf(funcProcessor, cancellationType, _addErrorProcessorAction);
-		}
-
-		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Func<Exception, ProcessingErrorInfo<TErrorContext>, CancellationToken, Task> funcProcessor) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorContextProcessorOf(funcProcessor, _addErrorProcessorAction);
-		}
-
-		internal static T WithErrorContextProcessor<T, TErrorContext>(this T policyProcessor, DefaultErrorProcessor<TErrorContext> errorProcessor) where T : IPolicyProcessor
-		{
-			return policyProcessor.WithErrorProcessor(errorProcessor, _addErrorProcessorAction);
-		}
-	}
-}
+	public static partial class ErrorProcessorRegistration
+	{
+		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Action<Exception, ProcessingErrorInfo<TErrorContext>> actionProcessor) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorContextProcessorOf(actionProcessor, _addErrorProcessorAction);
+
+		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Action<Exception, ProcessingErrorInfo<TErrorContext>> actionProcessor, CancellationType cancellationType) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorContextProcessorOf(actionProcessor, cancellationType, _addErrorProcessorAction);
+
+		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Action<Exception, ProcessingErrorInfo<TErrorContext>, CancellationToken> actionProcessor) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorContextProcessorOf(actionProcessor, _addErrorProcessorAction);
+
+		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Func<Exception, ProcessingErrorInfo<TErrorContext>, Task> funcProcessor) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorContextProcessorOf(funcProcessor, _addErrorProcessorAction);
+
+		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Func<Exception, ProcessingErrorInfo<TErrorContext>, Task> funcProcessor, CancellationType cancellationType) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorContextProcessorOf(funcProcessor, cancellationType, _addErrorProcessorAction);
+
+		internal static T WithErrorContextProcessorOf<T, TErrorContext>(this T policyProcessor, Func<Exception, ProcessingErrorInfo<TErrorContext>, CancellationToken, Task> funcProcessor) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorContextProcessorOf(funcProcessor, _addErrorProcessorAction);
+
+		internal static T WithErrorContextProcessor<T, TErrorContext>(this T policyProcessor, DefaultErrorProcessor<TErrorContext> errorProcessor) where T : IPolicyProcessor
+			=> policyProcessor.WithErrorProcessor(errorProcessor, _addErrorProcessorAction);
+	}
+}

src/ErrorProcessorRegistration.ForInnerError.cs

@@ -7,63 +7,39 @@ namespace PoliNorError
 	public static partial class ErrorProcessorRegistration
 	{
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Action<TException> actionProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Action<TException, CancellationToken> actionProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Action<TException> actionProcessor, CancellationType cancellationType) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(actionProcessor, cancellationType, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(actionProcessor, cancellationType, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Func<TException, Task> funcProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Func<TException, Task> funcProcessor, CancellationType cancellationType) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(funcProcessor, cancellationType, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(funcProcessor, cancellationType, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Func<TException, CancellationToken, Task> funcProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Action<TException, ProcessingErrorInfo> actionProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Action<TException, ProcessingErrorInfo, CancellationToken> actionProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(actionProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Action<TException, ProcessingErrorInfo> actionProcessor, CancellationType cancellationType) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(actionProcessor, cancellationType, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(actionProcessor, cancellationType, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Func<TException, ProcessingErrorInfo, Task> funcProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Func<TException, ProcessingErrorInfo, Task> funcProcessor, CancellationType cancellationType) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(funcProcessor, cancellationType, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(funcProcessor, cancellationType, _addErrorProcessorAction);
 
 		internal static T WithInnerErrorProcessorOf<T, TException>(this T policyProcessor, Func<TException, ProcessingErrorInfo, CancellationToken, Task> funcProcessor) where T : IPolicyProcessor where TException : Exception
-		{
-			return policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
-		}
+			=> policyProcessor.WithInnerErrorProcessorOf(funcProcessor, _addErrorProcessorAction);
 	}
 }

src/ErrorProcessors/BulkErrorProcessor.cs

@@ -233,6 +233,8 @@ public class BulkProcessResult
 		{
 			private readonly bool _isCanceledBetweenProcessOne;
 
+			private readonly IReadOnlyList<ErrorProcessorException> _processErrors;
+
 			/// <summary>
 			/// Initializes a new instance of the <see cref="BulkProcessResult"/> class.
 			/// </summary>
@@ -242,7 +244,7 @@ public class BulkProcessResult
 			public BulkProcessResult(Exception handlingError, IEnumerable<ErrorProcessorException> processErrors, bool isCanceledBetweenProcessOne = false)
 			{
 				HandlingError = handlingError;
-				ProcessErrors = processErrors;
+				_processErrors = (processErrors ?? Array.Empty<ErrorProcessorException>()).ToList();
 				_isCanceledBetweenProcessOne = isCanceledBetweenProcessOne;
 			}
 
@@ -254,22 +256,31 @@ public BulkProcessResult(Exception handlingError, IEnumerable<ErrorProcessorExce
 			/// <summary>
 			/// Gets a collection of exceptions that occurred within the error processors.
 			/// </summary>
-			public IEnumerable<ErrorProcessorException> ProcessErrors { get; }
+			public IEnumerable<ErrorProcessorException> ProcessErrors => _processErrors;
+
+			/// <summary>
+			/// Gets a value indicating whether any processing errors occurred.
+			/// </summary>
+			public bool HasProcessErrors => _processErrors.Count > 0;
 
 			/// <summary>
 			/// Gets a value indicating whether the bulk processing operation was canceled.
 			/// </summary>
-			public bool IsCanceled => ProcessErrors.Any(e => e.ErrorStatus == ProcessStatus.Canceled) || _isCanceledBetweenProcessOne;
+			public bool IsCanceled => _processErrors.Any(e => e.ErrorStatus == ProcessStatus.Canceled) || _isCanceledBetweenProcessOne;
 
 			/// <summary>
 			/// Converts the processing errors into a collection of <see cref="CatchBlockException"/>.
 			/// </summary>
 			/// <returns>An enumerable of <see cref="CatchBlockException"/>.</returns>
 			public IEnumerable<CatchBlockException> ToCatchBlockExceptions()
 			{
-				return ProcessErrors?.Any() != true
-					? Array.Empty<CatchBlockException>()
-					: ProcessErrors.Select(pe => new CatchBlockException(pe, HandlingError, CatchBlockExceptionSource.ErrorProcessor));
+				foreach (var pe in _processErrors)
+				{
+					yield return new CatchBlockException(
+						pe,
+						HandlingError,
+						CatchBlockExceptionSource.ErrorProcessor);
+				}
 			}
 		}
 	}

src/ErrorProcessors/DefaultErrorProcessor.T.cs

@@ -62,7 +62,7 @@ public static DefaultErrorProcessorT Create<TParam>(Action<Exception, Processing
 		{
 			void action(Exception ex, ProcessingErrorInfo pi, CancellationToken token)
 			{
-				if (pi is ProcessingErrorInfo<TParam> gpi)
+				if (TryGetProcessingErrorInfo<TParam>(pi, out var gpi))
 					actionProcessor(ex, gpi, token);
 			}
 			var res = new DefaultErrorProcessorT();
@@ -90,7 +90,7 @@ public static DefaultErrorProcessorT Create<TParam>(Func<Exception, ProcessingEr
 		{
 			Task fn(Exception ex, ProcessingErrorInfo pi, CancellationToken token)
 			{
-				if (pi is ProcessingErrorInfo<TParam> gpi)
+				if (TryGetProcessingErrorInfo<TParam>(pi, out var gpi))
 					return funcProcessor(ex, gpi, token);
 				else
 					return Task.CompletedTask;
@@ -112,7 +112,7 @@ private static Action<Exception, ProcessingErrorInfo> ConvertToNonGenericAction<
 		{
 			return (Exception ex, ProcessingErrorInfo pi) =>
 			{
-				if (pi is ProcessingErrorInfo<TParam> gpi)
+				if (TryGetProcessingErrorInfo<TParam>(pi, out var gpi))
 					actionProcessor(ex, gpi);
 			};
 		}
@@ -121,13 +121,26 @@ private static Func<Exception, ProcessingErrorInfo, Task> ConvertToNonGenericFun
 		{
 			return (Exception ex, ProcessingErrorInfo pi) =>
 			{
-				if (pi is ProcessingErrorInfo<TParam> gpi)
+				if (TryGetProcessingErrorInfo<TParam>(pi, out var gpi))
 					return funcProcessor(ex, gpi);
 				else
 					return Task.CompletedTask;
 			};
 		}
 
+		public static bool TryGetProcessingErrorInfo<TParam>(
+				ProcessingErrorInfo pi,
+				out ProcessingErrorInfo<TParam> gpi)
+		{
+			if (pi is ProcessingErrorInfo<TParam> result)
+			{
+				gpi = result;
+				return true;
+			}
+			gpi = null;
+			return false;
+		}
+
 		protected override Func<ProcessingErrorInfo, ProcessingErrorInfo> ParameterConverter => (_) => _;
 	}
 }

src/ErrorProcessors/DefaultTypedErrorProcessor.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PoliNorError
+{
+	public class DefaultTypedErrorProcessor<TException> : IErrorProcessor where TException : Exception
+	{
+		private readonly DefaultTypedErrorProcessorT<TException> _errorProcessor;
+
+		public DefaultTypedErrorProcessor(Action<TException, ProcessingErrorInfo, CancellationToken> actionProcessor)
+		{
+			_errorProcessor = DefaultTypedErrorProcessorT<TException>.Create(actionProcessor);
+		}
+
+		public Exception Process(Exception error, ProcessingErrorInfo catchBlockProcessErrorInfo = null, CancellationToken cancellationToken = default)
+		{
+			return _errorProcessor.Process(error, catchBlockProcessErrorInfo, cancellationToken);
+		}
+
+		public async Task<Exception> ProcessAsync(Exception error, ProcessingErrorInfo catchBlockProcessErrorInfo = null, bool configAwait = false, CancellationToken cancellationToken = default)
+		{
+			return await _errorProcessor.ProcessAsync(error, catchBlockProcessErrorInfo, configAwait, cancellationToken).ConfigureAwait(configAwait);
+		}
+	}
+
+	internal class DefaultTypedErrorProcessorT<TException> : ErrorProcessorBase<ProcessingErrorInfo> where TException : Exception
+	{
+		public static DefaultTypedErrorProcessorT<TException> Create(Action<TException, ProcessingErrorInfo, CancellationToken> actionProcessor)
+		{
+			var action = ErrorProcessorFuncConverter.Convert(actionProcessor, ConvertExceptionDelegates.ToSubException);
+
+			var res = new DefaultTypedErrorProcessorT<TException>();
+			res.SetSyncRunner(action);
+			return res;
+		}
+
+		protected override Func<ProcessingErrorInfo, ProcessingErrorInfo> ParameterConverter => (_) => _;
+	}
+}