Introducing C# and .NET 6

Exploring Some Key Benefits of the .NET Platform

Understanding the .NET Support Lifecycle

Previewing the Building Blocks of the .NET Platform

The Role of the Base Class Libraries

The Role of .NET Standard

What C# Brings to the Table

Managed vs Unmanaged code

Using Additional .NET-Aware Programming Languages

Getting an Overview of .NET Assemblies

The Common Type System

The Common Language Specification

 Rule 1: CLS rules apply only to those parts of a type that are exposed outside the defining assembly.

The .NET Runtime

Namespaces

ildasm.exe

Summary

Breaking Down a Simple C# Program

using System;

namespace SimpleCSharpApp
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Hello World");
    }
  }
}

Console.WriteLine("Hello World");

class Program
{
  static void Main(string[] args)
  {
    // Display a simple message to the user
    Console.WriteLine("***** My First C# App *****");
    Console.WriteLine("Hello World");
    Console.WriteLine();

    // Wait for Enter to be pressed before shutting down
    Console.ReadLine();
  }
}

Using Top-Level Statements

Specifying an Application Error Code

Processing Command-Line Arguments

// Display a message and wait for Enter key to be pressed.
Console.WriteLine("My First C# App");
Console.WriteLine("Hello world");
Console.WriteLine();
// Process any incoming args.
for (int i = 0; i < args.Length; i++)
{
  Console.WriteLine("Arg: {0}", args[i]);
}
Console.ReadLine();
// Return an arbitrary error code.
return 0;

static int Main(string[] args)
{
...
}

foreach(string args in args)
{
  Console.WriteLine("Arg: {0}", arg);
}
Console.ReadLine();
return 0;

string[] theArgs = Environment.GetCommandLineArgs();
foreach(string arg in theArgs)
{
  Console.WriteLine("Arg: {0}", arg);
}
Console.ReadLine();
return 0;

Specifying Command-Line Arguments with Visual Studio 2022

Additional Members of the System.Environment Class

Using the System.Console Class

The Console class encapsulates input, output, and error-stream manipulations for console-based applications.

Performing Basic Input and Output (I/O) with the Console Class

static void GetUserData()
{
  Console.Write("Please enter your name: ");
  string userName = Console.ReadLine();
  Console.Write("Please enter your age: ");
  string userAge = Console.ReadLine();

  ConsoleColor prevColor = Console.ForegroundColor;
  Console.ForegroundColor = ConsoleColor.Yellow;

  Console.WriteLine("Hello {0}! You are {1} years old.",
  userName, userAge);

  Console.ForegroundColor = prevColor;
}

Formatting Console Output

Formatting Numerical Data

