Add tutorial41 about dealing with exceptions

Author: stumathews

Tutorial41_Statics/Failures/AggregatePipelineFailure.cs

@@ -0,0 +1,30 @@
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Tutorial41
+{
+    public class AggregatePipelineFailure : IAmFailure
+    {
+        public AggregatePipelineFailure(IEnumerable<IAmFailure> failures)
+        {
+            frequencies = new Dictionary<IAmFailure, int>();
+            var failureNames = failures.GroupBy(o => o.GetType().Name + o.Reason);
+            var sb = new StringBuilder();
+            foreach (var name in failureNames)
+            {
+                var lookupFailure = failures.First(o=>(o.GetType().Name + o.Reason).Equals(name.Key));
+                if(!frequencies.ContainsKey(lookupFailure))
+                    frequencies.Add(lookupFailure, name.Count());
+
+                sb.Append($"Failure name: {name.Key} Count: {name.Count()}\n");
+            }
+
+            Reason = sb.ToString();
+        }
+        public string Reason { get; set; }
+        public Dictionary<IAmFailure, int> frequencies {get;set;}
+        public static IAmFailure Create(IEnumerable<IAmFailure> failures) => new AggregatePipelineFailure(failures);
+    }
+}

Tutorial41_Statics/Failures/ConditionNotSatisfiedFailure.cs

@@ -0,0 +1,13 @@
+
+namespace Tutorial41
+{
+    public class ConditionNotSatisfiedFailure : IAmFailure
+    {
+        public ConditionNotSatisfiedFailure(string caller = "Caller not captured")
+        {
+            Reason = $"Condition not satisfied. Caller: {caller}";
+        }
+        public string Reason { get; set; }
+        public static IAmFailure Create(string caller) => new ConditionNotSatisfiedFailure(caller);
+    }
+}

Tutorial41_Statics/Failures/ExceptionFailure.cs

@@ -0,0 +1,12 @@
+
+
+using System;
+
+namespace Tutorial41
+{
+    public class ExceptionFailure : Exception, IAmFailure
+    {
+        public ExceptionFailure(Exception e) => Reason = e.Message;
+        public string Reason { get; set; }
+    }
+}

Tutorial41_Statics/Failures/ExternalLibraryFailure.cs

@@ -0,0 +1,25 @@
+
+using System;
+
+namespace Tutorial41
+{
+    public class ExternalLibraryFailure : IAmFailure
+    {
+        public ExternalLibraryFailure(Exception exception)
+        {
+            Reason = exception.Message;
+            Exception = exception;
+        }
+
+        public ExternalLibraryFailure(string message)
+        {
+            Reason = message;
+        }
+
+        public string Reason { get; set; }
+        public Exception Exception { get; }
+
+        public static IAmFailure Create(string message) => new ExternalLibraryFailure(message);
+        public static IAmFailure Create(Exception e) => new ExternalLibraryFailure(e);
+    }
+}

Tutorial41_Statics/Failures/IAmFailure.cs

@@ -0,0 +1,14 @@
+
+namespace Tutorial41
+{
+    /// <summary>
+    /// Represents a failure for some reason
+    /// </summary>
+    public interface IAmFailure
+    {
+        /// <summary>
+        /// Nature of the failure
+        /// </summary>
+        string Reason { get; set; }
+    }
+}

Tutorial41_Statics/Failures/InvalidDataFailure.cs

@@ -0,0 +1,14 @@
+
+namespace Tutorial41
+{
+    public class InvalidDataFailure : IAmFailure
+    {
+        public InvalidDataFailure(string empty)
+        {
+            Reason = empty;
+        }
+
+        public string Reason { get; set; }
+        public static IAmFailure Create(string message) => new InvalidDataFailure(message);
+    }
+}

Tutorial41_Statics/Failures/NotFound.cs

@@ -0,0 +1,14 @@
+
+namespace Tutorial41
+{
+    public class NotFound : IAmFailure
+    {
+        public NotFound(string message)
+        {
+            Reason = message;
+        }
+        public string Reason { get; set; }
+
+        public static IAmFailure Create(string message) => new NotFound(message);
+    }
+}

Tutorial41_Statics/Failures/NotTypeExceptionFailure.cs

@@ -0,0 +1,17 @@
+
+using System;
+
+namespace Tutorial41
+{
+    public class NotTypeExceptionFailure : IAmFailure
+    {
+        public NotTypeExceptionFailure(Type type)
+        {
+            Reason = $"Function did not return expected type of '{type}'";
+        }
+
+        public string Reason { get; set; }
+
+        public static IAmFailure Create(Type type) => new NotTypeExceptionFailure(type);
+    }
+}

Tutorial41_Statics/Failures/ShortCircuitFailure.cs

@@ -0,0 +1,14 @@
+
+namespace Tutorial41
+{
+    public class ShortCircuitFailure : IAmFailure
+    {
+        public ShortCircuitFailure(string message)
+        {
+            Reason = message;
+        }
+
+        public string Reason { get; set; }
+        public static IAmFailure Create(string msg) => new ShortCircuitFailure(msg);
+    }
+}

Tutorial41_Statics/Failures/TransformExceptionFailure.cs

@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------
+
+// <copyright file="TransformExceptionFailure.cs" company="Stuart Mathews">
+
+// Copyright (c) Stuart Mathews. All rights reserved.
+
+// <author>Stuart Mathews</author>
+
+// <date>03/10/2021 13:16:11</date>
+
+// </copyright>
+
+//-----------------------------------------------------------------------
+
+using System;
+
+namespace Tutorial41
+{
+    public class TransformExceptionFailure : IAmFailure
+    {
+        public string Reason { get; set; }
+
+        public Exception Exception { get; set; }
+
+        public TransformExceptionFailure(string message)
+        {
+            Reason = message;
+        }
+
+        public override string ToString()
+        {
+            return Reason;
+        }
+
+        public static IAmFailure Create(string msg) => new TransformExceptionFailure(msg);
+
+    }
+}

