C# Cheatsheet - Advanced

Script written by Derek Banas (http://www.newthinktank.com) | Watch the online video tutorial here!

Reorganized by cozyplanes (https://cozyplanes.github.io)

Part 1 - C# Basics

1. Namespaces, Main, Input, Output, Loops, Command Line Arguments, Arrays, Data Types, DateTime, TimeSpan, BigInteger, Formatting, Strings, String Functions, and Functions

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using System.Numerics;
 
// You use a namespace to define globally unique objects
namespace CSharpTutA.cs
{
    // A class defines the variables and methods used
    // by objects. I'll get more into this later
    class Program
    {
        // The main function is where execution begins
        // static functions belong to the class and 
        // can be executed without needing to create 
        // an object
        // void means that this function doesn't return
        // a value after it executes, but it is 
        // common to use int instead and return an 
        // integer value 0 : when successfully executed
        // or -1 when an error occurred
        // This function can receive multiple string
        // values that are saved into an array
        
        static void Main(string[] args)
        {
 
            // Write a string to the console followed
            // be a newline
            // Write() doesn't include a newline
            // The Console class provides functions for input
            // output and error streams for console applications
            Console.WriteLine("Hello World");
 
            // for loops allow you to cycle through information
            // We will get command line arguments passed and print
            // them
 
            for(int i = 0; i < args.Length; i++)
            {
                // We use format parameters to place the string
                // version of passed objects into the output
                Console.WriteLine("Arg {0} : {1}", i, args[i]);
            }
 
            // Passing command line arguments in Visual Studio
            // Right click on project name in Solution Explorer 
            // Select Properties
            // Select Debug tab on the left
            // Enter parameters in Command Line Arguments textbox
            // Click Start
 
            // Get an array of the command line arguments
            string[] myArgs = Environment.GetCommandLineArgs();
 
            // Use the Join function to combine arguments with a comma
            Console.WriteLine(string.Join(", ", myArgs));
 
            // Call for the function to execute
            // SayHello();
 
            // ---------- DATA TYPES ----------
 
            // Bools store true or false
            bool canIVote = true;
 
            // INTEGERS
            // Integers are 32-bit signed integers
            Console.WriteLine("Biggest Integer : {0}", int.MaxValue);
            Console.WriteLine("Smallest Integer : {0}", int.MinValue);
 
            // LONGS
            // Longs are 64-bit signed integers
            Console.WriteLine("Biggest Long : {0}", long.MaxValue);
            Console.WriteLine("Smallest Long : {0}", long.MinValue);
 
            // DECIMALS
            // Decimals store 128-bit precise decimal values
            // It is accurate to 28 digits
            decimal decPiVal = 3.1415926535897932384626433832M;
            decimal decBigNum = 3.00000000000000000000000000011M;
            Console.WriteLine("DEC : PI + bigNum = {0}", decPiVal + decBigNum);
 
            Console.WriteLine("Biggest Decimal : {0}", Decimal.MaxValue);
 
            // DOUBLES
            // Doubles are 64-bit float types
            Console.WriteLine("Biggest Double : {0}", Double.MaxValue.ToString("#"));
 
            // It is precise to 14 digits
            double dblPiVal = 3.14159265358979;
            double dblBigNum = 3.00000000000002;
            Console.WriteLine("DBL : PI + bigNum = {0}", dblPiVal + dblBigNum);
 
            // FLOATS
            // Floats are 32-bit float types
            Console.WriteLine("Biggest Float : {0}", float.MaxValue.ToString("#"));
 
            // It is precise to 6 digits
            float fltPiVal = 3.141592F;
            float fltBigNum = 3.000002F;
            Console.WriteLine("FLT : PI + bigNum = {0}", fltPiVal + fltBigNum);
 
            // Other Data Types
            // byte : 8-bit unsigned int 0 to 255
            // char : 16-bit unicode character
            // sbyte : 8-bit signed int 128 to 127
            // short : 16-bit signed int -32,768 to 32,767
            // uint : 32-bit unsigned int 0 to 4,294,967,295
            // ulong : 64-bit unsigned int 0 to 18,446,744,073,709,551,615
            // ushort : 16-bit unsigned int 0 to 65,535
 
            // You can convert from string to other types with Parse
            bool boolFromStr = bool.Parse("True");
            int intFromStr = int.Parse("100");
            double dblFromStr = double.Parse("1.234");
 
            // ---------- DATETIME & TIMESPAN ----------
 
            // Used to define dates
            DateTime awesomeDate = new DateTime(1974, 12, 21);
            Console.WriteLine("Day of Week : {0}", awesomeDate.DayOfWeek);
 
            // You can change values
            awesomeDate = awesomeDate.AddDays(4);
            awesomeDate = awesomeDate.AddMonths(1);
            awesomeDate = awesomeDate.AddYears(1);
            Console.WriteLine("New Date : {0}", awesomeDate.Date);
 
            // TimeSpan
            // Used to define a time
            TimeSpan lunchTime = new TimeSpan(12, 30, 0);
 
            // Change values
            lunchTime = lunchTime.Subtract(new TimeSpan(0, 15, 0));
            lunchTime = lunchTime.Add(new TimeSpan(1, 0, 0));
            Console.WriteLine("New Time : {0}", lunchTime.ToString());
 
            // ---------- BIGINTEGER ----------
            // Used to store very large numbers
            // Select Project -> Add Reference
            // Select Assemblies -> System.Numerics.dll click Ok
            // Add this line using System.Numerics; at the top
 
            // Define the value using a text literal
            BigInteger bigNum = BigInteger.Parse("12345123451234512345");
            Console.WriteLine("Big Num * 2 = {0}", bigNum * 2);
 
 
            // ---------- FORMATTING OUTPUT ----------
 
            // Format output for currency
            Console.WriteLine("Currency : {0:c}", 23.455);
 
            // Pad with zeroes 
            Console.WriteLine("Pad with 0s : {0:d4}", 23);
 
            // Define decimals 
            Console.WriteLine("3 Decimals : {0:f3}", 23.4555);
 
            // Add commas and decimals
            Console.WriteLine("Commas : {0:n4}", 2300);
 
            // ---------- STRINGS ----------
            // Strings store a series of characters
            string randString = "This is a string";
 
            // Get number of characters in string
            Console.WriteLine("String Length : {0}", randString.Length);
 
            // Check if string contains other string
            Console.WriteLine("String Contains is : {0}", 
                randString.Contains("is"));
 
            // Index of string match
            Console.WriteLine("Index of is : {0}", 
                randString.IndexOf("is"));
 
            // Remove number of characters starting at an index
            Console.WriteLine("Remove string : {0}",
                randString.Remove(10, 6));
 
            // Add a string starting at an index
            Console.WriteLine("Insert String : {0}",
                randString.Insert(10, "short "));
 
            // Replace a string with another
            Console.WriteLine("Replace String : {0}",
                randString.Replace("string", "sentence"));
 
            // Compare strings and ignore case
            // < 0 : str1 preceeds str2
            // = : Zero
            // > 0 : str2 preceeds str1
            Console.WriteLine("Compare A to B : {0}",
                String.Compare("A", "B", StringComparison.OrdinalIgnoreCase));
 
            // Check if strings are equal
            Console.WriteLine("A = a : {0}",
                String.Equals("A", "a", StringComparison.OrdinalIgnoreCase));
 
            // Add padding left
            Console.WriteLine("Pad Left : {0}",
                randString.PadLeft(20, '.'));
 
            // Add padding right
            Console.WriteLine("Pad Right : {0} Stuff",
                randString.PadRight(20, '.'));
 
            // Trim whitespace
            Console.WriteLine("Trim : {0}",
                randString.Trim());
 
            // Make uppercase
            Console.WriteLine("Uppercase : {0}",
                randString.ToUpper());
 
            // Make lowercase
            Console.WriteLine("Lowercase : {0}",
                randString.ToLower());
 
            // Use Format to create strings
            string newString = String.Format("{0} saw a {1} {2} in the {3}",
                "Paul", "rabbit", "eating", "field");
 
            // You can add newlines with \n and join strings with +
            Console.Write(newString + "\n");
 
            // Other escape characters
            // \' \" \\ \t \a
 
            // Verbatim strings ignore escape characters
            Console.Write(@"Exactly What I Typed");
 
            // Excepts input up until a newline, but it is here to 
            // keep the console open after output
            // Read() excepts a single character
            Console.ReadLine();
 
        }
 
        // You can create your own functions (methods)
        private static void SayHello()
        {
            // Defines a variable that will store a string
            // of characters
            string name = "";
 
            Console.Write("What is your name : ");
 
            // Save the input the user provides
            name = Console.ReadLine();
 
            Console.WriteLine("Hello {0}", name);
        }
 
    }
}

2. Implicit Typing, Casting, For, For Each and Arrays and StringBuilder

 
​x
​
   using System;
   using System.Collections.Generic;
   using System.Linq;
    
   // Needed for StringBuilder
   using System.Text;
   using System.Threading.Tasks;
    
   // For culture specific formating
   using System.Globalization;
    
   namespace CSharpTutA.cs
   {
       class Program
       {
           
           static void Main(string[] args)
           {
               // ----- IMPLICIT TYPING -----
               // You can use var to have C# figure out the 
               // data type
    
               var intVal = 1234;
    
               Console.WriteLine("intVal Type : {0}", 
                   intVal.GetType());
    
               // ----- ARRAYS -----
               // Arrays are just boxes inside of a bigger box
               // that can contain many values of the same
               // data type
               // Each item is assigned a key starting at 0
               // and incrementing up from there
    
               // Define an array which holds 3 values
               // Arrays have fixed sizes
               int[] favNums = new int[3];
    
               // Add a value to the array
               favNums[0] = 23;
    
               // Retrieve a value 
               Console.WriteLine("favNum 0 : {0}", favNums[0]);
    
               // Create and fill array
               string[] customers = { "Bob", "Sally", "Sue" };
    
               // You can use var to create arrays, but the
               // values must be of the same type
               var employees = new[] { "Mike", "Paul", "Rick" };
    
               // Create an array of base objects which is the 
               // base type of all other types
               object[] randomArray = { "Paul", 45, 1.234 };
    
               // GetType knows its true type
               Console.WriteLine("randomArray 0 : {0}",
                   randomArray[0].GetType());
    
               // Get number of items in array
               Console.WriteLine("Array Size : {0}",
                   randomArray.Length);
    
               // Use for loop to cycle through the array
               for(int i = 0; i < randomArray.Length; i++)
               {
                   Console.WriteLine("Array {0} : Value : {1}",
                   i, randomArray[i]);
               }
    
               // Multidimensional arrays
               // When you define an array like arrName[5] you
               // are saying you want to create boxes stacked 
               // vertically
    
               // If you define arrName[2,2] you are saying
               // you want to have 2 rows high and 2 across
               string[,] custNames = new string[2,2] { { "Bob", "Smith" }, { "Sally", "Smith" } };
    
               // Get value in MD array
               Console.WriteLine("MD Value : {0}", 
                   custNames.GetValue(1,1));
    
               // Cycle through the multidimensional array
               // Get length of multidimensional array column
               for (int i = 0; i < custNames.GetLength(0); i++)
               {
                   // Get length of multidimensional array row
                   for(int j = 0; j < custNames.GetLength(1); j++)
                   {
                       Console.Write("{0} ",custNames[i,j]);
                   }
                   Console.WriteLine();
               }
    
               // An array like arrName[2,2,3] would be like a 
               // stack of 3 spread sheets with 2 rows and 2
               // columns worth of data on each page
    
               // foreach can be used to cycle through an array
               int[] randNums = { 1, 4, 9, 2 };
    
               // You can pass an array to a function
               PrintArray(randNums, "ForEach");
    
               // Sort array
               Array.Sort(randNums);
    
               // Reverse array
               Array.Reverse(randNums);
    
               // Get index of match or return -1
               Console.WriteLine("1 at index : {0} ",
                   Array.IndexOf(randNums, 1));
    
               // Change value at index 1 to 0
               randNums.SetValue(0, 1);
    
               // Copy part of an array to another
               int[] srcArray = { 1, 2, 3 };
               int[] destArray = new int[2];
               int startInd = 0;
               int length = 2;
    
               Array.Copy(srcArray, startInd, destArray,
                   startInd, length);
    
               PrintArray(destArray, "Copy");
    
               // Create an array with CreateInstance
               Array anotherArray = Array.CreateInstance(typeof(int), 10);
    
               // Copy values in srcArray to destArray starting
               // at index 5 in destination
               srcArray.CopyTo(anotherArray, 5);
    
               foreach (int m in anotherArray)
               {
                   Console.WriteLine("CopyTo : {0} ", m);
               }
    
               // Search for an element that matches the conditions
               // defined by the specified predicate
               int[] numArray = { 1, 11, 22 };
               Console.WriteLine("> 10 : {0}", Array.Find(numArray, GT10));
    
               // FindAll returns an array with all values that
               // match 
               // FindIndex returns the index of the match
    
    
               // ----- STRINGBUILDER -----
               // Each time you change a string you are actually
               // creating a new string which is inefficient
               // when you are working with large blocks of text
               // StringBuilders actually change the text
               // rather then make a copy
    
               // Create a StringBuilder with a default size
               // of 16 characters, but it grows automatically
               StringBuilder sb = new StringBuilder("Random Text");
    
               // Create a StringBuilder with a size of 256
               StringBuilder sb2 = new StringBuilder("More Stuff that is very important", 256);
    
               // Get max size
               Console.WriteLine("Capacity : {0}", sb2.Capacity);
    
               // Get length
               Console.WriteLine("Length : {0}", sb2.Length);
    
               // Add text to StringBuilder
               sb2.AppendLine("\nMore important text");
    
               // Define culture specific formating
               CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
    
               // Append a format string
               string bestCust = "Bob Smith";
               sb2.AppendFormat(enUS, "Best Customer : {0}", bestCust);
    
               // Output StringBuilder
               Console.WriteLine(sb2.ToString());
    
               // Replace a string
               sb2.Replace("text", "characters");
               Console.WriteLine(sb2.ToString());
    
               // Clear a string builder
               sb2.Clear();
    
               sb2.Append("Random Text");
    
               // Are objects equal
               Console.WriteLine(sb.Equals(sb2));
    
               // Insert at an index
               sb2.Insert(11, " that's Great");
    
               Console.WriteLine("Insert : {0}", sb2.ToString());
    
               // Remove number of characters starting at index
               sb2.Remove(11, 7);
    
               Console.WriteLine("Remove : {0}", sb2.ToString());
    
               // ----- CASTING -----
               // If you want to cast from one type to another
               long num1 = 1234;
               int num2 = (int)num1;
    
               Console.WriteLine("Orig : {0} Cast : {1}", 
                   num1.GetType(), num2.GetType());
    
    
               Console.ReadLine();
    
           }
    
           static void PrintArray(int[] intArray, string mess)
           {
               foreach (int k in intArray)
               {
                   Console.WriteLine("{0} : {1} ", mess, k);
               }
           }
    
           private static bool GT10(int val)
           {
               return val > 10;
           }
    
       }
   }
​

3. If, Else, Else If, Relational Operators, Logical Operators, Ternary Operator, Switch, Break, Continue, Goto, While Do While, Convert, Try, Catch, Finally and Exception Handling

 
xxxxxxxxxx
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace CSharpTutA.cs
{
    class Program
    {
        
        static void Main(string[] args)
        {
            // ----- CONDITIONALS -----
            // ----- IF / ELSE / -----
            // Relational Operators : > < >= <= == !=
            // Logical Operators : && || !
 
            int age = 17;
 
            if ((age >= 5) && (age <= 7))
            {
                Console.WriteLine("Go to elementary school");
            }
            else if ((age > 7) && (age < 13))
            {
                Console.WriteLine("Go to middle school");
            }
            else if ((age > 13) && (age < 19))
            {
                Console.WriteLine("Go to high school");
            }
            else
            {
                Console.WriteLine("Go to college");
            }
 
            if ((age < 14) || (age > 67))
            {
                Console.WriteLine("You shouldn't work");
            }
 
            Console.WriteLine("! true = " + (!true));
 
            // Ternary Operator
            // Assigns the 1st value if true and otherwise 
            // the 2nd
            bool canDrive = age >= 16 ? true : false;
 
            // Switch is used when you have limited options
            // The only way to use ranges is to stack 
            // the possible values
            switch (age)
            {
                case 1:
                case 2:
                    Console.WriteLine("Go to Day Care");
                    break;
                case 3:
                case 4:
                    Console.WriteLine("Go to Preschool");
                    break;
                case 5:
                    Console.WriteLine("Go to Kindergarten");
                    break;
                default:
                    Console.WriteLine("Go to another school");
                    // You can also jump out of a switch
                    // with goto
                    goto OtherSchool;
            }
 
            OtherSchool:
            Console.WriteLine("Elementary, Middle, High School");
 
            // To compare strings use Equals
            string name = "Derek";
            string name2 = "Derek";
 
            if (name.Equals(name2, StringComparison.Ordinal))
            {
                Console.WriteLine("Names are Equal");
            }
 
            // ----- WHILE LOOP -----
            // You use the while loop when you want to execute
            // as long as a condition is true
 
            // This while loop will print odd numbers between
            // 1 and 10
            int i = 1;
            while (i <= 10)
            {
                // % (Modulus) returns the remainder of a
                // division. If it returns 0 that means the
                // value is even
                if (i % 2 == 0)
                {
                    i++;
 
                    // Continue skips the rest of the code and 
                    // starts execution back at the top of the 
                    // while
                    continue;
                }
 
                // Break jumps completely out of the loop
                if (i == 9) break;
 
                Console.WriteLine(i);
                i++;
            }
 
            // ----- DO WHILE LOOP -----
            // Use do while when you must execute the code
            // at least once
 
            // Generate a random number
            Random rnd = new Random();
            int secretNumber = rnd.Next(1, 11);
            int numberGuessed = 0;
 
            do
            {
                Console.Write("Enter a number between 1 & 10 : ");
 
                // Use Convert to switch the string into an int
                numberGuessed = Convert.ToInt32(Console.ReadLine());
 
            } while (secretNumber != numberGuessed);
 
            Console.WriteLine("You guessed it is was {0}",
                secretNumber);
 
            // Other Convert options : ToBoolean, ToByte,
            // ToChar, ToDecimal, ToDouble, ToInt64,
            // ToString, and they can convert from any 
            // type to any other type
 
            // ----- EXCEPTION HANDLING -----
            // We use exception handling to catch errors
            // that could crash our program
            double num1 = 5;
            double num2 = 0;
 
            // Code that could cause an error is surrounded
            // by a try block
            try { 
            Console.WriteLine("5 / 0 = {0}", 
                DoDivision(num1, num2));
            }
 
            // We catch the error and warn the user 
            // rather then crash the program
            catch (DivideByZeroException ex)
            {
                Console.WriteLine("You can't Divide by Zero");
 
                // Get additonal info on the exception
                Console.WriteLine(ex.GetType().Name);
                Console.WriteLine(ex.Message);
 
            }
 
            // This is the default catch all for exceptions
            catch (Exception ex)
            {
                Console.WriteLine("An error occurred");
                Console.WriteLine(ex.GetType().Name);
                Console.WriteLine(ex.Message);
            }
 
            // finally always runs and provides for clean up
            finally
            {
                Console.WriteLine("Cleaning Up");
            }
 
            // Well cover more about exception handling 
            // with some real examples soon
 
            Console.ReadLine();
 
        }
 
        static double DoDivision(double x, double y)
        {
            if(y == 0)
            {
                // We are throwing an exception because
                // you can't divide by zero
                throw new System.DivideByZeroException();
            }
            return x / y;
        }
 
    }
}

4. Methods, Pass by Value versus Pass by Reference, Out Parameter, Params, Named Parameters, Method Overloading, and Enum

 
xxxxxxxxxx
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace CSharpTutA.cs
{
    class Program
    {
 
        static void Main(string[] args)
        {
            // ----- PASSING BY VALUE -----
            double x = 5;
            double y = 4;
 
            Console.WriteLine("5 + 4 = {0}",
                GetSum(x, y));
 
            // Even though the value for x changed in 
            // method it remains unchanged here
            Console.WriteLine("x = {0}",
                x);
 
            // ----- OUT PARAMETER -----
            // You can pass a variable as an output 
            // variable even without assigning a
            // value to it
            int solution;
 
            // A parameter passed with out has its
            // value assigned in the method
            DoubleIt(15, out solution);
 
            Console.WriteLine("15 * 2 = {0}",
                solution);
 
            // ----- PASS BY REFERENCE -----
            int num1 = 10;
            int num2 = 20;
 
            Console.WriteLine("Before Swap num1 : {0} num2 : {1}", num1, num2);
 
            Swap(ref num1, ref num2);
 
            Console.WriteLine("After Swap num1 : {0} num2 : {1}", num1, num2);
 
            // ----- PARAMS -----
            // You are able to pass a variable amount
            // of data of the same data type into a 
            // method using params. You can also pass
            // in an array. 
            Console.WriteLine("1 + 2 + 3 = {0}",
                GetSumMore(1, 2, 3));
 
            // ----- NAMED PARAMETERS -----
            // You can pass values in any order if
            // you used named parameters
            PrintInfo(zipCode: 15147,
                name: "Derek Banas");
 
            // ----- METHOD OVERLOADING -----
            // You can define methods with the same 
            // name that will be called depending on
            // what data is sent automatically
            Console.WriteLine("5.0 + 4.0 = {0}",
                GetSum(5.0, 4.5));
 
            Console.WriteLine("5 + 4 = {0}",
                GetSum(5, 4));
 
            Console.WriteLine("5 + 4 = {0}",
                GetSum("5", "4"));
 
            // ----- ENUM -----
            CarColor car1 = CarColor.Blue;
            PaintCar(car1);
 
 
            Console.ReadLine();
 
        }
 
        // ----- PASS BY VALUE -----
        // By default values are passed into a method
        // and not a reference to the variable passed
        // Changes made to those values do not effect the
        // variables outside of the method
 
        // If you assign a value then it is optional to 
        // pass
        static double GetSum(double x = 1, double y = 1)
        {
            double temp = x;
            x = y;
            y = temp;
            return x + y;
        }
 
        // ----- OUT PARAMETER -----
        // A parameter marked with out must be assigned 
        // a value in the method
        static void DoubleIt(int x, out int solution)
        {
            solution = x * 2;
        }
 
        // ----- PASS BY REFERENCE -----
        // If a variable is passed by reference changes
        // to its value in the method effect it outside
        // of the method
        public static void Swap(ref int num1, ref int num2)
        {
            int temp = num1;
            num1 = num2;
            num2 = temp;
        }
 
        // ----- PARAMS -----
        // The params array must be the last parameter
        // in the list
        static double GetSumMore(params double[] nums)
        {
            double sum = 0;
            foreach (int i in nums)
            {
                sum += i;
            }
            return sum;
        }
 
        // ----- NAMED PARAMETERS -----
        static void PrintInfo(string name, int zipCode)
        {
            Console.WriteLine("{0} lives in the zip code {1}", name, zipCode);
        }
 
        // ----- METHOD OVERLOADING -----
        static double GetSum(double x = 1, double y = 1)
        {
            return x + y;
        }
 
        static double GetSum(string x = "1", string y = "1")
        {
            double dblX = Convert.ToDouble(x);
            double dblY = Convert.ToDouble(y);
            return dblX + dblY;
        }
 
        // ----- ENUM -----
        // ----- ENUM -----
        // An enum is a custom data type with
        // key value pairs. They allow you to
        // use symbolic names to represent data
        // The first number is 0 by default unless
        // you change it
        // You can define the underlying type
        // or leave it as int as default
 
        enum CarColor : byte
        {
            Orange = 1,
            Blue,
            Green,
            Red,
            Yellow
        }
 
        static void PaintCar(CarColor cc)
        {
            Console.WriteLine("The car was painted {0} with the code {1}",
                cc, (int)cc);
        }
 
    }
}
​

5. Classes, Methods, Fields, Constructors, Static Classes, Methods and Fields, Structs and Nullable Types

 
xxxxxxxxxx
---------- Program.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Program
    {
 
        static void Main(string[] args)
        {
            // Create a Rectangle
            Rectangle rect1;
 
            // Add values to it and run the Area method
            rect1.length = 200;
            rect1.width = 50;
            Console.WriteLine("Area of rect1 : {0}",
                rect1.Area());
 
            // Use a constructor to create a Rectangle
            Rectangle rect2 = new Rectangle(100, 40);
 
            // If you assign one Rectangle to another
            // you are setting the values and not
            // creating a reference
            rect2 = rect1;
            rect1.length = 33;
 
            Console.WriteLine("rect2.length : {0}",
                rect2.length);
 
            // ----- OBJECT ORIENTED PROGRAMMING -----
            // A class models real world objects by
            // defining their attributes (fields) and
            // capabilities (methods)
            // Then unlike with structs you can 
            // inherit from a class and create more
            // specific subclass types
 
            // Add a class Project -> Add Class
 
            // Create an Animal object
            // You could also assign values like
            // fox.name = "Red"
            Animal fox = new Animal()
            {
                name = "Red",
                sound = "Raaaw"
            };
 
            // Call the static method
            Console.WriteLine("# of Animals {0}",
                Animal.GetNumAnimals());
 
            // You can also create static utility
            // classes Project -> Add Class
            Console.WriteLine("Area of Rectangle : {0}",
                ShapeMath.GetArea("rectangle", 5, 6));
 
 
            // ----- NULLABLE TYPES -----
            // Data types by default cannot have a
            // value of null. Often null is needed
            // when you are working with databases
            // and you can create a null type by 
            // adding a ? to the definition
            int? randNum = null;
            
            // Check for null
            if(randNum == null)
            {
                Console.WriteLine("randNum is null");
            }
 
            // Another check for null
            if (!randNum.HasValue)
            {
                Console.WriteLine("randNum is null");
            }
 
 
            Console.ReadLine();
 
        }
 
        // ----- STRUCTS -----
        // A struct is a user defined type that
        // contain multiple fields and methods
 
        struct Rectangle
        {
            public double length;
            public double width;
 
            // You can create a constructor method
            // that will set the values for fields
            public Rectangle(double l=1, double w=1)
            {
                length = l;
                width = w;
            }
 
            public double Area()
            {
                return length * width;
            }
        }
    }
 
}
 
---------- Animal.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Animal
    {
        // Attributes (fields) that all Animals have
        // public means can be directly changed
        // after an object has been created
        public string name;
        public string sound;
 
        // A constructor sets default values for 
        // fields when an object is created
        // This is the default constructor if no
        // parameters are sent
        public Animal()
        {
            name = "No Name";
            sound = "No Sound";
            numOfAnimals++;
        }
 
        // You can create additonal constructors
        // but since we are definig defaults you
        // don't have to
        public Animal(string name = "No Name")
        {
            // This refers to this objects name
            // instead of the name passed into
            // the constructor
            this.name = name;
            this.sound = "No Sound";
            numOfAnimals++;
        }
 
        public Animal(string name = "No Name",
            string sound = "No Sound")
        {
            this.name = name;
            this.sound = sound;
            numOfAnimals++;
        }
 
        // Capabilities (methods) that all Animals have
        public void MakeSound()
        {
            Console.WriteLine("{0} says {1}",
                name, sound);
        }
 
        // static fields and methods belong to the class
        // A static field has the same value for all
        // objects of the Animal type
        static int numOfAnimals = 0;
 
        public static int GetNumAnimals()
        {
            return numOfAnimals;
        }
    }
}
 