Console.WriteLine("c format: {0:c}", 99999);
Console.WriteLine(f3 format: {0:f3}", 99999);

Formatting Numerical Data Beyond Console Applications

string userMessage = string.Format("10000 in hex is {0:x}", 10000);

Working with System Data Types and Corresponding C# Keywords

C# defines keywords for fundamental data types which are used to represent local variables, class data member variables, method return values, and parameters. The C# data type keywords are shorthand notations for types in the System namespace. Not all of the types are compliant with the Common Language Specification.

Understanding Variable Declaration and Initialization

bool b1 = true, b2 = false, b3 = b1;

System.Boolean b4 = false;

The default Literal

int myInt = default;

Using Intrinsic Data Types and the new Operator

bool b = new bool();

bool b = new();

Understanding the Data Type Class Hierarchy

Even the primitive .NET data types are arranged in a class hierarchy.

Ultimately, each type if derived from System.Object. This defines a set of methods common to all types in the .NET Core base class libraries including ToString(), Equals(), and GetHashCode().

Note that many numerical types derive from a class called ValueType. Descendents of ValueType are automatically allocated on the stack, and therefore, have a predictable lifetime and are quite efficient. Types that do not have System.ValueType are instead allocated on the garbage-collected heap.

Understanding the Members of Numerical Data Types

Understanding the Members of System.Boolean

Understanding the Members of System.Char

Parsing Values from String Data

bool b = bool.Parse("True");

Using TryParse to Parse Values from String Data

bool b = bool.Parse("Hello");

Using System.DateTime and System.TimeSpan

Working with the System.Numerics Namespace

using System.Numerics;

Using Digit Separators

Console.Write(123_456.12);

Using Binary Literals

Console.WriteLine(0b_0001_0000);

Working with String Data

Be aware that a few members of System.String are static and therefore called at the class level.

Note strings are immutable and so methods like Replace() actually are returning a new string.

Performing String Concatenation

string s3 = s1 + s2;

string s3 = String.Concat(s1, s2);

Using Escape Characters

C# string literals may contain various escape characters which qualify how the character data should be printed to the output stream. Each begins with a backslash.

Performing String Interpolation

Performance Improvements

Defining Verbatim Strings

Working with Strings and Equality

Modifying String Comparison Behavior

Strings Are Immutable

Using the System.Text.StringBuilder Typer

using System.Text;

StringBuilder sb = new StringBuild("*****");
sb.Append("\n");

Narrowing and Widening Data Type Conversions

short numb1 = 9, numb2 = 10;
Console.WriteLine("{0} + {1}",
  numb1, numb2, Add(numb1, numb2));
Console.ReadLine();

static int Add(int x, int y)
{
  return x + y;
}

Formally speaking, widening is the term used to define an implicit upward cast that does not result in a loss of data.

short answer = (short)Add(numb1, numb2);

Using the checked Keyword

byte sum = checked((byte)Add(b1, b2));

Setting Project-wide Overflow Checking

Using the unchecked Keyword

Understanding Implicitly Typed Local Variables

Console.WriteLine("myString is a: {0}", myString.GetType().Name);

Declaring Numerics Implicitly

Understanding Restrictions on Implicitly Typed Variables

class ThisWillNeverCompile
{
  // Error!
  private var myInt = 10;

  // Error!
  public var MyMethod(var x, var y){}
}

Implicitly Typed Data is Strongly Typed Data

Understanding the Usefulness of Implicitly Typed Local Variables

Working with C# Iteration Constructs

for(int i = 0; i < 4; i++)
{
  Console.WriteLine("Number is: {0} ", i);
}

string[] carTypes = {"Ford", "BMW", "Yugo", "Honda"};
foreach (string c in carTypes)
{
  Console.WriteLine(c);
}

// LINQ query!
var subset = from i in numbers where i < 10 select i;

foreach (var i in subset)
{
  Console.Write("{0} ", i);
}

while(userIsDown.ToLower() != "yes")
{
...
}

A Quick Discussion About Scope

Working with Decision Constructs and the Relational/Equality Operators

Using Logical Operators

Using the switch Statement

Using switch Expressions

static string FromRainbow(string colorBand)
{
  return colorBand switch
  {
    "Red" => "FF0000",
    "Orange" => "FF7F00",
    _ => "#FFFFFF",
  };
}

static string RockPaperScissors(string first, string second)
{
  return (first, second) switch
  {
    ("rock", "paper") => "Paper wins.",
    ...
    (_, _) => "Tie.",
  };
}

Summary

Understanding C# Arrays

static void SimpleArrays()
{
  Console.WriteLine("=> Simple Array Creation.");
  // Create and fill an array of 3 integers
  int[] myInts = new int[3];
  // Create a 100 item string array, indexed 0 - 99
  string[] booksOnDotNet = new string[100];
  Console.WriteLine();
}

myInts[0] = 100;
myInts[1] = 200;

Looking at the C# Array Initialization Syntax

string[] stringArray = new string[] { "one", "two", "three" };
bool[] boolArray = { false, false, false };
int[] intArray = new int[4] { 20, 22, 23, 0 };

Understanding Implicitly Typed Local Arrays

var a = new[] { 1, 10, 100, 1000 };

Defining an Array of Objects

Working with Multidimensional Arrays

int[,] myMatrix;
int[][] myJagArray = new int[5][];

Using Arrays As Arguments or Return Values

Using the System.Array Base Class

Many members of System.Array are defined as static members (Array.Sort(), Array.Reverse()). Others such as Length are bound at the object level.

Using Indices and Ranges

Understanding Methods

// Recall that static methods can be called directly
// without creating a class instance.
// static returnType MethodName(parameter list) { /* Implementation */ }
static int Add(int x, int y)
{
  return x + y;
}

Understanding Expression-Bodied Members

static int Add(int x, int y) => x + y;

Understanding Local Functions

Understanding Method Parameters

Understanding Method Parameter Modifiers

The default way a parameter is sent into a function is by value. This means that a copy of the data is passed into the function. Exactly what is copied will depend on if the parameter is a value type or reference type. Parameter modifiers can be used to control how arguments are passed to a method.

Understanding the Default Parameter-Passing Behavior

The Default Behavior for Value Types

The Default Behavior for Reference Types

Using the out Modifier

static void AddUsingOutParam(int x, int y, out int ans)
{
  ans = x + y;
}

int ans;
AddUsingOutParam(90, 90, out ans);

Discarding out Parameters

FillTheseValues(out int a, out _, out _);

The out Modifier in Constructors and Initializers

Using the ref Modifier

public static void SwapStrings(ref string s1, ref string s2)
{
  string tempStr = s1;
  s1 = s2;
  s2 = tempStr;
}

Using the in Modifier

Using the params Modifier

Defining Optional Parameters

static void EnterLogData(string message, string owner = "Programmer")
{
  Console.WriteLine("Error: {0}", message);
  Console.WriteLine("Owner of Error: {0}", owner);
}

Using Named Arguments

Understanding Method Overloading

Checking Parameters for Null

static void EnterLogData(string message, string owner = "Programmer")
{
  if (message == null)
  {
    throw new ArgumentNullException(message);
  }
  ...
}

ArgumentNullException.ThrowIfNull(message);

Understanding the enum Type

// A custom enumeration
enum EmpTypeEnum
{
  Manager,
  Grunt,
  Contractor,
  VicePresident
}

enum EmpTypeEnum
{
  Manager = 102,
  Grunt,
  Contractor,
  VicePresident
}

Controlling the Underlying Storage for an enum

enum EmpTypeEnum : byte
{
  Manager = 10,
  Grunt = 1,
  Contractor = 100,
  VicePresident = 9
}

Declaring enum Variables

EmpTypeEnum emp = EmpTypeEnum.Contractor;

Using the System.Enum Type

Enum.GetUnderlyingType(emp.GetType()));

