notebooks/0107-Errata_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Session 7: The Errata Review No. 1\n",
    "\n",
    "This session is a review of the prior six sessions and covering those pieces that were left off.  Not necessarily errors, but missing pieces to complete the picture from the series.  These topics answer some questions and will help complete the picture of the C# language features discussed to this point.\n",
    "\n",
    "## Increment and Assignment operators\n",
    "\n",
    "In session 1, we reviewed operators and interacting with numbers.  We skipped the [increment](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/arithmetic-operators?WT.mc_id=visualstudio-twitch-jefritz#increment-operator-) `++` and [decrement](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/arithmetic-operators?WT.mc_id=visualstudio-twitch-jefritz#decrement-operator---) `--` operators.  These operators allow you to increment and decrement values quickly.  You can place these operators before and after the variable you would like to act on, and they will be incremented or decremented before or after being returned.\n",
    "\n",
    "Let's take a look:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var counter = 1;\n",
    "display(counter++); // Running ++ AFTER counter will display 1\n",
    "display(counter);   // and then display 2 in the next row"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">1</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">2</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var counter = 1;\n",
    "display(--counter); // Running ++ BEFORE counter will display 2 as it is incrementing the variable before \n",
    "                    // displaying it"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Logical negation operator\n",
    "\n",
    "Sometimes you want to invert the value of a boolean, converting from `true` to `false` and from `false` to `true`.  Quite simply, just prefix your test or boolean value with  the [negation operator](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/boolean-logical-operators?WT.mc_id=visualstudio-twitch-jefritz#logical-negation-operator-) `!` to invert values"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var isTrue = true;\n",
    "display(!isTrue);\n",
    "\n",
    "display(!(1 > 2))\n"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">False</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">True</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## TypeOf, GetType and NameOf methods\n",
    "\n",
    "Sometimes you need to work with the type of a variable or the name of a value.  The methods `typeof`, `GetType()` and `nameof` allow you to interact with the types and pass them along for further interaction.\n",
    "\n",
    "[typeof](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/type-testing-and-cast?WT.mc_id=visualstudio-twitch-jefritz#typeof-operator) allows you to get a reference to a type for use in methods where you need to inspect the underlying type system"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "display(typeof(System.IO.StreamReader));"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span><a href=\"https://docs.microsoft.com/dotnet/api/system.io.streamreader?view=net-5.0\">System.IO.StreamReader</a></span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Conversely, the `GetType()` method allows you to get the type information for a variable already in use.  Every object in C# has the `GetType()` method available."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var myInt = 5;\n",
    "display(myInt.GetType());"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span><a href=\"https://docs.microsoft.com/dotnet/api/system.int32?view=net-5.0\">System.Int32</a></span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The [`nameof` expression](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/nameof?WT.mc_id=visualstudio-twitch-jefritz) gives the name of a type or member as a string.  This is particularly useful when you are generating error messages."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class People {\n",
    "    public string Surname { get; set; }\n",
    "    public TimeSpan CalculateAge() => DateTime.Now.Subtract(new DateTime(2000,1,1));\n",
    "}\n",
    "\n",
    "var fritz = new People { Surname=\"Fritz\" };\n",
    "\n",
    "display(nameof(People));\n",
    "display(typeof(People));\n",
    "display(nameof(fritz.Name) + \": \" + fritz.Surname);"
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "Error",
     "evalue": "(10,22): error CS1061: 'People' does not contain a definition for 'Name' and no accessible extension method 'Name' accepting a first argument of type 'People' could be found (are you missing a using directive or an assembly reference?)",
     "traceback": [
      "(10,22): error CS1061: 'People' does not contain a definition for 'Name' and no accessible extension method 'Name' accepting a first argument of type 'People' could be found (are you missing a using directive or an assembly reference?)"
     ]
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// Get Types from string\n",
    "\n",
    "var streamType = \"System.IO.MemoryStream\";\n",
    "//var myStream = new DateTime();\n",
    "var myStream = Activator.CreateInstance(\"System.IO\", streamType);\n",
    "\n",
    "display(myStream.GetType());"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "System.Runtime.Remoting.ObjectHandle, System.Private.CoreLib, Version=5.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## String Formatting\n",
    "\n",
    "Formatting and working with strings or text is a fundamental building block of working with user-input.  We failed to cover the various ways to interact with those strings.  Let's take a look at a handful of the ways to work with text data.\n",
    "\n",
    "## Concatenation\n",
    "\n",
    "You may have seen notes and output that concatenates strings by using the [`+` operator](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/addition-operator?WT.mc_id=visualstudio-twitch-jefritz#string-concatenation).  This is the simplest form of concatenation and only works when both sides of the `+` operator are strings.  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var greeting = \"Hello\";\n",
    "display(greeting + \" World!\");\n",
    "\n",
    "// += also works\n",
    "greeting += \" C# developers\";\n",
    "display(greeting);"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello World!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Hello C# developers"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "If you have multiple strings to combine, the `+` operator gets a little unwieldy and is not as performance aware as several other techniques.  We can [combine multiple strings](https://docs.microsoft.com/en-us/dotnet/csharp/how-to/concatenate-multiple-strings?WT.mc_id=visualstudio-twitch-jefritz) using the `Concat`, `Join`, `Format` and interpolation features of C#."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var greeting = \"Good\";\n",
    "var time = DateTime.Now.Hour < 12 && DateTime.Now.Hour > 3  ? \"Morning\" : DateTime.Now.Hour < 17 ? \"Afternoon\" : \"Evening\";\n",
    "var name = \"Visual Studio Channel\";\n",
    "\n",
    "// Use string.concat with a comma separated list of arguments \n",
    "display(string.Concat(greeting, \" \", time, \" \", name + \"!\"));"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Good Morning Visual Studio Channel!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var terms = new [] {greeting, time, name};\n",
    "\n",
    "// Use string.Join to assembly values in an array with a separator\n",
    "display(string.Join(\" \", terms));"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Good Morning Visual Studio Channel"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// Use string.Format to configure a template string and load values into it based on position\n",
    "var format = \"Good {0} {1}\";\n",
    "display(string.Format(format, time, name));"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Good Morning Visual Studio Channel"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// With C# 7 and later you can now use string interpolation to format a string.  \n",
    "// Simply prefix a string with a $ to allow you to insert C# expressions in { } inside\n",
    "// a string\n",
    "\n",
    "var names = new string[] {\"Fritz\", \"Scott\", \"Maria\", \"Jayme\"};\n",
    "\n",
    "display($\"Good {time} {name} {string.Join(\",\",names)}\");\n"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Good Morning Visual Studio Channel Fritz,Scott,Maria,Jayme"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// Another technique that can be used when you don't know the exact number of strings\n",
    "// to concatenate is to use the StringBuilder class.\n",
    "\n",
    "var sb = new StringBuilder();\n",
    "sb.AppendFormat(\"Good {0}\", time);\n",
    "sb.Append(\" \");\n",
    "sb.Append(name);\n",
    "\n",
    "display(sb.ToString());"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Good Morning\n",
       "Visual Studio Channel"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Parsing strings with Split\n",
    "\n",
    "You can turn a string into an array of strings using the `Split` method on a string variable.  Pass the character that identifies the boundary between elements of your array to turn it into an array:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var phrase = \"Good Morning Cleveland\";\n",
    "display(phrase.Split(' '));\n",
    "display(phrase.Split(' ')[2]);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>value</th></tr></thead><tbody><tr><td>0</td><td>Good</td></tr><tr><td>1</td><td>Morning</td></tr><tr><td>2</td><td>Cleveland</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Cleveland"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var fibonacci = \"1,1,2,3,5,8,13,21\";\n",
    "display(fibonacci.Split(','));"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>value</th></tr></thead><tbody><tr><td>0</td><td>1</td></tr><tr><td>1</td><td>1</td></tr><tr><td>2</td><td>2</td></tr><tr><td>3</td><td>3</td></tr><tr><td>4</td><td>5</td></tr><tr><td>5</td><td>8</td></tr><tr><td>6</td><td>13</td></tr><tr><td>7</td><td>21</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## A Deeper Dive on Enums\n",
    "\n",
    "We briefly discussed enumeration types in session 3 and touched on using the `enum` keyword to represent related values.  Let's go a little further into conversions and working with the enum types.\n",
    "\n",
    "### Conversions\n",
    "\n",
    "[Enum types](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/enum?WT.mc_id=visualstudio-twitch-jefritz) are extensions on top of numeric types.  By default, they wrap the `int` integer data type.  While this base numeric type can be overridden, we can also convert data into and out of the enum using standard explicit conversion operators  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "enum DotNetLanguages : byte {\n",
    "    csharp = 100,\n",
    "    visual_basic = 2,\n",
    "    fsharp = 3\n",
    "}\n",
    "\n",
    "var myLanguage = DotNetLanguages.csharp;\n",
    "display(myLanguage);\n",
    "display((byte)myLanguage);\n",
    "display((int)myLanguage);\n",
    "\n",
    "// Push a numeric type INTO DotNetLanguages\n",
    "myLanguage = (DotNetLanguages)2;\n",
    "display(myLanguage);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span>csharp</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">100</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">100</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<span>visual_basic</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Working with strings using Parse and TryParse\n",
    "\n",
    "What about the string value of the enumeration itself?  We can work with that using the [`Parse`](https://docs.microsoft.com/en-us/dotnet/api/system.enum.parse?view=netcore-3.1&WT.mc_id=visualstudio-twitch-jefritz) and [`TryParse`](https://docs.microsoft.com/en-us/dotnet/api/system.enum.tryparse?view=netcore-3.1&WT.mc_id=visualstudio-twitch-jefritz) methods of the Enum object to convert a string into the Enum type"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var thisLanguage = \"csharp\";\n",
    "myLanguage = Enum.Parse<DotNetLanguages>(thisLanguage);\n",
    "display(myLanguage);\n",
    "\n",
    "// Use the optional boolean flag parameter to indicate if the Parse operation is case-insensitive \n",
    "thisLanguage = \"CSharp\";\n",
    "myLanguage = Enum.Parse<DotNetLanguages>(thisLanguage, true);\n",
    "display(myLanguage);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span>csharp</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<span>csharp</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// TryParse has a similar signature, but returns a boolean to indicate success \n",
    "var success = Enum.TryParse<DotNetLanguages>(\"Visual_Basic\", true, out var foo);\n",
    "display(success);\n",
    "display(foo);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">True</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<span>visual_basic</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### GetValues and the Enumeration's available values\n",
    "\n",
    "The constant values of the enum type can be exposed using the [Enum.GetValues](https://docs.microsoft.com/en-us/dotnet/api/system.enum.getvalues?view=netcore-3.1&WT.mc_id=visualstudio-twitch-jefritz) method.  This returns an array of the numeric values of the enum.  Let's inspect our `DotNetLanguages` type: "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var languages = Enum.GetValues(typeof(DotNetLanguages));\n",
    "display(languages);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>value</th></tr></thead><tbody><tr><td>0</td><td><span>visual_basic</span></td></tr><tr><td>1</td><td><span>fsharp</span></td></tr><tr><td>2</td><td><span>csharp</span></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// We can convert back to the named values of the enum with a little conversion\n",
    "foreach (var l in languages) {\n",
    "    display((DotNetLanguages)l);\n",
    "}"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span>visual_basic</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<span>fsharp</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<span>csharp</span>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Classes vs. Structs\n",
    "\n",
    "In the second session we introduced the `class` keyword to create reference types.  There is another keyword, `struct`, that allows you to create [Structure](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct?WT.mc_id=visualstudio-twitch-jefritz) **value types** which will be allocated in memory and reclaimed more quickly than a class.  While a `struct` looks like a class in syntax, there are some constraints:\n",
    "\n",
    "- A constructor must be defined that configures all properties / fields\n",
    "- The parameterless constructor is not allowed\n",
    "- Instance Fields / Properties cannot be assigned in their declaration\n",
    "- Finalizers are not allowed\n",
    "- A struct cannot inherit from another type, but can implement interfaces \n",
    "\n",
    "Structs are typically used to store related numeric types.  Let's tinker with an example:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "struct Rectangle {\n",
    "    \n",
    "    public Rectangle(int length, int width) {\n",
    "        this.Length = length;\n",
    "        this.Width = width;\n",
    "    }\n",
    "    \n",
    "    public static readonly int Depth = DateTime.Now.Minute;\n",
    "    \n",
    "    public int Length {get;set;}\n",
    "    public int Width {get;set;}\n",
    "    \n",
    "    public int Area => Length * Width;\n",
    "    public int Perimeter { get { return Length*2 + Width*2;}}\n",
    "    \n",
    "}\n",
    "\n",
    "var myRectangle = new Rectangle(2, 5);\n",
    "display(myRectangle);\n",
    "display(Rectangle.Depth);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>Length</th><th>Width</th><th>Area</th><th>Perimeter</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">2</div></td><td><div class=\"dni-plaintext\">5</div></td><td><div class=\"dni-plaintext\">10</div></td><td><div class=\"dni-plaintext\">14</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">46</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "enum CountryCode {\n",
    "    USA = 1\n",
    "}\n",
    "\n",
    "struct PhoneNumber {\n",
    "    \n",
    "    public PhoneNumber(CountryCode countryCode, string exchange, string number) {\n",
    "        this.CountryCode = countryCode;\n",
    "        this.Exchange = exchange;\n",
    "        this.Number = number;\n",
    "    }\n",
    "    \n",
    "    public CountryCode CountryCode { get; set; }\n",
    "    public string Exchange { get; set; }\n",
    "    public string Number {get; set; }\n",
    "    \n",
    "}\n",
    "\n",
    "var jennysNumber = new PhoneNumber(CountryCode.USA, \"867\", \"5309\");\n",
    "display(jennysNumber);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>CountryCode</th><th>Exchange</th><th>Number</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">USA</div></td><td><div class=\"dni-plaintext\">867</div></td><td><div class=\"dni-plaintext\">5309</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>CountryCode</th><th>Exchange</th><th>Number</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">USA</div></td><td><div class=\"dni-plaintext\">867</div></td><td><div class=\"dni-plaintext\">1234</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### When should I use a struct instead of a class?\n",
    "\n",
    "This is a common question among C# developers.  How do you decide?  Since a `struct` is a simple value type, there are [several guidelines to help you decide](https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/choosing-between-class-and-struct?WT.mc_id=visualstudio-twitch-jefritz):\n",
    "\n",
    "**Choose a struct INSTEAD of a class if all of these are true about the type:**\n",
    "- It will be small and short-lived in memory\n",
    "- It represents a single value\n",
    "- It can be represented in 16 bytes or less\n",
    "- It will not be changed, and is immutable\n",
    "- You will not be converting it to a class (called `boxing` and `unboxing`)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Stopping and Skipping Loops \n",
    "\n",
    "In session four we learned about loops using `for`, `while`, and `do`.  We can speed up our loop by moving to the next iteration in the loop and we can stop a loop process completely using the `continue` and `break` keywords.  Let's take a look at some examples:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for (var i=1; i<10_000_000; i++) {\n",
    "    display(i);\n",
    "    if (i%10 == 0) break; // Stop if the value is a multiple of 10\n",
    "}"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">1</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">2</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">3</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">4</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">5</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">6</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">7</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">8</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">9</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">10</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "// We can skip an iteration in the loop using the continue keyword\n",
    "for (var i = 1; i<10_000_000; i++) {\n",
    "    if (i%3 == 0) continue; // Skip this iteration\n",
    "    display(i);\n",
    "    if (i%10 == 0) break;\n",
    "}"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">1</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">2</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">4</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">5</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">7</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">8</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">10</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Initializing Collections\n",
    "\n",
    "In the fifth session we explored Arrays, Lists, and Dictionary types.  We saw that you could initialize an array with syntax like the following:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var fibonacci = new int[] {1,1,2,3,5,8,13};\n",
    "display(fibonacci);\n",
    "\n",
    "//var coordinates = new int[,] {{1,2}, {2,3}};\n",
    "//display(coordinates);"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can also initialize List and Dictionary types using the curly braces notation:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var myList = new List<string> {\n",
    "    \"C#\",\n",
    "    \"Visual Basic\",\n",
    "    \"F#\"\n",
    "};\n",
    "display(myList);\n",
    "\n",
    "var myShapes = new List<Rectangle> {\n",
    "    new Rectangle(2, 5),\n",
    "    new Rectangle(3, 4),\n",
    "    new Rectangle(4, 3)\n",
    "};\n",
    "display(myShapes);\n"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>value</th></tr></thead><tbody><tr><td>0</td><td>C#</td></tr><tr><td>1</td><td>Visual Basic</td></tr><tr><td>2</td><td>F#</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>Length</th><th>Width</th><th>Area</th><th>Perimeter</th></tr></thead><tbody><tr><td>0</td><td><div class=\"dni-plaintext\">2</div></td><td><div class=\"dni-plaintext\">5</div></td><td><div class=\"dni-plaintext\">10</div></td><td><div class=\"dni-plaintext\">14</div></td></tr><tr><td>1</td><td><div class=\"dni-plaintext\">3</div></td><td><div class=\"dni-plaintext\">4</div></td><td><div class=\"dni-plaintext\">12</div></td><td><div class=\"dni-plaintext\">14</div></td></tr><tr><td>2</td><td><div class=\"dni-plaintext\">4</div></td><td><div class=\"dni-plaintext\">3</div></td><td><div class=\"dni-plaintext\">12</div></td><td><div class=\"dni-plaintext\">14</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var myDictionary = new Dictionary<int, string> {\n",
    "    {100, \"C#\"},\n",
    "    {200, \"Visual Basic\"},\n",
    "    {300, \"F#\"}\n",
    "};\n",
    "display(myDictionary);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>key</i></th><th>value</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">100</div></td><td>C#</td></tr><tr><td><div class=\"dni-plaintext\">200</div></td><td>Visual Basic</td></tr><tr><td><div class=\"dni-plaintext\">300</div></td><td>F#</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Dictionary Types\n",
    "\n",
    "This question was raised on an earlier stream, and [David Fowler](https://twitter.com/davidfowl) (.NET Engineering Team Architect) wrote a series of [Tweets](https://twitter.com/davidfowl/status/1444467842418548737) about it based on discussions with [Stephen Toub](https://twitter.com/stephentoub/) (Architect for the .NET Libraries) \n",
    "\n",
    "There are 4 built-in Dictionary types with .NET:\n",
    "\n",
    "- [Hashtable](https://docs.microsoft.com/dotnet/api/system.collections.hashtable)\n",
    "  - This is the most efficient dictionary type with keys organized by the hash of their values.\n",
    "  - David says: \"Good read speed (no lock required), sameish weight as dictionary but more expensive to mutate and no generics!\""
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "var hashTbl = new Hashtable();\n",
    "hashTbl.Add(\"key1\", \"value1\");\n",
    "hashTbl.Add(\"key2\", \"value2\");\n",
    "\n",
    "display(hashTbl);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>key</i></th><th>value</th></tr></thead><tbody><tr><td>key2</td><td>value2</td></tr><tr><td>key1</td><td>value1</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "\n",
    "- [Dictionary](https://docs.microsoft.com/dotnet/api/system.collections.generic.dictionary-2)\n",
    "  - A generic dictionary object that you can search easily by keys.\n",
    "  - David says: \"Lightweight to create and 'medium' update speed.  Poor read speed when used with a lock.  As an immutable object it has the best read speed and heavy to update.\""
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "private readonly Dictionary<string,string> readonlyDictionary = new() { \n",
    "\t{\"txt\", \"Text Files\"},\n",
    "\t{\"wav\", \"Sound Files\"},\n",
    "\t{\"mp3\", \"Compressed Music Files\"},\n",
    "};\n",
    "\n",
    "display(readonlyDictionary);\n",
    "\n",
    "readonlyDictionary.Add(\"mp4\", \"Video Files\"); \n",
    "display(readonlyDictionary);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>key</i></th><th>value</th></tr></thead><tbody><tr><td>txt</td><td>Text Files</td></tr><tr><td>wav</td><td>Sound Files</td></tr><tr><td>mp3</td><td>Compressed Music Files</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>key</i></th><th>value</th></tr></thead><tbody><tr><td>txt</td><td>Text Files</td></tr><tr><td>wav</td><td>Sound Files</td></tr><tr><td>mp3</td><td>Compressed Music Files</td></tr><tr><td>mp4</td><td>Video Files</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "- [ConcurrentDictionary](https://docs.microsoft.com/dotnet/api/system.collections.concurrent.concurrentdictionary-2)\n",
    "  - A thread-safe version of Dictionary that is optimized for use by multiple threads.  It is not recommended for use by a single thread due to the extra overhead allocate for multi-threaded support.\n",
    "  - David says: \"Poorish read speed, no locking required but more allocations require to update than a dictionary.\"\n",
    "\n",
    "Instead of Adding, Updating and Getting values from the ConcurrentDictionary, we TryAdd, TryUpdate, and TryGetValue.  TryAdd will return false if the key already exists, and TryUpdate will return false if the key does not exist.  TryGetValue will return false if the key does not exist.  We can also AddOrUpdate to add a value if the key does not exist and GetOrAdd to add a value if the key does not exist."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "using System.Collections.Concurrent;\n",
    "\n",
    "var cd = new ConcurrentDictionary<string, string>();\n",
    "cd.AddOrUpdate(\"key1\", \"value1\", (key, oldValue) => \"value2\");\n",
    "cd.AddOrUpdate(\"key1\", \"value1\", (key, oldValue) => \"value2\");\n",
    "\n",
    "display(cd.TryAdd(\"key2\", \"value1\"));\n",
    "display(cd);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">True</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">False</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>key</i></th><th>value</th></tr></thead><tbody><tr><td>key2</td><td>value1</td></tr><tr><td>key1</td><td>value2</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "- [ImmutableDictionary](https://docs.microsoft.com/dotnet/api/system.collections.immutable.immutabledictionary-2)\n",
    "  - A new type in .NET Core and .NET 5/6 that is a read-only version of Dictionary.  Changes to it's contents involve creation of a new Dictionary object and copying of the contents.\n",
    "  - David says: \"Poorish read speed, no locking required but more allocations required to update than a dictionary.\""
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "using System.Collections.Immutable;\n",
    "\n",
    "var d = ImmutableDictionary.CreateBuilder<string,string>();\n",
    "d.Add(\"key1\", \"value1\");\n",
    "d.Add(\"key2\", \"value2\");\n",
    "\n",
    "var theDict = d.ToImmutable();\n",
    "//theDict = theDict.Add(\"key3\", \"value3\");\n",
    "display(theDict);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>key</i></th><th>value</th></tr></thead><tbody><tr><td>key1</td><td>value1</td></tr><tr><td>key2</td><td>value2</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Const and Static keywords\n",
    "\n",
    "\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "const int Five = 5;\n",
    "\n",
    "// Five = 6;\n",
    "display(Five);"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class Student {\n",
    "    \n",
    "    public const decimal MaxGPA = 5.0m;\n",
    "    \n",
    "}\n",
    "\n",
    "display(Student.MaxGPA);"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class Student {\n",
    "    \n",
    "    public static bool InClass = false;\n",
    "    public string Name { get; set; }\n",
    "\n",
    "    public override string ToString() {\n",
    "        return Name + \": \" + Student.InClass;\n",
    "    }\n",
    "\n",
    "    public static void GoToClass() {\n",
    "        Student.InClass = true;\n",
    "    }\n",
    "    \n",
    "    public static void DitchClass() {\n",
    "        Student.InClass = false;\n",
    "    }\n",
    "    \n",
    "}\n",
    "\n",
    "var students = new Student[] { new Student { Name=\"Hugo\" }, new Student {Name=\"Fritz\"}, new Student {Name=\"Lily\"}};\n",
    "foreach (var s in students) {\n",
    "    display(s.ToString());\n",
    "}"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "Student.GoToClass();\n",
    "foreach (var s in students) {\n",
    "    display(s.ToString());\n",
    "}"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "static class DateMethods {\n",
    "    \n",
    "    public static int CalculateAge(DateTime date1, DateTime date2) {\n",
    "        return 10;\n",
    "    }\n",
    "    \n",
    "}\n",
    "\n",
    "display(DateMethods.CalculateAge(DateTime.Now, DateTime.Now))"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  }
 ],
 "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
}