Tutorial41_Statics/Failures/UnexpectedFailure.cs

@@ -0,0 +1,19 @@
+
+namespace Tutorial41
+{
+    public class UnexpectedFailure : IAmFailure
+    {
+        public UnexpectedFailure(string reason)
+        {
+            Reason = reason;
+        }
+
+        public override string ToString()
+        {
+            return Reason;
+        }
+
+        public string Reason { get; set; }
+        public static IAmFailure Create(string reason) => new UnexpectedFailure(reason);
+    }
+}

Tutorial41_Statics/Failures/UnexpectedFailureException.cs

@@ -0,0 +1,16 @@
+
+using System;
+
+namespace Tutorial41
+{
+    public class UnexpectedFailureException : Exception, IAmFailure
+    {
+        public UnexpectedFailureException(IAmFailure failure): base(failure.Reason)
+        {
+            Reason = failure.Reason;
+        }
+
+        public string Reason { get; set; }
+        public static IAmFailure Create(IAmFailure failure) => new UnexpectedFailureException(failure);
+    }
+}

Tutorial41_Statics/Failures/UninitializedFailure.cs

@@ -0,0 +1,16 @@
+
+using LanguageExt;
+
+namespace Tutorial41
+{
+    internal class UninitializedFailure : IAmFailure
+    {
+        public UninitializedFailure(string what)
+        {
+            Reason = what;
+        }
+        public string Reason { get; set; }
+        public static IAmFailure Create(string what) => new UninitializedFailure(what);
+        public static Either<IAmFailure, T> Create<T>(string what) => new UninitializedFailure(what);
+    }
+}

Tutorial41_Statics/Program.cs

@@ -0,0 +1,89 @@
+using LanguageExt;
+using System;
+
+namespace Tutorial41
+{
+    // This tutorial shows you how to protect binding transformations from exceptions,
+    // and also override how the problem is surfaced to the user.
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // Create some products based on an assembly line (pipeline)
+            var product1 = GetAnalysisResult()
+                            .Bind(analysisResult => GetDesignResult())
+                            .Bind(designResult => GetImplementationResult());
+
+            // Design fails internally by throwing an exception:
+            var product2 = GetAnalysisResult()
+                            .EnsuringBind(analysisResult => GetDesignResult(throwException: true)) // We can Ensure the transformation function against exceptions
+                            .Bind(designResult => GetImplementationResult()); // We assume there aren't any exceptions here 
+
+            // Implementation fails internally by throwing an exception:
+            var product3 = GetAnalysisResult()
+                            .Bind(analysisResult => GetDesignResult())
+                            .EnsuringBind(designResult => GetImplementationResult(throwException: true));
+
+            
+            // However sometimes the internal error caused somewhere in the guts of the function isn't as useful,
+            // and re-interpreting it to add more context at a higher level is more useful...
+            
+            // Same process but you can override how internal error is surfaced/presented using MapLeft:
+
+            var product4 = GetAnalysisResult()
+                            .EnsuringBind(analysisResult => GetDesignResult(throwException: true))  
+                                // Whatever the left value is, override/customize/surface it diffirently as a new Failure and add better context, ie product4
+                                .MapLeft( failure => UnexpectedFailure.Create($"Design Error Occured while creating product 4. Details were '{failure.Reason}'")) 
+                            .Bind(designResult => GetImplementationResult());
+            var product5 = GetAnalysisResult()
+                            .Bind(analysisResult => GetDesignResult())
+                            .EnsuringBind(designResult => GetImplementationResult(throwException: true))
+                                // Whatever the left value is, override/customize/surface it diffirently as a new Failure and add better context, ie product5
+                                .MapLeft( failure => UnexpectedFailure.Create($"Implementation Error Occured while creating product 5. Details were '{failure.Reason}'")); 
+            
+            Console.WriteLine($"Product1 result: {product1}");
+            Console.WriteLine($"Product2 result: {product2}");
+            Console.WriteLine($"Product3 result: {product3}");
+            Console.WriteLine($"Product4 result: {product4}");
+            Console.WriteLine($"Product5 result: {product5}");
+
+
+        }
+
+        /// <summary>
+        /// Do some Analysis Work
+        /// </summary>
+        /// <returns></returns>
+        public static Either<IAmFailure, string> GetAnalysisResult()
+        {
+            // Do some analysis work...
+            return "Analysis Success";
+        }
+
+        /// <summary>
+        /// Do some design work
+        /// </summary>
+        /// <param name="throwException"></param>
+        /// <returns></returns>
+        public static Either<IAmFailure, string> GetDesignResult(bool throwException = false)
+        {
+            // Do some design work...
+            return throwException 
+                ? throw new UnexpectedFailureException(UnexpectedFailure.Create("Design Width is too large. Error DES623 Ref=KJE871"))
+                : "Design Success";
+        }
+
+        /// <summary>
+        /// Do some implementation
+        /// </summary>
+        /// <param name="throwException"></param>
+        /// <returns></returns>
+        public static Either<IAmFailure, string> GetImplementationResult(bool throwException = false)
+        {
+            // Do some implemantion work...
+            return throwException 
+                ? throw new UnexpectedFailureException(UnexpectedFailure.Create("Implementation Volume exceeds mainframe size. Error IMP371 Ref=K763P"))
+                : "Implementation Success";
+        }
+    }   
+}