Dynamically Discovering an enum's Name-Value Pairs

Using Enums, Flags, and Bitwise Operations

Understanding the Structure

struct Point
{
  public int X;
  public int Y;

  public void Increment()
  {
    X++; Y++;
  }
}

Creating Structure Variables

Point p2;
p2.X = 10;
p2.Y = 10;
p2.Display();

Structure Constructors

struct Point
{
  public int X;
  public int Y;

  public Point(int xPos, int yPos)
  {
    X = xPos;
    Y = yPos;
  }
  ...
}

Point p2 = new Point(50, 60);

struct Point
{
  ...
  public Point()
  {
    X = 0;
    Y = 0;
  }
}

Using Field Initializers

struct Point
{
  public int X = 5;
  public int Y = 7;
}

Using Read-Only Structs

readonly struct ReadOnlyPoint
{
...
}

Using Read-Only Members

Using ref Structs

Using Disposable ref Structs

Understanding Value Types and Reference Types

Using Value Types, Reference Types, and the Assignment Operator

Using Value Types Containing Reference Types

Passing Reference Types by Value

Passing Reference Types by Reference

Final Details Regarding Value Types and Reference Types

• Allocated on the stack
• Extends System.ValueType
• Cannot be inherited from
• Passed by value
• Die when falling out of scope

• Allocated on the managed heap
• Can derive from any type except System.ValueType
• Reference is passed by value
• Dies when garbage collected

Understanding C# Nullable Types

static void LocalNullableVariables()
{
  int? nullableInt = 10;
  double? nullableDouble = 3.14;
}

Using Nullable Value Types

Nullable<int> nullableInt = 10;