---------- ShapeMath.cs ----------
 
using System;
 
    public static class ShapeMath
    {
        // This class can only contain static methods
        // and constant values
        public static double GetArea(string shape = "",
            double length1 = 0,
            double length2 = 0)
        {
            if (String.Equals("Rectangle",
                shape,
                StringComparison.OrdinalIgnoreCase))
            {
                return length1 * length2;
            }
            else if (String.Equals("Triangle",
              shape,
              StringComparison.OrdinalIgnoreCase))
            {
                return length1 * (length2 / 2);
            }
            else if (String.Equals("Circle",
              shape,
              StringComparison.OrdinalIgnoreCase))
            {
                return 3.14159 * Math.Pow(length1, 2);
            }
            else
            {
                return -1;
            }
        }
 
    }

6. public, private, protected, constants, read-only fields, constructors, setters, getters, properties and static

 
xxxxxxxxxx
// ----- Animal.cs -----
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
// We cover public, private, protected, constants,
// read-only fields, constructors, setters, getters, 
// properties and more on static
 
namespace CSharpTutA.cs
{
    class Animal
    {
        // Define fields that are protected with private
        // Private fields can only be accessed by
        // methods in the class and they are not 
        // accessible by subclasses
        // protected fields can only be accessed by
        // methods in the class and by subclasses
        private string name;
        private string sound;
 
