Exception handling middleware

src/WaCore.Common/ExceptionHandling/HandlingInput.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace WaCore.Common.ExceptionHandling
+{
+    public class HandlingInput<TParameter>
+    {
+        public Exception Exception { get; }
+
+        public TParameter Parameter { get; }
+
+        public HandlingInput(Exception exception, TParameter parameter = default(TParameter))
+        {
+            Exception = exception ?? throw new ArgumentNullException(nameof(exception));
+            Parameter = parameter;
+        }
+    }
+
+    public class HandlingInput : HandlingInput<object>
+    {
+        public HandlingInput(Exception exception, object parameter = null) : base(exception, parameter)
+        {
+
+        }
+    }
+}

src/WaCore.Common/ExceptionHandling/HandlingMatchType.cs

@@ -0,0 +1,8 @@
+namespace WaCore.Common.ExceptionHandling
+{
+    public enum HandlingMatchType
+    {
+        Inheritance,
+        ExactType
+    }
+}

src/WaCore.Common/ExceptionHandling/HandlingResult.cs

@@ -0,0 +1,31 @@
+namespace WaCore.Common.ExceptionHandling
+{
+    public class HandlingResult<TResult>
+    {
+        public HandlingResult()
+        {
+            Handled = true;
+        }
+
+        public HandlingResult(bool handled, TResult result = default(TResult))
+        {
+            Handled = handled;
+            Result = result;
+        }
+
+        public bool Handled { get; }
+
+        public TResult Result { get; }
+    }
+
+    public class HandlingResult : HandlingResult<object>
+    {
+        public HandlingResult()
+        {
+        }
+
+        public HandlingResult(bool handled, object result = null) : base(handled, result)
+        {
+        }
+    }
+}

src/WaCore.Common/ExceptionHandling/NoHandlerMatchedException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace WaCore.Common.ExceptionHandling
+{
+    public class NoHandlerMatchedException: Exception
+    {
+        private const string DefaultMessage = "No handler matched the exception to catch";
+
+        public NoHandlerMatchedException(Exception innerException)
+            : base(DefaultMessage, innerException)
+        {
+
+        }
+    }
+}

src/WaCore.Common/ExceptionHandling/WacHandling.cs

@@ -0,0 +1,65 @@
+using System;
+
+namespace WaCore.Common.ExceptionHandling
+{
+    public static class WacHandling
+    {
+        private static readonly HandlingResult<object> HandledResult = new HandlingResult(true);
+
+        private static readonly HandlingResult<object> IgnoredResult = new HandlingResult(false);
+
+        public static WacHandlingConfiguration<TParameter, TResult> Prepare<TParameter, TResult>()
+        {
+            return new WacHandlingConfiguration<TParameter, TResult>();
+        }
+
+        public static WacHandlingConfiguration Prepare()
+        {
+            return new WacHandlingConfiguration();
+        }
+
+        public static TResult Result<TResult>(this HandlingResult<object> result)
+        {
+            if (result == null) throw new ArgumentNullException(nameof(result));
+
+            return (TResult)result.Result;
+        }
+
+        public static TResult Parameter<TResult>(this HandlingInput<object> input)
+        {
+            if (input == null) throw new ArgumentNullException(nameof(input));
+
+            return (TResult)input.Parameter;
+        }
+
+        public static HandlingResult<TResult> Handled<TResult>()
+        {
+            return new HandlingResult<TResult>(true);
+        }
+
+        public static HandlingResult<TResult> Handled<TResult>(TResult result)
+        {
+            return new HandlingResult<TResult>(true, result);
+        }
+
+        public static HandlingResult<object> Handled()
+        {
+            return HandledResult;
+        }
+
+        public static HandlingResult<object> Handled(object result)
+        {
+            return new HandlingResult(true, result);
+        }
+
+        public static HandlingResult<TResult> Ignore<TResult>()
+        {
+            return new HandlingResult<TResult>(false);
+        }
+
+        public static HandlingResult<object> Ignore()
+        {
+            return IgnoredResult;
+        }
+    }
+}

src/WaCore.Common/ExceptionHandling/WacHandlingConfiguration.cs