Using Nullable Reference Types

Opting in for Nullable Reference Types

Nullable Reference Types in Action

Migration Considerations

Change Nullable Warnings to Errors

Operating on Nullable Types

The Null-Coalescing Operator

int myData = dr.GetIntFromDatabase() ?? 100;

The Null-Coalescing Assignment Operator

int? nullableInt = null;
nullableInt ??= 12;
nullableInt ??= 14; // does not assign 14 to the variable since it is not null

The Null Conditional Operator

args?.Length

Console.WriteLine($"You sent me {args?.Length ?? 0} arguments."); 

Understanding Tuples

Getting Started with Tuples

(string, int, string) values = ("a", 5' "c");

Console.WriteLine($"First item: {values.Item1}");

(string FirstLetter, int TheNumber, string SecondLetter) valuesWithNames = ("a", 5, "c");
var valuesWithNames2 = (FirstLetter: "a", TheNumber: 5, SecondLetter: "c")

var nt = (5, 4, ("a", "b"));

Using Inferred Variable Names

Understanding Tuple Equality/Inequality

Understanding Tuples as Method Return Values

Understanding Discards with Tuples

Understanding Tuple Pattern Matching switch Expressions

Deconstructing Tuples

(int x1, int y1) = myTuple;

Deconstructing Tuples with Positional Pattern Matching

Summary

This chapter began with an examination of arrays. Then, we discussed the C# keywords that allow you to build custom methods. Recall that by default parameters are passed by value; however, you may pass a parameter by reference if you mark it with ref or out. You also learned about the role of optional or named parameters and how to define and invoke methods taking parameter arrays. After you investigated the topic of method overloading, the bulk of this chapter examined several details regarding how enumerations and structures are defined in C# and represented within the .NET Core base class libraries. Along the way, you examined several details regarding value types and reference types, including how they respond when passing them as parameters to methods and how to interact with nullable data types and variables that might be null (e.g., reference type variables and nullable value type variables) using the ?, ??, and ??= operators. The final section of the chapter investigated a long-anticipated feature in C#, tuples. After getting an understanding of what they are and how they work, you used them to return multiple values from methods as well as to deconstruct custom types. 

Introducing the C# Class Type

class Car
{
  public string petName;
  public int currSpeed;
}

class Car
{
  public void PrintState()
    => Console.WriteLine("{0} is going {1} MPH.", petName, currSpeed);

  public void SpeedUp(int delta)
    => currSpeed += delta;
}

Allocating Objects with the new Keyword

Understanding Constructors

Understanding the Role of the Default Constructor

class Car
{
  public string petName;
  public int currSpeed;
  
  public Car()
  {
    petName = "Chuck";
    currSpeed = 10;
  }
...
}

Defining Custom Constructors

Constructors As Expression-Bodied Members

public Car(String pn) => petName = pn;

Constructors with out Parameters

public Car(string pn, int cs, out bool inDanger)
{
  petName = pn;
  currSpeed = cs;
  if (cs > 100)
  {
    inDanger = true;
  }
  else
  {
    inDanger = false;
  }
}

Understanding the Default Constructor Revisited

Understanding the Role of the this Keyword

Chaining Constructor Calls Using this

Observing Constructor Flow

Revisiting Optional Arguments

Understanding the static Keyword

Defining Static Field Data

Defining Static Methods

Defining Static Constructors

Defining Static Classes

Importing Static Members via the C# using Keyword

Defining the Pillars of OOP

Understanding the Role of Encapsulation

Understanding the Role of Inheritance

Understanding the Role of Polymorphism

Understanding C# Access Modifiers

Types (classes, interfaces, structures, enumerations, and delegates) and their members (properties, methods, constructors, and fields) are defined using a keyword that specifies how visible that item is to other parts of the application.

Using the Default Access Modifiers

class Radio
{
  Radio(){}
}

Using Access Modifiers and Nested Types

Understanding the First Pillar: C#'s Encapsulation Services

Encapsulation Using Traditional Accessors and Mutators

Encapsulation using Properties

class Employee
{
  // Field data
  private string _empName;
  private int _empId;
  private float _currPay;
  // Properties
  public string Name
  {
    get { return _empName; }
    set {
      if (value.Length > 15)
      {
        Console.WriteLine("Error");
      }
      else
      {
        _empName = value;
      }
    }
  }
  public int Id
  {
    get { return _empId; }
    set { _empId = value; }
  }
}

public string Name
{
  get { return _empName; }
  set {
    if (value.Length > 15)
    {  Console.WriteLine("error");
    }
    else
    {
      empName = value;
    }
  }
}

Properties As Expression-Bodied Members

public int Age
{
  get => empAge;
  set => empAge = value;
}

Using Properties Within a Class Definition

Read-Only Properties

public string SocialSecurityNumber
{
  get { return _empSSN; }
}

public string SocialSecurityNumber => _empSSN;

Write-Only Properties

Mixing Private and Public Get/Set Methods on Properties

public string SocialSecurityNumber
{
  get => _empSSN;
  private set => _empSSN = value;
}

Revisiting the static Keyword: Defining Static Properties

class SavingsAccount
{
  public static double InterestRate
  {
    get { return _currInterestRate; }
    set { _currInterestRate = value; }
  }
...
}

Pattern Matching with Property Patterns

Extended Property Patterns

Understanding Automatic Properties

class Car
  // Automatic properties! No need to define backing fields.
  public string PetName { get; set; }
  public int Speed { get; set; }
  public string Color { get; set; }
}