        // You can define constants
        public const string SHELTER = "Derek's Home for Animals";
 
        // You can define read-only fields that are set
        // at runtime in constructors, but then can't
        // be changed
        public readonly int idNum;
 
        // Method (Capabilities)
        public void MakeSound()
        {
            Console.WriteLine("{0} says {1}",
                name, sound);
        }
 
        // Default constructor
        public Animal() 
        :this("No Name", "No Sound") { }
 
        // Constructor called if only name is passed
        // this passes the parameters to the next
        // constructor
        public Animal(string name)
            : this(name, "No Sound") { }
 
        // Constructor that receives parameters
        public Animal(string name,
            string sound)
        {
            SetName(name);
            Sound = sound;
 
            // Increment the number of animals
            // property
            NumOfAnimals = 1;
 
            // Define the read-only value which is
            // the same for all Animals
            Random rnd = new Random();
            idNum = rnd.Next(1, 2147483640);
        }
 
        // Setters (Mutators) protect the fields 
        // from receiving bad data
        public void SetName(string name)
        {
            // Any checks if any character in the string 
            // is a number and if so returns true
            // Since we won't allow numbers we will 
            // protect our data
            if (!name.Any(char.IsDigit))
            {
                this.name = name;
            } else
            {
                // We have this duplicated code because 
                // everything isn't a property
                this.name = "No Name";
                Console.WriteLine("Name can't contain numbers");
            }
        }
 