@@ -0,0 +1,237 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WaCore.Common.ExceptionHandling
+{
+    public class WacHandlingConfiguration<TParameter, TResult>
+    {
+        private readonly IList<Func<Exception, HandlingInput<TParameter>, HandlingResult<TResult>>> _handlers =
+            new List<Func<Exception, HandlingInput<TParameter>, HandlingResult<TResult>>>();
+
+        private Action<Exception, HandlingInput<TParameter>, HandlingResult<TResult>> _finalizationHandler;
+
+        public HandlingMatchType MatchType { get; set; } = HandlingMatchType.Inheritance;
+
+        private void AddHandler(Func<Exception, HandlingInput<TParameter>, HandlingResult<TResult>> handler)
+        {
+            _handlers.Add(handler);
+        }
+
+        private bool TryCastException<TException>(Exception sourceException, out TException exception) where TException: Exception
+        {
+            exception = null;
+            switch (MatchType)
+            {
+                case HandlingMatchType.Inheritance:
+                {
+                    if (sourceException is TException)
+                    {
+                        exception = (TException) sourceException;
+                        return true;
+                    }
+                    return false;
+                }
+                case HandlingMatchType.ExactType:
+                {
+                    if (sourceException.GetType() == typeof(TException))
+                    {
+                        exception = (TException)sourceException;
+                        return true;
+                    }
+                    return false;
+                }
+                default:
+                    throw new NotImplementedException($"Unrecognized HandlingMatchType value - '{MatchType}'");
+            }
+        }
+
+        public bool ContainsHandler<TException>() where TException : Exception
+        {
+            foreach (var handler in _handlers)
+            {
+                var handlerType = handler.GetType();
+                var handlerExceptionType = handlerType.GetGenericArguments().First();
+
+                if (handlerExceptionType == typeof(TException))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> On<TException>(
+            Action<TException, HandlingInput<TParameter>> handler,
+            Func<TException, HandlingInput<TParameter>, bool> condition = null)
+            where TException : Exception
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            AddHandler((ex, i) =>
+            {
+                if (TryCastException(ex, out TException castedException))
+                {
+                    if (condition == null || condition(castedException, i))
+                    {
+                        handler(castedException, i);
+                        return new HandlingResult<TResult>(true);
+                    }
+                }
+
+                return new HandlingResult<TResult>(false);
+            });
+
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> On<TException>(
+            Func<TException, HandlingInput<TParameter>, HandlingResult<TResult>> handler,
+            Func<TException, HandlingInput<TParameter>, bool> condition = null)
+            where TException : Exception
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            AddHandler((ex, i) =>
+            {
+                if (TryCastException(ex, out TException castedException))
+                {
+                    if (condition == null || condition(castedException, i))
+                    {
+                        return handler(castedException, i);
+                    }
+                }
+
+                return new HandlingResult<TResult>(false);
+            });
+
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> On<TException>(
+            Action<TException> handler,
+            Func<TException, HandlingInput<TParameter>, bool> condition = null)
+            where TException : Exception
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            AddHandler((ex, i) =>
+            {
+                if (TryCastException(ex, out TException castedException))
+                {
+                    if (condition == null || condition(castedException, i))
+                    {
+                        handler(castedException);
+                        return new HandlingResult<TResult>(true);
+                    }
+                }
+
+                return new HandlingResult<TResult>(false);
+            });
+
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> On<TException>(
+            Func<TException, HandlingResult<TResult>> handler,
+            Func<TException, HandlingInput<TParameter>, bool> condition = null)
+            where TException : Exception
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            AddHandler((ex, i) =>
+            {
+                if (TryCastException(ex, out TException castedException))
+                {
+                    if (condition == null || condition(castedException, i))
+                    {
+                        return handler(castedException);
+                    }
+                }
+
+                return new HandlingResult<TResult>(false);
+            });
+
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> FinalizeWith(
+            Action<Exception, HandlingInput<TParameter>, HandlingResult<TResult>> finalizationHandler)
+        {
+            _finalizationHandler = finalizationHandler ?? throw new ArgumentNullException(nameof(finalizationHandler));
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> FinalizeWith(
+            Action<Exception, HandlingInput<TParameter>> finalizationHandler)
+        {
+            if (finalizationHandler == null) throw new ArgumentNullException(nameof(finalizationHandler));
+
+            _finalizationHandler = (e, input, result) =>
+            {
+                finalizationHandler(e, input);
+            };
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> FinalizeWith(Action<Exception> finalizationHandler)
+        {
+            if (finalizationHandler == null) throw new ArgumentNullException(nameof(finalizationHandler));
+
+            _finalizationHandler = (e, input, result) =>
+            {
+                finalizationHandler(e);
+            };
+            return this;
+        }
+
+        public WacHandlingConfiguration<TParameter, TResult> FinalizeWith(Action finalizationHandler)
+        {
+            if (finalizationHandler == null) throw new ArgumentNullException(nameof(finalizationHandler));
+
+            _finalizationHandler = (e, input, result) =>
+            {
+                finalizationHandler();
+            };
+            return this;
+        }
+
+        public HandlingResult<TResult> Catch(
+            Exception exception, TParameter parameter = default(TParameter), bool throwIfNotHandled = true)
+        {
+            if (exception == null) throw new ArgumentNullException(nameof(exception));
+
+            var input = new HandlingInput<TParameter>(exception, parameter);
+            HandlingResult<TResult> result = null;
+            try
+            {
+                foreach (var handler in _handlers)
+                {
+                    result = handler(exception, input);
+                    if (result.Handled)
+                    {
+                        return result;
+                    }
+                }
+
+                result = WacHandling.Ignore<TResult>();
+                if (throwIfNotHandled)
+                {
+                    throw new NoHandlerMatchedException(exception);
+                }
+
+                return result;
+            }
+            finally
+            {
+                _finalizationHandler?.Invoke(exception, input, result ?? WacHandling.Ignore<TResult>());
+            }
+        }
+    }
+
+    public class WacHandlingConfiguration : WacHandlingConfiguration<object, object>
+    {
+
+    }
+}

src/WaCore.Common/WaCore.Common.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+</Project>