Interacting with Automatic Properties

Automatic Properties and Default Values

Initializing Automatic Properties

class Car
{
  private int numberOfDoors = 2;
}

class Garage
  // The hidden backing field is set to 1
  public int NumberOfCars { get; set; } = 1;

  // The hidden backing field is set to a new Car object.
  public Car MyAuto { get; set; } = new Car();

  public Garage(){}
  public Garage(Car car, int number)
  {
    MyAuto = car;
    NumberOfCars = number;
  }
}

Understanding Object Initialization

Looking at the Object Initialization Syntax

// Make a Point by setting each property manually.
Point firstPoint = new Point();
firstPoint.X = 10;
firstPoint.Y = 10;

// Or make a Point via a custom constructor
Point anotherPoint = new Point(20, 20);

// Or make a Point using object init syntax
Point finalPoint = new Point { X = 30, Y = 30 };

Using init-Only Setters

class PointReadOnlyAfterCreation
{
  public int X { get; init; }
  public int Y { get; init; }
}

Calling Custom Constructors with Initialization Syntax

Point pt = new Point(10, 16) { X = 100, Y = 100 };

Initializing Data with Initialization Syntax

Rectangle myRect = new Rectangle
{
  TopLeft = new Point { X = 10, Y = 10},
  BottomRight = new Point { X = 200, Y = 200}
};

Working with Constant and Read-Only Field Data

Understanding Constant Field Data

class MyMathClass
{
  public const double PI = 3.14;
}

Constant Interpolated Strings

Understanding Read-Only Fields

class MyMathClass
{
  // Read-only fields can be assigned in constructors,
  // but nowhere else.
  public readonly double PI;

  public MyMathClass ()
  {
    PI = 3.14;
  }
}

Understanding Static Read-Only Fields

Understanding Partial Classes

Records

Understanding the Basic Mechanics of Inheritance

Specifying the Parent Class of an Existing Class

class MiniVan : Car
{
}

Regarding Multiple Base Classes

Using the sealed Keyword

Revisiting Visual Studio Class Diagrams

Understanding the Second Pillar of OOP: The Details of Inheritance

Calling Base Class Constructors with the base Keyword

public Manager(string fullName, int age, int empId, float currPay, string ssn, int numbOfOpts)
  : base(fullName, age, empId, currPay, ssn, EmployeePayTypeEnum.Salaried)
{
  // This property is defined by the Manager class.
  StockOptions = numbOfOpts;
}

Keeping Family Secrets: The protected Keyword

Adding a sealed Class

Understanding Inheritance with Record Types

Inheritance for Record Types with Standard Properties