        // Getters (Accessors) can provide output
        // aside from the value stored
        public string GetName()
        {
            return name;
        }
 
        // The preferred way to define getters and
        // setters is through properties
        public string Sound
        {
            get { return sound; }
            set
            {
                // value is assigned the value passed in
                if (value.Length > 10)
                {
                    sound = "No Sound";
                    Console.WriteLine("Sound is too long");
                } else
                {
                    sound = value;
                }
            }
        }
 
        // You can have the getters and setters
        // generated for you like this and also
        // set the default value
        public string Owner { get; set; } = "No Owner";
 
        // You can also define static properties
        public static int numOfAnimals = 0;
 
        public static int NumOfAnimals
        {
            get { return numOfAnimals; }
            set { numOfAnimals += value; }
        }
 
    }
}
 
// ----- Program.cs -----
 
using System;
 
namespace CSharpTutA.cs
{
    class Program
    {
 
        static void Main(string[] args)
        {
            Animal cat = new Animal();
 
            // Call the setter
            cat.SetName("Whiskers");
 
            // Set the property
            cat.Sound = "Meow";
 
            Console.WriteLine("The cat is named {0} and says {1}",
                cat.GetName(), cat.Sound);
 
            // Test auto generated getters and setters
            cat.Owner = "Derek";
 
            Console.WriteLine("{0} owner is {1}",
                cat.GetName(), cat.Owner);
 
            // Get the read-only id number
            Console.WriteLine("{0} shelter id is {1}",
                cat.GetName(), cat.idNum);
 
            // Test static property
            Console.WriteLine("# of Animals : {0}",
                Animal.NumOfAnimals);
 
 
            Console.ReadLine();
 
        }
        
    }
 
}

