notebooks/0108-InterfacesErrorHandling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session 8: Abstract Classes, Interfaces, and Error Handling\n",
    "\n",
    "We've talked about the `protected` keyword and seen some interfaces in previous sessions when dealing with `IEnumerable` but haven't gotten into the science of Object Oriented Programming (OOP) and how we can create a hierarchy of objects that we can work with in our applications.  In some of the .NET frameworks like ASP.NET Core, interfaces and abstract classes are used in many places and are key to your successful use of the framework.\n",
    "\n",
    "## Abstract Classes\n",
    "\n",
    "Everything in C# is an object.  A class in C# can derive from another class in a **is a** relationship.  Let's look at the common Shape sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "abstract class Shape {\n",
    "    \n",
    "}\n",
    "\n",
    "class Triangle : Shape { }\n",
    "class Rectangle : Shape { }\n",
    "class Square : Rectangle { }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In C#, we declare a class is abstract with the `abstract` keyword.  This prevents anyone from being able to create this type of class directly and they can only `inherit` from it using the `: ClassName` notation you see in `Triangle`, `Rectangle`, and `Square`.  `Square` inherits from Rectangle so a `Square` **is a** `Rectangle` and also a `Shape`\n",
    "\n",
    "We can add methods to the `Shape` and they will be available in all of the other classes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "abstract class Shape {\n",
    "    public int Perimeter() { return 10; }\n",
    "    public decimal Area() { return 15; }\n",
    "}\n",
    "\n",
    "class Triangle : Shape { }\n",
    "class Rectangle : Shape { }\n",
    "class Square : Rectangle { }\n",
    "\n",
    "// consequently, we can execute the perimeter and area methods \n",
    "// on Triangle, Rectangle, and Square\n",
    "var t = new Square();\n",
    "display(t.Perimeter());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we know that `Perimeter` and `Area` are calculated differently for each shape.  We can add properties specific to each class, declare the `Perimiter` and `Area` methods as `abstract` and `override` them in each of the derived shape classes.  An `abstract method` or `abstract property`:\n",
    "- **Only appears** in an abstract class\n",
    "- **MUST** be implemented in a class that inherits from it. \n",
    "- Provides no body definition in the abstract class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">6</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">12</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>Side1Length</th><th>Side2Length</th><th>Side3Length</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">3</div></td><td><div class=\"dni-plaintext\">4</div></td><td><div class=\"dni-plaintext\">5</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "abstract class Shape {\n",
    "    public abstract int Perimeter();\n",
    "    public abstract decimal Area();\n",
    "}\n",
    "\n",
    "class Triangle : Shape { \n",
    "    public int Side1Length;\n",
    "    public int Side2Length;\n",
    "    public int Side3Length;\n",
    "    \n",
    "    public override int Perimeter() {\n",
    "        return Side1Length + Side2Length + Side3Length;\n",
    "    }\n",
    "    \n",
    "    public override decimal Area() {\n",
    "        var semiPerimeter = 0.5 * Perimeter();\n",
    "        \n",
    "        // Use Heron's Formula\n",
    "        return (decimal)Math.Sqrt(semiPerimeter * (semiPerimeter - Side1Length) * (semiPerimeter - Side2Length) * (semiPerimeter - Side3Length));\n",
    "    }\n",
    "    \n",
    "}\n",
    "class Rectangle : Shape {\n",
    "\n",
    "    public int Length;\n",
    "    public int Width;\n",
    "    \n",
    "    public override int Perimeter() {\n",
    "        return Length*2 + Width*2;\n",
    "    }\n",
    "    \n",
    "    public override decimal Area() {\n",
    "        return Length * Width;\n",
    "    }\n",
    "    \n",
    "\n",
    "}\n",
    "class Square : Rectangle { }\n",
    "\n",
    "// consequently, we can execute the perimeter and area methods on Triangle, Rectangle, and Square\n",
    "var t = new Triangle() { Side1Length=3, Side2Length=4, Side3Length=5};\n",
    "display(t.Area());\n",
    "display(t.Perimeter());\n",
    "\n",
    "/*\n",
    "var rect = new Rectangle { Length=3, Width=4 };\n",
    "display(rect.Perimeter());\n",
    "*/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can declare variables or parameters of the base type and pass in or assign the derived type.  This gives your classes more flexibility in their interactions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">15</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Rectangle is quadrilateral: True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Triangle is quadrilateral: False"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "abstract class Shape {\n",
    "    public int Perimeter() { return 10; }\n",
    "    public decimal Area() { return 15; }\n",
    "}\n",
    "\n",
    "class Triangle : Shape { }\n",
    "class Rectangle : Shape { }\n",
    "class Square : Rectangle { }\n",
    "\n",
    "Shape s = new Rectangle();\n",
    "display(s.Area());\n",
    "\n",
    "bool IsQuadrilateral(Shape s) {\n",
    "    return (s is Rectangle);\n",
    "}\n",
    "\n",
    "Shape t = new Triangle();\n",
    "display(\"Rectangle is quadrilateral: \" + IsQuadrilateral(s));\n",
    "display(\"Triangle is quadrilateral: \" + IsQuadrilateral(t));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Virtual Methods\n",
    "\n",
    "There are times when you want to provide a default implementation of a method, but provide the ability for subclasses to be able to override or add value to that method.  This is done through the use of the `virtual` keyword in the base class and the child classes use the `override` keyword or `new` keyword to re-implement those methods.  [New](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/new-modifier) will hide the base implementation and prevent any compiler errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">6</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">12</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>Side1Length</th><th>Side2Length</th><th>Side3Length</th><th>Length</th><th>Width</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">3</div></td><td><div class=\"dni-plaintext\">4</div></td><td><div class=\"dni-plaintext\">5</div></td><td><div class=\"dni-plaintext\">0</div></td><td><div class=\"dni-plaintext\">0</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "abstract class Shape {\n",
    "    public abstract int Perimeter();\n",
    "    public virtual decimal Area() {\n",
    "        return Length * Width;\n",
    "    }\n",
    "\n",
    "    public int Length;\n",
    "    public int Width;\n",
    "    \n",
    "}\n",
    "\n",
    "class Triangle : Shape { \n",
    "    public int Side1Length;\n",
    "    public int Side2Length;\n",
    "    public int Side3Length;\n",
    "    \n",
    "    public override int Perimeter() {\n",
    "        return Side1Length + Side2Length + Side3Length;\n",
    "    }\n",
    "    \n",
    "    public override decimal Area() {\n",
    "        var semiPerimeter = 0.5 * Perimeter();\n",
    "        \n",
    "        // Use Heron's Formula\n",
    "        return (decimal)Math.Sqrt(semiPerimeter * (semiPerimeter - Side1Length) * (semiPerimeter - Side2Length) * (semiPerimeter - Side3Length));\n",
    "    }\n",
    "    \n",
    "}\n",
    "class Rectangle : Shape {\n",
    "\n",
    "    public override int Perimeter() {\n",
    "        return Length*2 + Width*2;\n",
    "    }\n",
    "    \n",
    "}\n",
    "class Square : Rectangle { }\n",
    "\n",
    "// consequently, we can execute the perimeter and area methods on Triangle, Rectangle, and Square\n",
    "var t = new Triangle() { Side1Length=3, Side2Length=4, Side3Length=5};\n",
    "display(t.Area());\n",
    "display(t.Perimeter());\n",
    "display(t);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Sealed Classes](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/abstract-and-sealed-classes-and-class-members?WT.mc_id=visualstudio-twitch-jefritz)\n",
    "\n",
    "You can prevent another class from inheriting a class by using the `sealed` keyword.  Members of the class that were previously marked virtual are no longer available to be overridden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">16</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "abstract class Shape {\n",
    "    public abstract int Perimeter();\n",
    "    public abstract decimal Area();\n",
    "\n",
    "    public int Length;\n",
    "    public int Width;\n",
    "\n",
    "}\n",
    "\n",
    "// Try marking this class as sealed\n",
    "class Rectangle : Shape {\n",
    "\n",
    "    public override int Perimeter() {\n",
    "        return Length*2 + Width*2;\n",
    "    }\n",
    "    \n",
    "    // Also try marking this method as sealed\n",
    "    public override decimal Area() {\n",
    "        return Length * Width;\n",
    "    }\n",
    "    \n",
    "}\n",
    "class Square : Rectangle { \n",
    "\n",
    "    public override decimal Area() {\n",
    "        return Length*Length;\n",
    "    }\n",
    "\n",
    "}\n",
    "\n",
    "var s = new Square() { Length=4, Width=4};\n",
    "display(s.Area());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Interfaces](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/interfaces?WT.mc_id=visualstudio-twitch-jefritz)\n",
    "\n",
    "Interfaces define behaviors that a class or a struct **MUST** implement.  An interface can contain methods, properties, events and indexers.  They can also contain static methods with an implementation.  We previously saw collection objects that implement the `IEnumerable<T>` interface that allows LINQ methods to be executed against them.  These members in the interface are declared without scope, as they are required to be accessible to any object that wishes to interact with it.\n",
    "\n",
    "Assign one or multiple interfaces to a class or struct using the same `:` notation, separating each interface name with a comma.  You must then implement the content of the interface in your object's definition.\n",
    "\n",
    "By convention, many C# developers name their interfaces starting with the letter I. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "There was an error: Houston, we have a problem..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">1</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "interface ILogger {\n",
    "\n",
    "    void LogError(string error);\n",
    "    \n",
    "    int ErrorCount { get; }\n",
    "    \n",
    "}\n",
    "\n",
    "class DisplayLogger : ILogger {\n",
    "    \n",
    "    private static int _ErrorCount = 0;\n",
    "    \n",
    "    public void LogError(string error) {\n",
    "        display(\"There was an error: \" + error);\n",
    "        _ErrorCount++;\n",
    "    }\n",
    "    \n",
    "    public int ErrorCount { get { return _ErrorCount; }  }\n",
    "    \n",
    "}\n",
    "\n",
    "class DbLogger : ILogger {\n",
    "\n",
    "    public void LogError(string error) {\n",
    "        // do something in the database to log the error\n",
    "        display(\"Error logged to database\");\n",
    "    }\n",
    "    \n",
    "    public int ErrorCount { \n",
    "        get {\n",
    "            // query the database for the count of errors\n",
    "            return 0;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "}\n",
    "\n",
    "long DisplayErrorCount(ILogger logger) {\n",
    "    // do something with the eventlog object\n",
    "    return logger.ErrorCount;\n",
    "}\n",
    "\n",
    "ILogger logger = new DisplayLogger();\n",
    "logger.LogError(\"Houston, we have a problem...\");\n",
    "display(DisplayErrorCount(logger));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explicit Implementation\n",
    "\n",
    "Implementing methods of an interface without any modifiers in the previous example makes them visible to any interactions with the class type.  It is also possible to HIDE the interface so that it is only visible when the class is explicitly cast to the interface type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Shh...  I did a thing"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "public interface IDoAThing {\n",
    "    void DoTheThing();\n",
    "}\n",
    "\n",
    "class PublicThing : IDoAThing {\n",
    "    public void DoTheThing() {\n",
    "        display(\"I did the thing!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "class SecretThing : IDoAThing {\n",
    "    void IDoAThing.DoTheThing() {\n",
    "        display(\"Shh...  I did a thing\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// let's try to DoTheThing\n",
    "IDoAThing p = new SecretThing();\n",
    "p.DoTheThing();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Implementations\n",
    "\n",
    "Interfaces can implement other interfaces and can also provide default implementations of their methods.  A classic example of this use is to create new versions of interfaces without breaking compatibility with older interfaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Something else?"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "I did the thing!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "public interface IDoAThing2 : IDoAThing {\n",
    "    void DoSomethingElse();\n",
    "    void IDoAThing.DoTheThing() {\n",
    "        display(\"This is my default thing\");\n",
    "    }\n",
    "}\n",
    "\n",
    "class NewThing : IDoAThing2 {\n",
    "    public void DoSomethingElse() {\n",
    "        display(\"Something else?\");\n",
    "    }\n",
    "\n",
    "\t\tpublic void DoTheThing() \n",
    "\t\t{\n",
    "\t\t\tdisplay(\"I did the thing!\");\n",
    "\t\t}\n",
    "\n",
    "}\n",
    "\n",
    "// let's try to DoTheThing\n",
    "IDoAThing2 p = new NewThing();\n",
    "p.DoSomethingElse();\n",
    "p.DoTheThing();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Error Handling + Exceptions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/exceptions?WT.mc_id=visualstudio-twitch-jefritz)\n",
    "\n",
    "In C# and .NET, we work with errors through the `System.Exception` object.  This object can carry information about the site of the error, the type of the error, and includes a stacktrace to assist in debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">2</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "decimal Divide(decimal arg1, decimal arg2) {\n",
    "    return arg1 / arg2;\n",
    "}\n",
    "\n",
    "display(Divide(4, 2));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### try...catch\n",
    "\n",
    "For methods that we want to prevent interactions that could throw errors, we can wrap those commands in a `try..catch` block.  The `catch` block can receive an `Exception` type to allow for inspection,  Similarly to `if..else if...else` blocks, you can have multiple `catch` blocks to catch different exceptions with a final default that does not include an Exception argument to continue processing appropriately.\n",
    "\n",
    "If you would like to add information about the error, you can `throw` the exception to notify other calling methods about the error type incurred."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "You broke something else"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "Error",
     "evalue": "System.InvalidOperationException: Nullable object must have a value.\n   at System.Nullable`1.get_Value()\n   at Submission#53.Divide(Decimal arg1, Nullable`1 arg2)\n   at Submission#53.<<Initialize>>d__0.MoveNext()\n--- End of stack trace from previous location ---\n   at Microsoft.CodeAnalysis.Scripting.ScriptExecutionState.RunSubmissionsAsync[TResult](ImmutableArray`1 precedingExecutors, Func`2 currentExecutor, StrongBox`1 exceptionHolderOpt, Func`2 catchExceptionOpt, CancellationToken cancellationToken)",
     "output_type": "error",
     "traceback": [
      "System.InvalidOperationException: Nullable object must have a value.\n",
      "   at System.Nullable`1.get_Value()\n",
      "   at Submission#53.Divide(Decimal arg1, Nullable`1 arg2)\n",
      "   at Submission#53.<<Initialize>>d__0.MoveNext()\n",
      "--- End of stack trace from previous location ---\n",
      "   at Microsoft.CodeAnalysis.Scripting.ScriptExecutionState.RunSubmissionsAsync[TResult](ImmutableArray`1 precedingExecutors, Func`2 currentExecutor, StrongBox`1 exceptionHolderOpt, Func`2 catchExceptionOpt, CancellationToken cancellationToken)"
     ]
    }
   ],
   "source": [
    "decimal Divide(decimal arg1, decimal? arg2) {\n",
    "\n",
    "    try {\n",
    "        return arg1 / arg2.Value;\n",
    "    } catch (DivideByZeroException e) {\n",
    "        display(\"Division by zero is not allowed\");\n",
    "        return 0;\n",
    "    } catch {\n",
    "        display(\"You broke something else\");\n",
    "        throw;\n",
    "    }\n",
    "}\n",
    "\n",
    "display(Divide(4, 2));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Clean up after try...catch using finally](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/exceptions/how-to-execute-cleanup-code-using-finally?WT.mc_id=visualstudio-twitch-jefritz)\n",
    "\n",
    "A good practice is to clean up the state of your methods that threw an exception, and we use the `finally` block to execute code after a `catch` block has been executed.  The `finally` block is **ALWAYS** executed when your application throws an error.  This is particularly effective when you are working with external resources like a file on disk or a database connection. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cleaning up code here..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">2</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "decimal DivideCleanup(decimal arg1, decimal? arg2) {\n",
    "\n",
    "    try {\n",
    "        return arg1 / arg2.Value;\n",
    "    } catch {\n",
    "        display(\"You broke something else\");\n",
    "        throw;\n",
    "    } finally {\n",
    "        display(\"Cleaning up code here...\");\n",
    "    }\n",
    "}\n",
    "\n",
    "display(DivideCleanup(4, 2));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create our own Exception\n",
    "\n",
    "As the complexity of your applications grows, you should create your own exception objects that more clearly define the error scenario that has been reached.  This allows your developer teammates and customers to receive richer error reports and triage those problems appropriately.  You can inherit from the base Exception object.  By convention, C# and .NET developers typically name their exception classes **Something**Exception to make it clear that the object contains error information.  \n",
    "\n",
    "There are four constructor signatures that you _SHOULD_ implement in your custom exception class, and then you can implement any other properties or methods you would like.  These are not required, but are considered good practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cannot divide by zero"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4 / 0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "   at Submission#58.DivideHandled(Decimal arg1, Nullable`1 arg2)\n",
       "   at Submission#58.<<Initialize>>d__0.MoveNext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "public class BetterDivisionException : System.Exception\n",
    "{\n",
    "    public BetterDivisionException() : base(\"Unable to divide by zero\") { }\n",
    "    public BetterDivisionException(string message) : base(message) { }\n",
    "    public BetterDivisionException(string message, System.Exception inner) : base(message, inner) { }\n",
    "\n",
    "    // A constructor is needed for serialization when an\n",
    "    // exception propagates from a remoting server to the client.\n",
    "    protected BetterDivisionException(System.Runtime.Serialization.SerializationInfo info,\n",
    "        System.Runtime.Serialization.StreamingContext context) : base(info, context) { }\n",
    "    \n",
    "    // Remember, division is Dividend / Divisor\n",
    "    \n",
    "    public decimal? Dividend { get; set; }\n",
    "    public decimal? Divisor { get; set; }\n",
    "    \n",
    "}\n",
    "\n",
    "decimal DivideHandled(decimal arg1, decimal? arg2) {\n",
    "\n",
    "/**/\n",
    "    if (arg2 == null) throw new BetterDivisionException(\"Cannot divide by null\")    { Dividend=arg1, Divisor=arg2};\n",
    "    if (arg2.Value == 0) throw new BetterDivisionException(\"Cannot divide by zero\") { Dividend=arg1, Divisor=arg2};\n",
    "/**/\n",
    "\n",
    "    return arg1 / arg2.Value;\n",
    "\n",
    "}\n",
    "\n",
    "try {\n",
    "\n",
    "    display(DivideHandled(4, 0));\n",
    "\n",
    "} catch (BetterDivisionException e) {\n",
    "    display(e.Message);\n",
    "    display($\"{e.Dividend} / {e.Divisor}\");\n",
    "    display(e.StackTrace);\n",
    "} catch (DivideByZeroException e) {\n",
    "    display(\"Dividing by zero\");\n",
    "    throw;\n",
    "} catch {\n",
    "    display(\"Did something else\");\n",
    "    throw;\n",
    "}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".cs",
   "mimetype": "text/x-csharp",
   "name": "C#",
   "pygments_lexer": "csharp",
   "version": "8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}