notebooks/0102-Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Session 2: Making our own Types with Classes, and Scope\n",
    "\n",
    "C# is an object-oriented language in which everything is an object, with the type `object` as the most basic types that all other types inherit from. In this session, we will learn to create our own types and how they can relate to other types using Interfaces and various scopes.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    Refer back to Session 1 for more details about built-in and primitive Types\n",
    "</div>\n",
    "\n",
    "## First, a word on memory utilization and garbage collection\n",
    "\n",
    "Memory with C# and .NET is dynamically allocated and reclaimed by the .NET runtime as you no longer reference variables.  The .NET **Garbage Collector** runs occasionally, freeing memory that was previously used by variables.  There are ways to tune the garbage collector and in-depth studies of how it manages memory that are much more advanced than this part of the series.  If you'd like to read more, check the [official .NET garbage collector documentation](https://docs.microsoft.com/dotnet/standard/garbage-collection/fundamentals?WT.mc_id=visualstudio-twitch-jefritz)\n",
    "\n",
    "## The Class keyword and defining reference types\n",
    "\n",
    "The `class` keyword is used to create the most common type, a reference type, that you can create and interact with using C#.  As a reference type, every instance of your classes will be stored on the memory heap.\n",
    "\n",
    "Classes are declared with a name, a block of content, and with one or more access modifiers.  That syntax is followed by curly-braces `{ }` that enclose the contents of the class definition.  Let's declare our first class for use in this notebook:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class Student \r\n",
    "{\r\n",
    "    \r\n",
    "}"
   ],
   "outputs": [],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "This class, named `Student` has no modifiers and no content.  By default, classes are `internal` in scope - meaning that they can only be interacted with by other classes in the same library or program.  You can explicitly use the `internal` keyword before the `class` keyword to ensure that your class declaration is internal in scope.\n",
    "\n",
    "Classes are typically written into their own files, one class per file, with the filename matching the name of the class inside.  In this case, we would create `Student.cs`\n",
    "\n",
    "Classes can also be made `public`, allowing access from outside the library or program that they are compiled with.  Inside the class, you can declare and add features like:\n",
    "\n",
    "- **Constructors:** A method that is used to create an instance of the class\n",
    "- **Finalizers:** A method that is called when the class is cleaned up by the garbage collector\n",
    "- **Fields:** A variable owned by the class and typically used in `private` or `protected` scope, `private` by default when no access modeifier is used\n",
    "- **Constants:** Values defined at compile time that never change for the life of the program\n",
    "- **Properties:** A flexible mechanism that allows interaction with values stored in a class\n",
    "- **Methods:** An action-taking code block that contains multiple statements, can accept parameters, and can return values\n",
    "- **Events:** An interaction point that allows for notification of other classes when something of interest occurs\n",
    "- **Delegates:** A type that can reference a method based on matching parameters and return types \n",
    "- **Operators:** Defines how the class interacts with the various built-in .NET/C# operators \n",
    "\n",
    "Let's add some properties and a constructor to our `Student` class:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "internal class Student \r\n",
    "{\r\n",
    "\r\n",
    "    /* A publicly accessible constructor that doesn't do anything.  \r\n",
    "    \r\n",
    "    This public constructor is created by default by the compiler, and does not need to\r\n",
    "    explicitly be added if no action methods take place during construction\r\n",
    "    */\r\n",
    "    public Student() \r\n",
    "    { \r\n",
    "    }\r\n",
    "\r\n",
    "    // Simple publicly accessible properties that define the FirstName, LastName, and Age\r\n",
    "    // of our Student\r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    public byte Age { get; set; }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "\r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student();\r\n",
    "s.FirstName = \"Mary\";\r\n",
    "s.LastName = \"Contrary\";\r\n",
    "s.Age = 25;\r\n",
    "s.IsEnrolled = true;\r\n",
    "\r\n",
    "display(s);   // This is NOT a C# or .NET function, but rather a Jupyter notebook feature to display \r\n",
    "              //the content inside parenthesis ( )\r\n",
    "    \r\n",
    "var fritz = new Student() {\r\n",
    "    FirstName = \"Jeff\",\r\n",
    "    LastName = \"Fritz\",\r\n",
    "    Age = 20,\r\n",
    "    IsEnrolled = false\r\n",
    "};\r\n",
    "display(fritz);\r\n",
    "    "
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">Mary</div></td><td><div class=\"dni-plaintext\">Contrary</div></td><td><div class=\"dni-plaintext\">25</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">Jeff</div></td><td><div class=\"dni-plaintext\">Fritz</div></td><td><div class=\"dni-plaintext\">20</div></td><td><div class=\"dni-plaintext\">False</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "There's more information in the [class keyword reference in the official documentation](https://docs.microsoft.com/dotnet/csharp/language-reference/keywords/class?WT.mc_id=visualstudio-twitch-jefritz)\r\n",
    "\r\n",
    "## Constructors\r\n",
    "\r\n",
    "Constructors are an active block of code that is defined with an access modifier and optionally some parameters to help with the initialization of the object.  In the above class, our constructor does not take any arguments and it publicly accessible - any code can use that constructor to create an instance of this class.\r\n",
    "\r\n",
    "The `var s = new Student();` statement creates a new Student object and calls the constructor method.  We can have our `Student` class do some initialization there if it makes sense in configuring the object."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    public Student() \r\n",
    "    {\r\n",
    " \r\n",
    "        // A student is enrolled by default\r\n",
    "        IsEnrolled = true;\r\n",
    "        \r\n",
    "    }\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    public byte Age { get; set; }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student();\r\n",
    "s.FirstName = \"Joe\";\r\n",
    "s.LastName = \"Bag O'Donuts\";\r\n",
    "s.Age = 30;\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">Joe</div></td><td><div class=\"dni-plaintext\">Bag O&#39;Donuts</div></td><td><div class=\"dni-plaintext\">30</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Try adding other initialization values in the constructor method and tinkering with the output.\n",
    "\n",
    "Constructors can also be **overloaded**, that is, you can create multiple constructors that accept various input parameters to allow your class to be created different ways.  Let's revisit our student and add a constructor with input variables for age, since every student has an age."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "\r\n",
    "    public Student(string firstName, string lastName, byte age) \r\n",
    "    {\r\n",
    "        \r\n",
    "        this.FirstName = firstName;\r\n",
    "        this.LastName = lastName;\r\n",
    "        this.Age = age;\r\n",
    "        \r\n",
    "         // A student is enrolled by default\r\n",
    "        IsEnrolled = true;\r\n",
    "        \r\n",
    "    }\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    public byte Age { get; set; }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student(\"Jeff\", \"Fritz\", 30);\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">Jeff</div></td><td><div class=\"dni-plaintext\">Fritz</div></td><td><div class=\"dni-plaintext\">30</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Improve the above code to ensure that EVERY student created has a name and an age. \n",
    "\n",
    "### Chaining Constructors\n",
    "\n",
    "Constructors can call other constructors.  That sounds strange, but makes sense if you have constructor methods that each provide a part of the definition of the class.  You can call the other constructors by use the `: this()` method suffix.  Let's improve our `Student` class from above to call the parameterless constructor from the constructor that takes an age parameter.   "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    public Student() \r\n",
    "    {\r\n",
    " \r\n",
    "        // A student is enrolled by default\r\n",
    "        display(\"Running the parameterless constructor\");\r\n",
    "        IsEnrolled = true;\r\n",
    "        \r\n",
    "    }\r\n",
    "    \r\n",
    "    public Student(byte age) : this()\r\n",
    "    {\r\n",
    "        \r\n",
    "        this.Age = age;\r\n",
    "        display(\"Running the Age constructor\");\r\n",
    "        \r\n",
    "    }\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    public byte Age { get; set; }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student(30);\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Running the parameterless constructor"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Running the Age constructor"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">30</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Now we can see that our properties are being initialized properly and the second constructor is called even though we are only triggered the constructor with the age.\n",
    "\n",
    "Try setting the parameterless constructor to call the age-parameter constructor.  What happens?\n",
    "\n",
    "## Properties\n",
    "\n",
    "We've already seen some properties, [_auto-implemented_ properties](https://docs.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/auto-implemented-properties?WT.mc_id=visualstudio-twitch-jefritz) in our `Student` class.  These declarations of a type with an access modifier and `{ get; set; }` means that these are properties that can be read and written to in our class.  Besides `public`, properties can be declared with `private`, `internal`, `protected`, and `protected internal` scope.  We already know what `private` and `internal` are, but `protected` and `protected internal` grant access to the property to classes that **inherit** from this class.  We'll learn more about inheritance in a future lesson.\n",
    "\n",
    "The Properties are able to be assigned to _INSIDE_ our class by using `this.PROPERTYNAME = value` notation.  We're able to read and write the property value with similar notation as noted in the previous samples.\n",
    "\n",
    "What if we wanted to do **MORE** with our properties when we set and retrieve their values?  Let's take a look at making the `Age` property only capable of being set internally to our Student class.  We can do this by adding an access modifier to the `set` statement."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    private Student() { IsEnrolled = true; }\r\n",
    "    \r\n",
    "    public Student(int age) : this()\r\n",
    "    {\r\n",
    "        \r\n",
    "        this.Age = age;\r\n",
    "        \r\n",
    "    }\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    internal int Age { get; private set; }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student(30);\r\n",
    "display(s);\r\n",
    "\r\n",
    "// s.Age = 25;\r\n",
    "// display(s);\r\n"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">30</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Perhaps we know the birthdate of all students is June 1, 2000.  We could update our `Age` property to remove the `SET` operation and make it only a `GET` with a calculation against the known birthdate. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    public Student() { IsEnrolled = true; }\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; } \r\n",
    "    \r\n",
    "    public byte Age { \r\n",
    "        get \r\n",
    "        {\r\n",
    "            // Total days / 365 to convert to years... not 100% accurate, but close enough for a demo\r\n",
    "            return (byte)Math.Floor(DateTime.Now.Subtract(new DateTime(2000, 6, 1)).TotalDays / 365d);\r\n",
    "        } \r\n",
    "    }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student();\r\n",
    "// s.Age = 30;\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">21</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Default Values or Initializing Auto-Implemented Properties\n",
    "\n",
    "There are a few techniques that you can use to set default or initial values for properties when a class is created.  This initial or default value can be overwritten with a different value once the class has been created.\n",
    "\n",
    "We've seen an approach previously in the samples here where the `IsEnrolled` property is set to `true` in the constructor.  Additionally, you can add the `=` equals operator with an initial value after a property definition to set the initial or default value."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    public byte Age { get; set; }\r\n",
    "    \r\n",
    "    // Define the IsEnrolled property with a default value of True\r\n",
    "    public bool IsEnrolled { get; set; } = true;\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and inspect the value of the Student to see if IsEnrolled is set to true\r\n",
    "var s = new Student();\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">0</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Expression Body Definitions for Properties\n",
    "\n",
    "You will see folks refer to the `=>` operator as the **fat-arrow** operator and C# folks will read this operator as \"such that\" with an expression on the right side with some code to be executed when interacting with the property.  This [expression body definition](https://docs.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/properties?WT.mc_id=visualstudio-twitch-jefritz#expression-body-definitions) allows for a very terse expression of what to do when interacting with the property.\n",
    "\n",
    "We can use these expression body definitions for `get`, `set` and the property itself.  Take a look at the following sample code:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; } \r\n",
    "    \r\n",
    "    // Let's create a simple GET that puts together the full-name of our student\r\n",
    "//    public string Name => string.Concat(FirstName, \" \", LastName);\r\n",
    "// public string Name => string.Format(\"{0} {1}\", FirstName, LastName);\r\n",
    "    public string Name => $\"{FirstName} {LastName}\";\r\n",
    "    \r\n",
    "    // Total days / 365 to convert to years... not 100% accurate, but close enough for a demo\r\n",
    "    // Read-only and property that is calculated each time it is accessed\r\n",
    "    public byte Age => (byte)Math.Floor(DateTime.Now.Subtract(new DateTime(2000, 6, 1)).TotalDays / 365d);\r\n",
    "\r\n",
    "    // Default value set to True\r\n",
    "    public bool IsEnrolled { get; set; } = true;\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student();\r\n",
    "s.FirstName = \"Sally\";\r\n",
    "s.LastName = \"Smith\";\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Name</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">Sally</div></td><td><div class=\"dni-plaintext\">Smith</div></td><td><div class=\"dni-plaintext\">Sally Smith</div></td><td><div class=\"dni-plaintext\">21</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Fields\n",
    "\n",
    "Working with the fixed birthdate in the previous example is a bit clumsy.  We would REALLY like to have a `BirthDate` value stored with our class and the `Age` calculated off of that.  **Fields** are variables that belong to the class and can be accessed depending on their access modifier.  Some of the supported access modifiers include\n",
    "\n",
    "- **private** fields can be accessed anywhere _inside_ the class\n",
    "- **public** fields can be accessed by any code that can interact with the class\n",
    "- **internal** fields can be accessed by any code inside the current library or program\n",
    "\n",
    "Let's update that last sample with a `BirthDate` field and a constructor that accepts a `birthDate` parameter."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    // The new BirthDate field is declared with its Type and Access Modifier explicitly\r\n",
    "    private DateTime _BirthDate;\r\n",
    "    \r\n",
    "    public Student(DateTime birthDate) \r\n",
    "    {\r\n",
    "        this._BirthDate = birthDate;\r\n",
    "    }\r\n",
    "    \r\n",
    "    public string FirstName { get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "\r\n",
    "    public DateTime BirthDate => _BirthDate;\r\n",
    "    \r\n",
    "    // Total days / 365 to convert to years... not 100% accurate, but close enough for a demo\r\n",
    "    public int Age => (int)Math.Floor(DateTime.Now.Subtract(BirthDate).TotalDays / 365d);\r\n",
    "    public bool IsEnrolled { get; set; } = true;\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student(new DateTime(2003, 10, 1));\r\n",
    "\r\n",
    "display(s.Age);\r\n",
    "display(s);"
   ],
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">17</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>BirthDate</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">&lt;null&gt;</div></td><td><div class=\"dni-plaintext\">2003-10-01 00:00:00Z</div></td><td><div class=\"dni-plaintext\">17</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Encapsulation\n",
    "\n",
    "A technique that you may want to use to interact with your properties and their persisted values with backing fields.  This technique is called **encapsulation** and was originally the only way to create properties.  Consider the `FirstName` property in the below sample.  The value is stored and fetched from the `_FirstName` field.\n",
    "\n",
    "The `LastName` property also encapsulates the `_LastName` field, but we have added a notification message (this `display` command is specific to Jupyter notebooks) to report when the `LastName` property is modified.\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    // The new BirthDate field is declared with its Type and Access Modifier explicitly\r\n",
    "    private DateTime _BirthDate;\r\n",
    "    private string _FirstName;\r\n",
    "    private string _LastName;\r\n",
    "    \r\n",
    "    public Student(string firstName, string lastName, DateTime birthDate) \r\n",
    "    {\r\n",
    "        this._FirstName = firstName;\r\n",
    "        this._LastName = lastName;\r\n",
    "        this._BirthDate = birthDate;\r\n",
    "    }\r\n",
    "    \r\n",
    "    // The FirstName property is ENCAPSULATED in the _FirstName field\r\n",
    "    public string FirstName { \r\n",
    "        get { return _FirstName; }\r\n",
    "        set { _FirstName = value; }\r\n",
    "    }\r\n",
    "    \r\n",
    "    // Using encapsulation techniques like this allows us to add code to take actions when the property is interacted with\r\n",
    "    // ... In this case, we're notifying when the LastName is changed.\r\n",
    "    public string LastName { \r\n",
    "        get { return _LastName; }\r\n",
    "        set { \r\n",
    "            // Notify the teachers about the name change\r\n",
    "            display(\"Name change notification!\");\r\n",
    "            _LastName = value; \r\n",
    "        }\r\n",
    "    }\r\n",
    "    \r\n",
    "    // Total days / 365 to convert to years... not 100% accurate, but close enough for a demo\r\n",
    "    public int Age => (int)Math.Floor(DateTime.Now.Subtract(_BirthDate).TotalDays / 365d);\r\n",
    "    public bool IsEnrolled { get; set; } = true;\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student(\"Jeff\", \"Stevens\", new DateTime(2003, 10, 1));\r\n",
    "s.LastName = \"Fritz\";\r\n",
    "\r\n",
    "display(s)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Name change notification!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th>FirstName</th><th>LastName</th><th>Age</th><th>IsEnrolled</th></tr></thead><tbody><tr><td><div class=\"dni-plaintext\">Jeff</div></td><td><div class=\"dni-plaintext\">Fritz</div></td><td><div class=\"dni-plaintext\">17</div></td><td><div class=\"dni-plaintext\">True</div></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Constants\n",
    "\n",
    "Constants are values that are defined at compile time and do not change for the life of the application.  The `const` keyword declares the constant with access modifiers and variable type.  From outside the class, you can then access the constant value using the name of the class and only the constant name from inside the class.  \n",
    "\n",
    "More details about [constants](https://docs.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/constants?WT.mc_id=visualstudio-twitch-jefritz) are available in the official documentation."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public class Student {\r\n",
    "    \r\n",
    "    // The new BirthDate field is declared with its Type and Access Modifier explicitly\r\n",
    "    private DateTime BirthDate;\r\n",
    "    private string _FirstName;\r\n",
    "    private string _LastName;\r\n",
    "    \r\n",
    "    // Here is a publicly accessible constant\r\n",
    "    public const int MaximumYearsEnrolled = 5;\r\n",
    "    \r\n",
    "    public Student() { IsEnrolled = true; }\r\n",
    "    public Student(string firstName, string lastName, DateTime birthDate) : this() \r\n",
    "    {\r\n",
    "        this.BirthDate = birthDate;\r\n",
    "        \r\n",
    "        // We access the constant here by using its name\r\n",
    "        display(\"From the constructor, the maximum years enrolled: \" + MaximumYearsEnrolled);\r\n",
    "    }\r\n",
    "    \r\n",
    "    public string FirstName {  get; set; }\r\n",
    "    public string LastName { get; set; }\r\n",
    "    public int Age { get; set; }\r\n",
    "    public bool IsEnrolled { get; set; }\r\n",
    "    \r\n",
    "}\r\n",
    "    \r\n",
    "// Create a new Student object and assign it to the variable name `s`\r\n",
    "var s = new Student(\"Jeff\", \"Stevens\", new DateTime(2003, 10, 1));\r\n",
    "\r\n",
    "// We can display the constant here \r\n",
    "display(Student.MaximumYearsEnrolled);\r\n",
    "    \r\n",
    "// This does not work, as the constant is only accessible through the use of the Student typename\r\n",
    "//display(s.MaximumYearsEnrolled);\r\n",
    "\r\n",
    "// This also does not work, as constants cannot be modified.  Try un-commenting and running.\r\n",
    "// Student.MaximumYearsEnrolled = 7;\r\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "Error",
     "evalue": "(37,1): error CS0131: The left-hand side of an assignment must be a variable, property or indexer",
     "traceback": [
      "(37,1): error CS0131: The left-hand side of an assignment must be a variable, property or indexer"
     ]
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Shortcut with C# 9:  Records\n",
    "\n",
    "Starting with [C# 9](https://docs.microsoft.com/dotnet/csharp/language-reference/builtin-types/record), we can use the `record` keyword to define a reference type.  You can use the short form of `record` with a constructor-like signature to create a record with positional syntax for a collection of properties.  The C# compiler will automatically create a constructor for you as well as the property definitions and a `ToString()` method.   \n"
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "public record StudentRecord (string FirstName, string LastName, int Age);\n",
    "\n",
    "var s = new StudentRecord(\"Sally\", \"Smith\", 30);\n",
    "display(s);\n",
    "\n",
    "display(s.ToString());"
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "Error",
     "evalue": "(8,1): error CS8852: Init-only property or indexer 'StudentRecord.LastName' can only be assigned in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor.",
     "traceback": [
      "(8,1): error CS8852: Init-only property or indexer 'StudentRecord.LastName' can only be assigned in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor."
     ]
    }
   ],
   "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
}