7. Protected, Inheritance, Aggregations, Virtual, Override, Super Classes, Inner Classes, New, Base, and Polymorphism

 
xxxxxxxxxx
---------- Animal.cs ----------
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace CSharpTutA.cs
{
    // If this class was sealed you couldn't inherit 
    // from it sealed class Animal
    class Animal
    {
        private string name;
 
        // A protected field can be changed by
        // a subclass directly
        protected string sound;
 
        // Inheritance has a "is-a" relationship, 
        // while an aggregation or delegate 
        // represents a "Has-a" relationship
        // like we have here with the AnimalIDInfo
        // object
        protected AnimalIDInfo animalIDInfo = new AnimalIDInfo();
  
        public void SetAnimalIDInfo(int idNum, string owner)
        {
            animalIDInfo.IDNum = idNum;
            animalIDInfo.Owner = owner;
        }
 
        public void GetAnimalIDInfo()
        {
            Console.WriteLine($"{Name} has the ID of {animalIDInfo.IDNum} and is owned by {animalIDInfo.Owner}");
        }
 
        // Added virtual so that this method can
        // be overridden by subclasses
        // You must add override to the method in 
        // the subclass
        public virtual void MakeSound()
        {
            Console.WriteLine($"{Name} says {Sound}");
        }
 
        public Animal()
        :this("No Name", "No Sound") { }
 
        public Animal(string name)
            :this(name, "No Sound") { }
 
        public Animal(string name, string sound)
        {
            Name = name;
            Sound = sound;
        }
 
        public string Name
        {
            get { return name; }
            set
            {
                if (!value.Any(char.IsDigit))
                {
                    name = "No Name";
                } else {
                    name = value;
                }
            }
        }
 
        public string Sound
        {
            get { return sound; }
            set
            {
                if(value.Length > 10)
                {
                    sound = "No Sound";
                }
                sound = value;
            }
        }
 
        // You can create inner classes that are 
        // normally helper classes for the outer 
        // class because it can access private
        // members of the outer class
        public class AnimalHealth
        {
            public bool HealthyWeight(double height,
                double weight)
            {
                double calc = height / weight;
 
                if ((calc >= .18) && (calc <= .27))
                {
                    return true;
                }
                else return false;
            }
 
        }
 
    }
}
 