Inheritance for Record Types with Positional Parameters

Nondestructive Mutation with Inherited Record Types

Equality with Inherited Record Types

Deconstructor Behavior with Inherited Record Types

Programming for Containment/Delegation

partial class Employee
{
  // Contain a BenefitPackage object.
  protected BenefitPackage EmpBenefits = new BenefitPackage();
  
  // Expose certain benefit behaviors of object.
  public double GetBenefitCost() => EmpBenefits.ComputePayDeduction();

  // Expose object through a custom property
  public BenefitPackage Benefits
  {
    get { return EmpBenefits; }
    set { EmpBenefits = value; }
  }
}

Understanding Nested Type Definitions

public class OuterClass
{
  // A public nested type can be used by anybody.
  public class PublicInnerClass {}
  
  // A private nested type can only be used by members
  // of the containing class
  private class PrivateInnerClass {}
}

Understanding the Third Pillar of OOP: C#'s Polymorphic Support

Using the virtual and override Keywords

public override void GiveBonus(float amount)
{
...
  public override void GiveBonus(float amount)
  {
    base.GiveBonus(amount);
    Random r = new Random();
    StockOptions += r.Next(500);
  }
}

Overriding Virtual Members with Visual Studio/Visual Studio Code

Sealing Virtual Members

Understanding Abstract Classes

Understanding the Polymorphic Interface

Understanding Member Shadowing

Understanding Base Class/Derived Class Casting Rules

Using the C# as Keyword

foreach (object item in things)
{
  Hexagon h = item as Hexagon;
  if (h == null)
  {
    Console.WriteLine("Item is not a hexagon.");
  }
  else
  {
    h.Draw();
  }
}

Using the C# is Keyword

The is keyword can be used to determine whether two items are compatible. is will return false, rather than null, if the types are incompatible.

static void GivePromotion(Employee emp)
{
  Console.WriteLine("{0} was promoted.", emp.Name);
  if (emp is SalesPerson)
  {
    Console.WriteLine("{0} made {1} sales.", emp.Name, ((SalesPerson)emp).SalesNumber);
  }
  else if (emp is Manager)
  {
    ...
  }
}

static void GivePromotion(Employee emp)
{
  Console.WriteLine("{0} was promoted!", emp.Name);
  // Check if is SalesPerson, assign to variable s
  if (emp is SalesPerson s)
  {
    Console.WriteLine("{0} made {1} sale(s)., s.Name, s.SalesNumber);
  }
...
}

if (emp is not Manager and not SalesPerson)
{
  ...
}

Discards with the is Keyword

if (obj is var _)
{
  // do something
}

Revisiting Pattern Matching

static void GivePromotion(Employee emp)
{
  switch (emp)
  {
    case SalesPerson s:
      Console.WriteLine(...);
      break;
    case Manager m:
      ...
   }
}

Discards with switch Statements

case Employee _:
  ...
  break;

Understanding the Super Parent Class: System.Object

You may have noticed that the base classes in the example hierarchies do not explicitly specify their parent classes. In .NET, every type ultimately derives from a base class named System.Object, represented in C# with the object keyword. System.Object defines a set of common members for every type in the framework. When you build a class that does not explicitly define its parent, the compiler automatically derives your type from System.Object.

The System.Object defines a set of methods, some marked virtual, and others marked static.

Overriding System.Object.ToString()

public override string ToString() => $"[First Name: {FirstName}; Last Name: {LastName};
Age: {Age}]";

Overriding System.Object.Equals()

Overriding System.Object.GetHashCode()

Using the Static Members of System.Object

Summary

This chapter explored the role and details of inheritance and polymorphism. Over these pages you were introduced to numerous new keywords and tokens to support each of these techniques. For example, recall that the colon token is used to establish the parent class of a given type. Parent types are able to define any number of virtual and/or abstract members to establish a polymorphic interface. Derived types override such members using the override keyword. 
In addition to building numerous class hierarchies, this chapter also examined how to explicitly cast between base and derived types and wrapped up by diving into the details of the cosmic parent class in the .NET base class libraries: System.Object.