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