---------- Dog.cs ----------
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace CSharpTutA.cs
{
    // When you inherit from another class you
    // receive all of its fields and methods
    // You cannot inherit from multiple classes
    class Dog : Animal
    {
        // You can add additional properties
        // or fields
        public string Sound2 { get; set; } = "Grrrrr";
 
        // You can overwrite methods by adding new
        /*
        public new void MakeSound()
        {
            Console.WriteLine($"{Name} says {Sound} and {Sound2}");
        }
        */
 
        // Add override so that the correct method
        // is called when a Dog is created as an
        // Animal type
        public override void MakeSound()
        {
            Console.WriteLine($"{Name} says {Sound} and {Sound2}");
        }
 
 
        // Create a constructor that has the base 
        // constructor initialize everything except 
        // Sound2
        public Dog(string name = "No Name", 
            string sound = "No Sound", 
            string sound2 = "No Sound 2")
            :base(name, sound){
                Sound2 = sound2;
            }
    }
}
 
---------- Program.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Program
    {
 
        static void Main(string[] args)
        {
            Animal whiskers = new Animal()
            {
                Name = "Whiskers",
                Sound = "Meow"
            };
 
            Dog grover = new Dog()
            {
                Name = "Grover",
                Sound = "Woof",
                Sound2 = "Grrrrr"
            };
 
            // Demonstrate changing the protected
            // field sound
            grover.Sound = "Wooooof";
 
            whiskers.MakeSound();
            grover.MakeSound();
 
            // Define the AnimalIDInfo
            whiskers.SetAnimalIDInfo(12345, "Sally Smith");
            grover.SetAnimalIDInfo(12346, "Paul Brown");
 
            whiskers.GetAnimalIDInfo();
 
            // Test the inner class
            Animal.AnimalHealth getHealth = new Animal.AnimalHealth();
 
            Console.WriteLine("Is my animal healthy : {0}", getHealth.HealthyWeight(11, 46));
 
            // You can define 2 Animal objects but have
            // one actually be a Dog type. 
            Animal monkey = new Animal()
            {
                Name = "Happy",
                Sound = "Eeeeee"
            };
 
            Animal spot = new Dog()
            {
                Name = "Spot",
                Sound = "Wooooff",
                Sound2 = "Geerrrr"
            };
 
            // The problem is that if you call a 
            // function in Animal it won't call
            // the overridden method in Dog unless
            // the method that might be overridden
            // is marked virtual
            spot.MakeSound();
 
            // This is an example of how Polymorphism
            // allows a subclass to override a method
            // in the super class and even if the 
            // subclass is defined as the super class
            // type the correct method will be called
 
 
            Console.ReadLine();
 
        }
        
    }
 
}
 
---------- AnimalIDInfo.cs ----------
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace CSharpTutA.cs
{
    class AnimalIDInfo
    {
        public int IDNum { get; set; } = 0;
        public string Owner { get; set; } = "No Owner";
 
    }
}

8. Break time : Simple OOP Warrior Game

 
xxxxxxxxxx
// ---------- Warrior.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Warrior
    {
        // Define the Warriors properties
        public string Name { get; set; } = "Warrior";
        public double Health { get; set; } = 0;
        public double AttkMax { get; set; } = 0;
        public double BlockMax { get; set; } = 0;
 
        // Always create a single Random instance and reuse
        // it or you will get the same value over and over
        Random rnd = new Random();
 
        // Constructor initializes the warrior
        public Warrior(string name = "Warrior", 
            double health = 0, 
            double attkMax = 0,
            double blockMax = 0)
        {
            Name = name;
            Health = health;
            AttkMax = attkMax;
            BlockMax = blockMax;
        }
 
        // Generate a random atack value from 1
        // to the warriors maximum attack value
        public double Attack()
        {
            return rnd.Next(1, (int)AttkMax);
        }
 
        // Generate a random block value from
        // 1 to the warriors maximum block
        public double Block()
        {
            return rnd.Next(1, (int)BlockMax);
        }
 
    }
}
 
// ---------- Battle.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Battle
    {
        // This is a utility class so it makes sense
        // to have just static methods
 
        // Recieve both Warrior objects
        public static void StartFight(Warrior warrior1,
            Warrior warrior2)
        {
            // Loop giving each Warrior a chance to attack
            // and block each turn until 1 dies
            while (true)
            {
                if (GetAttackResult(warrior1, warrior2) == "Game Over")
                {
                    Console.WriteLine("Game Over");
                    break;
                }
 
                if (GetAttackResult(warrior2, warrior1) == "Game Over")
                {
                    Console.WriteLine("Game Over");
                    break;
                }
            }
        }
 
        // Accept 2 Warriors
        public static string GetAttackResult(Warrior warriorA,
            Warrior warriorB)
        {
            // Calculate one Warriors attack and the others block
            double warAAttkAmt = warriorA.Attack();
            double warBBlkAmt = warriorB.Block();
 
            // Subtract block from attack
            double dmg2WarB = warAAttkAmt - warBBlkAmt;
 
            // If there was damage subtract that from the health
            if (dmg2WarB > 0)
            {
                warriorB.Health = warriorB.Health - dmg2WarB;
            }
            else dmg2WarB = 0;
 
            // Print out info on who attacked who and for how
            // much damage
            Console.WriteLine("{0} Attacks {1} and Deals {2} Damage",
                warriorA.Name,
                warriorB.Name,
                dmg2WarB);
 
            // Provide output on the change to health
            Console.WriteLine("{0} Has {1} Health\n",
                warriorB.Name,
                warriorB.Health);
 
            // Check if the warriors health fell below
            // zero and if so print a message and send
            // a response that will end the loop
            if (warriorB.Health <= 0)
            {
                Console.WriteLine("{0} has Died and {1} is Victorious\n",
                    warriorB.Name,
                    warriorA.Name);
 
                return "Game Over";
            }
            else return "Fight Again";
        }
 
    }
}
 
// ---------- Program.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Program
    {
        /*
        Bob Attacks Maximus and Deals 74 Damage
        Maximus Has 69 Health
 
        Maximus Attacks Bob and Deals 6 Damage
        Bob Has 6 Health
 
        Bob Attacks Maximus and Deals 48 Damage
        Maximus Has 21 Health
 
        Maximus Attacks Bob and Deals 48 Damage
        Bob Has -42 Health
 
        Bob has Died and Maximus is Victorious
 
        Game Over
        */
 
        static void Main(string[] args)
        {
            Warrior maximus = new Warrior("Maximus", 1000, 120, 40);
            Warrior bob = new Warrior("Bob", 1000, 120, 40);
 
            Battle.StartFight(maximus, bob);
 
            Console.ReadLine();
 
        }
        
    }
 
}

Part 2 - C# Advanced

9. Abstract Classes, Virtual Methods, Abstract Methods, Override, Base Classes, Is, As, Casting, and more about Polymorphism

 
xxxxxxxxxx
// ---------- Shape.cs ----------
using System;
 
// Very often you want to define a
// class that you don't want to be
// instantiated. In that case an 
// Abstract class may be the way to
// go. 
 
namespace CSharpTutA.cs
{
    abstract class Shape
    {
        public string Name { get; set; }
 
        // You can define non-abstract
        // methods in an abstract class
        public virtual void GetInfo()
        {
            Console.WriteLine($"This is a {Name}");
        }
 
        // We want subclasses to override
        // this method so mark it as abstract
        // You can only make abstract methods 
        // in abstract classes
        public abstract double Area();
 
    }
}
 
// ---------- Circle.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Circle : Shape
    {
        public double Radius { get; set; }
 
        public Circle(double radius)
        {
            Name = "Circle";
            Radius = radius;
        }
 
        public override double Area()
        {
            return Math.PI * (Math.Pow(Radius, 2.0));
        }
 
        // You can replace the method using override
        public override void GetInfo()
        {
            // Execute the base version
            base.GetInfo();
            Console.WriteLine($"It has a Radius of {Radius}");
        }
 
    }
}
 
// ---------- Rectangle.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Rectangle : Shape
    {
        public double Length { get; set; }
        public double Width { get; set; }
 
        public Rectangle(double length,
            double width)
        {
            Name = "Rectangle";
            Length = length;
            Width = width;
        }
 
        public override double Area()
        {
            return Length * Width;
        }
 
        // You can replace the method using override
        public override void GetInfo()
        {
            // Execute the base version
            base.GetInfo();
            Console.WriteLine($"It has a Length of {Length} and Width of {Width}");
        }
    }
}
 
// ---------- Program.cs ----------
 
using System;
 
// This time we cover Abstract Classes, Abstract
// Methods, Base Classes, Is, As, Casting and
// more about Polymorphism
 
namespace CSharpTutA.cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // We can store our shapes in
            // a Shape array as long as it 
            // contains subclasses of Shape
            Shape[] shapes = {new Circle(5),
            new Rectangle(4,5)};
 
            // Cycle through shapes and print
            // the area
            foreach(Shape s in shapes)
            {
                // Call the overidden method
                s.GetInfo();
 
                Console.WriteLine("{0} Area : {1:f2}",
                s.Name, s.Area());
 
                // You can use as to check if an
                // object is of a specific type
                Circle testCirc = s as Circle;
                if(testCirc == null)
                {
                    Console.WriteLine("This isn't a Circle");
                }
 
                // You can use is to check the data
                // type
                if(s is Circle)
                {
                    Console.WriteLine("This isn't a Rectangle");
                }
 
 
                Console.WriteLine();
            }
 
            // You can store any class as a base
            // class and call the subclass methods
            // even if they don't exist in the base
            // class by casting
            object circ1 = new Circle(4);
 
            Circle circ2 = (Circle)circ1;
            Console.WriteLine("The {0} Area is {1:f2}",
                circ2.Name, circ2.Area());
            
 
            Console.ReadLine();
 
        }
        
    }
 
}

10. Abstract Methods, Inheriting an Interface, How to Create Flexible Designs, and the Command Design Pattern

 
xxxxxxxxxx
// ---------- IDrivable.cs ----------
 
namespace CSharpTutA.cs
{
    // An interface is a class with nothing but
    // abstract methods. Interfaces are used
    // to represent a contract an object may
    // decide to support.
 
    // Interfaces commonly have names that
    // are adjectives because adjectives
    // modify nouns (Objects). The also
    // describe abstract things
 
    // It is common to prefix your interfaces with 
    // an I
 
    interface IDrivable
    {
        // Interfaces can have properties
        int Wheels { get; set; }
        double Speed { get; set; }
 
        // Classes that inherit an interface
        // must fulfill the contract and 
        // implement every abstract method
        void Move();
        void Stop();
    }
}
 
// ---------- Vehicle.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    class Vehicle : IDrivable
    {
        // Vehicle properties
        public string Brand { get; set; }
 
        public Vehicle(string brand = "No Brand",
            int wheels = 0,
            double speed = 0)
        {
            Brand = brand;
            Wheels = wheels;
            Speed = speed;
        }
 
        // Properties and methods from
        // the interface
        public double Speed {get; set;}
 
        public int Wheels {get; set;}
 
        public void Move()
        {
            Console.WriteLine($"The {Brand} Moves Forward at {Speed} MPH");
        }
 
        public void Stop()
        {
            Console.WriteLine($"The {Brand} Stops");
            Speed = 0;
        }
    }
}
 
// ---------- Program.cs ----------
 
using System;
 
// A class can support multiple interfaces. 
 
// Create an interface Project -> Add New Item
// and select Interface
 
namespace CSharpTutA.cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Vehicle object
            Vehicle buick = new Vehicle("Buick",
                4, 160);
 
            // Check if Vehicle implements 
            // IDrivable
            if(buick is IDrivable)
            {
                buick.Move();
                buick.Stop();
            } else
            {
                Console.WriteLine("The {0} can't be driven", buick.Brand);
            }
 
            // We are now modeling the act of
            // picking up a remote, aiming it
            // at the TV, clicking the power
            // button and then watching as
            // the TV turns on and off
 
            // Pick up the TV remote
            IElectronicDevice TV = TVRemote.GetDevice();
 
            // Create the power button
            PowerButton powBut = new PowerButton(TV);
 
            // Turn the TV on and off with each 
            // press
            powBut.Execute();
            powBut.Undo();
 
            Console.ReadLine();
 
        }
        
    }
 
}
 
// ---------- IElectronicDevice.cs ----------
 
namespace CSharpTutA.cs
{
    // With interfaces you can create very
    // flexible systems. Here I'll model
    // generic electronic devices like 
    // TVs and Radios and remotes that 
    // control them and the buttons on the
    // remotes. 
    interface IElectronicDevice
    {
        // We want each device to have 
        // these capabilities
        void On();
        void Off();
        void VolumeUp();
        void VolumeDown();
 
    }
}
 
// ---------- Television.cs ----------
 
using System;
 
namespace CSharpTutA.cs
{
    // Because we implemented the 
    // ElectronicDevice interface any
    // other device we create will know
    // exactly how to interface with it.
    class Television : IElectronicDevice
    {
        public int Volume { get; set; }
 
        public void Off()
        {
            Console.WriteLine("The TV is Off");
        }
 
        public void On()
        {
            Console.WriteLine("The TV is On");
        }
 
        public void VolumeDown()
        {
            if (Volume != 0) Volume--;
            Console.WriteLine($"The TV Volume is at {Volume}");
        }
 
        public void VolumeUp()
        {
            if (Volume != 100) Volume++;
            Console.WriteLine($"The TV Volume is at {Volume}");
        }
    }
}
 
// ---------- ICommand.cs ----------
 
namespace CSharpTutA.cs
{
    interface ICommand
    {
        // We can model what happens when
        // a button is pressed for example
        // a power button. By breaking
        // everything down we can add
        // an infinite amount of flexibility
        void Execute();
        void Undo();
    }
}
 
// ---------- PowerButton.cs ----------
 
namespace CSharpTutA.cs
{
    class PowerButton : ICommand
    {
        // You can refer to instances using
        // the interface
        IElectronicDevice device;
 
        // Now we get into the specifics of
        // what happens when the power button
        // is pressed.
        public PowerButton(IElectronicDevice device)
        {
            this.device = device;
        }
 
        public void Execute()
        {
            device.On();
        }
 
        // You can provide a way to undo
        // an action just like the power 
        // button does on a remote
        public void Undo()
        {
            device.Off();
        }
    }
}
 
// ---------- TVRemote.cs ----------
 
namespace CSharpTutA.cs
{
    class TVRemote
    {
        // Now we are modeling the action of
        // picking up the remote with our hand
        public static IElectronicDevice GetDevice()
        {
            return new Television();
        }
    }
}

11. C# Collections : ArrayLists, Dictionaries, Queues, and Stacks

 
xxxxxxxxxx
using System;
using System.Linq;
 
// Used for ArrayLists
using System.Collections;
 
// Used for Dictionary
using System.Collections.Generic;
 
namespace CSharpTutA.cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Collections can resize unlike arrays
 
            // #region provides a way to collapse
            // long blocks of code
 
            // ---------- ARRAYLISTS ----------
 
            // ArrayLists are resizable arrays
            // that can hold multiple data types
            ArrayList aList = new ArrayList();
 
            aList.Add("Bob");
            aList.Add(40);
 
            // Number of items in list
            Console.WriteLine("Count: {0}",
                aList.Count);
 
            // The capacity automatically increases
            // as items are added
            Console.WriteLine("Capacity: {0}",
                aList.Capacity);
 
            ArrayList aList2 = new ArrayList();
 
            // Add an object array
            aList2.AddRange(new object[] { "Mike", "Sally", "Egg" });
 
            // Add 1 array list to another
            aList.AddRange(aList2);
 
            // You can sort the list if the types 
            // are the same
            aList2.Sort();
            aList2.Reverse();
 
            // Insert at the 2nd position
            aList2.Insert(1, "Turkey");
 
            // Get the 1st 2 items
            ArrayList range = aList2.GetRange(0, 2);
 
            /*
            // Remove the first item
            aList2.RemoveAt(0);
 
            // Remove the 1st 2 items
            aList2.RemoveRange(0, 2);
            */
 
            // Search for a match starting at the provided 
            // index. You can also find the last index
            // with LastIndexOf
            Console.WriteLine("Turkey Index : {0}",
                aList2.IndexOf("Turkey", 0)); 
 
            // Cycle through the list
            foreach (object o in range)
            {
                Console.WriteLine(o);
            }
 
            // Convert an ArrayList into a string array
            string[] myArray = (string[])aList2.ToArray(typeof(string));
 
            // Convert a string array into an ArrayList
            string[] customers = { "Bob", "Sally", "Sue" };
            ArrayList custArrayList = new ArrayList();
            custArrayList.AddRange(customers);
 
            #endregion
 
 
            // ---------- DICTIONARIES ----------
            #region Dictionary Code
 
            // Dictionaries store key value pairs
            // To create them define the data
            // type for the key and the value
            Dictionary<string, string> superheroes = new Dictionary<string, string>();
 
            superheroes.Add("Clark Kent", "Superman");
            superheroes.Add("Bruce Wayne", "Batman");
            superheroes.Add("Barry West", "Flash");
 
            // Remove a key / value
            superheroes.Remove("Barry West");
 
            // Number of keys
            Console.WriteLine("Count : {0}",
                superheroes.Count);
 
            // Check if a key is present
            Console.WriteLine("Clark Kent : {0}",
                superheroes.ContainsKey("Clark Kent"));
 
            // Get the value for the key and store it
            // in a string
 
            superheroes.TryGetValue("Clark Kent", out string test);
 
            Console.WriteLine($"Clark Kent : {test}");
 
            // Cycle through key value pairs
            foreach(KeyValuePair<string, string> item in superheroes)
            {
                Console.WriteLine("{0} : {1}", 
                    item.Key,
                    item.Value);
            }
 
            // Clear a dictionary
            superheroes.Clear();
 
 
            #endregion
 
            // ---------- QUEUES ----------
            #region Queue Code
            // Queue 1st in 1st Out Collection
 
            // Create a Queue
            Queue queue = new Queue();
 
            // Add values
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
 
            // Is item in queue
            Console.WriteLine("1 in Queue : {0}",
                queue.Contains(1));
 
            // Remove 1st item from queue
            Console.WriteLine("Remove 1 : {0}",
                queue.Dequeue());
 
            // Look at 1st item but don't remove
            Console.WriteLine("Peek 1 : {0}",
                queue.Peek());
 
            // Copy queue to array
            object[] numArray = queue.ToArray();
 
            // Print array
            Console.WriteLine(string.Join(",", numArray));
 
            // Print queue items
            foreach (object o in queue)
            {
                Console.WriteLine($"Queue : {o}");
            }
 
            // Clear the queue
            queue.Clear();
 
 
            #endregion
 
            // ---------- STACKS ----------
            #region Queue Code
            // Stack Last in 1st Out Collection
 
            // Create a stack
            Stack stack = new Stack();
 
            // Put items on the stack
            stack.Push(1);
            stack.Push(2);
            stack.Push(3);
 
            // Get but don't remove item
            Console.WriteLine("Peek 1 : {0}",
                stack.Peek());
 
            // Remove item
            Console.WriteLine("Pop 1 : {0}",
                stack.Pop());
 
            // Does item exist on stack
            Console.WriteLine("Contain 1 : {0}",
                stack.Contains(1));
 
            // Copy stack to array
            object[] numArray2 = stack.ToArray();
 
            // Print array
            Console.WriteLine(string.Join(",", numArray2));
 
            // Print the stack
            foreach (object o in stack)
            {
                Console.WriteLine($"Stack : {o}");
            }
 
            // Clear stack
 
            Console.ReadLine();
 
        }
        
    }
 
}