C# Cheat Sheet

In C#, namespaces are like surrounding containers to organize common code. If a code file has a namespace declared, it must be called by its full name when using it, or the namespace loaded at the top by the using keyword. The default namespace is called <Main>$ and is added by the compiler automatically to any partial class that has no namespace. It is then merged with the top-level program class, and can be called directly.

//namespace declared (use semi-colon if only one per file)//otherwise need brackets to enclose everything that belongs

namespace MyCompany.Utilities;
 public class Calculator
  {
     public int Add(int a, int b)
     {
        return a + b;
     }
  }

// In another file in your project, using the namespace to access the Calculator class
using MyCompany.Utils;

// Now you can use Calculator directly
Calculator calc = new Calculator();
int result = calc.Add(5, 3); 

//note no namespace declared
//This file will be merged with top-level program

partial class HelloWorld //merged with <Main>$
{
    static void SayHi() {
     {
         System.Console.WriteLine("Hello World");
    }
}

//Now you can call it directly without the full name or importing it

SayHi();

Namespace Alias

Use aliases for namespaces when 1) there may be a name conflict or 2) to shorten code

//top of file used
using env = System.Environment;
WriteLine(env.OSVersion);

//in project directive
<ItemGroup>
  <Using Include="Namespace.TargetType" Alias="TypeAlias " />
</ItemGroup>

For use before classes, methods, fields
Always explicitly specify for clarity

Class Modifiers
internal — only accessible from within assembly (default)
public — accessible everywhere
file — can only be used within its code file
partial — will be merged with its companion(s)
interface — does not allow instantiation, requires full implementation in classes that inherit it
abstract — not intended to be instantiated, only inherited — can have both implemented and abstract members
sealed — cannot be inherited
record — uses value equality rather than reference equality, cannot be inherited by a class
struct — for small, lightweight simple classes that do not need complex encapsulation, cannot be inherited
static — cannot be inherited or instantiated (use for extending other classes)

Member Modifiers
private — within same class (default)
public — everywhere — derived classes can call as if part of itself
public static — shared by all object instances, don’t need to create object with new to use
protected — within same class or any derived class
internal — within class and any derived class in same assembly
internal protected — within class, any class in same assembly, or any class that inherits it
private protected — within class, any class that inherits it from the same assembly
static — breaks the object wall, don’t need instance to call, call by class name
virtual — allow derived classes to override this
override — this is an override of a base class member marked with virtual
abstract — can only be declared within an abstract class, derived class MUST implement this

Value types (Stack Types)

Considered equal if the values match
Assignment copies the value into the variable
Lowercase keywords are aliases for types are recognized as .Net types and should be used
Adding ? after any value type variable disables null compiler warnings
Adding ! after a null assignment forgives a non-nullable type

int population; // default 0
double weight; // default 0
decimal price = 5.88M; //default 0 use M suffix
char letter = ‘Z’; //default ‘\0’ use single quotes
bool happy = true; //default false — must be in lowercase
short age; //default 0
long population; //default 0
DateTime birthdate = new(1960, 1, 31); //must use new to set with numbers
DateTime birthday = DateTime.Parse(“Jan 1, 1959”); //use parse to set with string
Point location = new (10, 20); //must use new to set x and y coords
struct or record struct // located in stack unless has heap types within it, default constructor generated if not there

Reference types (Heap Types)

Address in stack, value put in heap on new(). All default values are null
Considered equal if have the same heap address (exception: string)
Assignment copies the address into the variable
Adding ? after any reference type variable changes type to Nullable<T>

object
Person bob; //address put into stack
bob = new(); //now default Person is created in heap at that address
record
string //string is exception to equality rule (the value is compared)
string fruit = "apple"; //new() is optional on strings — use double quotes — default is null
string? myString; //becomes Nullable<string> — disables compiler warnings

Var Type

Using var as type, the compiler will set it at compile time. Use var when it’s obvious to a human reader what the type would be. Compiler can also infer from new() back to the data type;
var population = 67.5; //compiler knows you want a double.
var xml1 = new XmlDocument(); //compiler makes space for XmlDocument
XmlDocument xml1 = new(); //compiler also knows

Dynamic Type

Set at runtime, when an actual value is assigned, and can be changed.
dynamic returnResult; //compiler doesn’t know what you want.
returnResult = true; //oh ok it’s a boolean now
returnResult = 3.88M; //now it’s a decimal

NOTE: Can set any variable back to default with keyword default
fruit = default; //now is null

Nulls

Avoid NullReferenceException at runtime by checking for nulls before using variables

//use is or is not instead of == or !=
if (someVar is null) { }
if (someVar is not null) { }

//instead of throwing Exception, assign null
int? authorNameLength = authorName?.Length;

//assign a specific value if null
int authorNameLength = authorName?.Length ?? 25;

//check for nulls in method parameters using !!
public void Hire(Person manager!!, Person employee!!) { }
— now will automatically throw ArgumentNullException if either of these args are null

string line = new string('_', 52); — 2nd arg is number of times to repeat char (note single quotes)
string? input = Console.ReadLine(); — tell compiler that a null value is possible, so don’t warn

Verbatim
string myString = @"taken exactly as it is /even with backslashes (but not double quotes)";

Interpolation (sticking stuff inside a string)
string myString = Write($"{const1} is a {const2}"); //variable names use $
string myString = Write("{0} is a {1}", arg0: "Cat", arg1: "animal"); //passing args no $

Formatting
string myString = string.Format("{0} is {2}", "A rose", "a rose");
{0, -10} — format arg0 with min of 10 spaces, aligned left


String Stuff
string newstring = string.Concat(string1, string2);
string newstring = string1 + string2;
string.Empty — equals “” works like a global constant value

Extending String class

public static class MyStringExtensions   //make your class static
{
    public static bool IsValidEmail(this string input)  //use the this keyword before parameter
{ 
...

//now can use it in your code
string email1 = "terrymarr@test.comm";
bool isValid = email1.IsValidEmail();   //works like a method on base string class

:N0 —- format a number with thousands separator and zero decimals
:C — format a number as currency in the current culture
:B8 — format a number in binary with 8 digits
:B32 — format as binary padded with leading zeros to a width of 32
:X2 — format as Hexidecimal

NOTE: sizeof(type) for capitalized types (Int128, UInt128, Half) only works in unsafe code blocks

Weird Number Stuff

IMPORTANT!! Never compare two doubles using ==. (Using greater/lesser than is ok.)

Use decimals for money, engineering and for values that will be compared equally

Other Number Stuff

Use Math.BigMul(number1, number2) method when multiplying large integers to avoid overflow. Will return value in next largest type.

Set Globalization at top
using System.Globalization;
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US"); //or whatever

DateTime birthday = DateTime.Parse("6 June 1978"); //Parse converts string to DateTime
DateTime nye = new(2011, 12, 31); //must use new() if setting with numbers

Standard Date Formatting

WriteLine($"{birthday:D}"); //with a colon

Use arrays when the number of elements is fixed, e.g. a list of states.
string[] pacific; // declared but size not fixed yet — (any datatype)
string?[] pacific; //declare and can have null values
pacific = new string[3]; //size is fixed
string[] states = {"Washington", "Oregon", "California"}; //declared and fixed
states[0] = "Hawaii"; //set value by position
string[,] grid1; //declare 2-dimensional array
string[3,4] grid1; //declare and set number of elements in each dimension
string [][] jaggedarr; //array of arrays (each array can have different sizes (jagged))
arrayName.GetUpperBound(0) // the last position in the (first) array

Always use generics that force data typing within a collection
From System.Collections.Generic

List<T> — T can be any type
myList[3] — (positional)
myList.Sort();
myList.Reverse();

Dictionary<TKey, TValue> — both key and value can be any type
myDic[“keyname”] — (whatever key is)
eachMyDicElement.Value — get value
eachMyDicElement.Key — get key
myDic.Add(newkey, newvalue)

For fixed list of values
Int by default but can choose to inherit other integer types
Use byte if 8 values or less
Use ushort up to 16 values
Use uint up to 32 values
Use ulong up to 64 values
Use [Flags] decorator to allow multiple values

[Flags]
public enum DaysOfTheWeek : byte {
 Sunday = 0b_0000_0000, //0
 Monday = 0b_0000_0001,  //1
 Tuesday  0b_0000_0010,  //2
 Wednesday = 0b_0000_0100,  //4
 Thursday = 0b_0000_1000, //8
 Friday = 0b_0001_0000, //16
 Saturday = 0b_0010_0000 //32
};

//now can use it like this:
bob.CleaningSchedule = DaysOfTheWeek.Tuesday | DaysOfTheWeek.Friday;

When want to create a variable that has more than one value attached without creating new class
var myTuple = ("This is a string", 14); => myTuple.Item1 and myTuple.Item2

Referenced as Item1, Item2 unless named like so:
var myTuple = (Name: "Terry", Grade: "A"); //capitalize field names

Or inferred from another object’s fields
var bobGrades = (bob.English, bob.Spanish); => bobGrades.English and bobGrades.Spanish etc.

Can return tuple from a method:
public (string Name, int Age) GetNameAndAge()
{
return (Name: "Terry", Age: 30);
}

Can alias a tuple type at the top
using Fruit = (string Name, string AvailableMonth);
then instead of var can use your alias:
Fruit apples = (Name: "Fuji", AvailableMonth: "April");

Can deconstruct a tuple into its component parts
(string name, int age) = terry.GetNameAndAge(); => now name and age variables have values

Null-coalescing Operators

int maxLength = authorName?.Length ?? 30; — if it’s null make it 30 else Length
authorName ??= “unknown”; — if null make it “unknown”

Logical Operators — work when operands evaluate boolean

& (AND)— both operands are true
| (OR) — either operand is true
^ (Exclusive OR) — only if operands are different
&& (short-circuit) — if first operand is false, skip evaluating the second operand

Bitwise Operators — comparing bits — works when operands are integers

Ints are read as bits, then operator is used so 10 & 8 = 8
10 & 6 = 6 — 0001010 & 00000110 — returns 00000010 (set the column where both are true)
10 | 6 = 14 — 0001010 | 00000110 — returns 00001110 (set the column where either are true)
10 ^ 6 = 12 — 0001010 ^ 00000110 — returns 00001100 (set the column where only one is 1)
1 << 2 = 4 — 00000001 shifted to left 2 places = 00000100 = 4

Misc Operators

nameof(myVar) — name of variable
sizeof(myVar) — size in bytes

if else

if (boolean value or statement)
{   //always use braces
  do something if true
}
else
{
  do something if false
}

switch

switch (someVariable)
{
  case val1: 
    //DO SOMETHING HERE
    break;   //jump out of switch
  case val2:
    //DO SOMETHNG ELSE
    goto case 1; //jump to another case
  case val3:
  case val4:
    //3 FALLS INTO 4
    break;
  case val5:
    goto a_label;      //jump to label
  Default:
    //IF ALL ELSE FAIL WILL COME HERE
    break;
} //end of switch

a_label:  //jump label use sparingly if at all
//some code here;

Switch shorthand

Separate cases with comma (trailing on last one ok)
Omit case keyword and colon
_ denotes default case
Use => to return value from case, can be on new line
break; not needed

string message = animal switch
{
  Cat c when c.Legs == 4 => "4 legs",   
  Cat c when c.Legs == 3 => "3 legs", 
  Cat c when c.IsDomestic == false => "Wildcat",
  null => "The animal is null",
  _ => $"{animal.Name} is a {animal.GetType().Name}"
};  

Switch Case Pattern Matching

Can also check type of the variable in the case:
case Cat cat:
Or check type & property of a class variable in the case:
case Cat c when c.Legs == 4:
using shorthand
Cat c when c.Legs == 4 => "4 legs",
or even shorter (C#9 or later)
Cat {Legs: == 4} => "4 legs",

while

while (x < 10)
{  do something   x++;
}

do while

do
{
  do something
  x++;
}
while (x < 10)

for

for (int y = 1; y < 10; y++)
{
   do something
}

foreach

foreach (string name in names)
{
   WriteLine($"{name}");   //property values cannot be modified
}

Cast between similar types
Convert between different types

Implicit Casting

setting one type equal to another similar type
only works if data won’t be lost (make bigger not smaller)
can go up to parent class, but not down to more specific
int a = 10;
double b = a; //ok because double is bigger than int
Person alice = EmployeeAlice; //casted UP — Employee is derived from Person
Employee alice = PersonAlice; //won’t compile — cannot cast DOWN (must be explicit)

Explicit Casting

double c = 9.8;
int d = c; //won’t compile because int is smaller than double
int d = (int)c; //explicitly cast into an int (warning – will truncate)

Casting safely

if (personAlice is Employee)
{ 
    Employee explicitAlice = (Employee)personAlice;  //now can safely cast
}

OR
if (personAlice is not Employee)
... 

OR 
Employee? explicitAlice  = personAlice as Employee; //will be null if not cast
if (explicitAlice is not null) //now check for null
...

System.Convert

Use by importing System.Convert class
Will error if it cannot convert
ToInt32(9.8); // rounds up to 10

Converting To String

yourVariable.ToString()
dateTimeVar.ToString("mm/dd/yyyy"); //format you want
don’t have to call ToString when passing to WriteLine method

Safe conversion from binary to base64 string (for transmission)
string encoded = ToBase64String(byte[]); — takes array of bytes
string encoded = Base64Url.EncodeToString(ReadOnlySpan<byte>) –notice what it takes

Using TryParse method

Use TryParse method to avoid errors

//returns true or false, 
//out is the number if parseable

if (int.TryParse(input, out int result)) 
{
  intToStore = result;  
} else {
  //do something if not parseable
}

Class is the blueprint or type, Object is the instance
Build your code using classes
Put in a logically defined namespace (eg: MyCompany.Utilities)
Each class should be in its own file, can split into partial classes
Class objects are only equal if they have the same memory address (exception Record classes)
Record objects are equal if all the properties match

Inheritance
public class subclass/derived : superclass/base
Derived class IS A subtype of the base class (Car is a type of Vehicle)
Inheritance implies getting functionality for free from superclass which you can usually override.
A class can only inherit from one other class, but can implement many interfaces (separate with comma)
Exception: all objects automatically inherit from System.Object
If a base method is marked virtual (Go to definition) then you can override it
Constructors are not inherited. You must explicitly define and call them using base keyword.

System.Object

Available methods/properties:
objA.ToString() => namespace.className
objA.GetType() => namespace.className
objA.Equals(objB) => True if both point to the same reference
objA.GetHashCode() => Unique ID of this object

Record Class

Special type of class where the whole object is immutable after instantiation
Copy of a record object is considered equal if all the properties match
Ideal for holding records of data that won’t change after loading

public record class ImmutableVehicle   //best practice to use record and class keywords
{
     public int Color {get; set;}  //this makes this field still changeable
}

Now every time a change is made to the property, an entirely new object is copied into memory.
ImmutableVehicle car = new() {Color: "Gray"}; — original object
ImmutableVehicle repaintedCar = car with { Color = "Red" }; — copy — note keyword with to change prop

//simpler syntax to auto-generate constructor, deconstructor and properties
public record class ImmutableVehicle (string Color, string Make);

Now can construct like this:
ImmutableVehicle car = new("Blue", "Mazda");
And deconstruct:
var (color, make) = car;

Note: To make a record class unchangeable after instantiation use a constructor signature
public record class Unchangeable(string? Name);

Struct instead of Class

Use for simple stack-memory type, treats an object like a primitive value
A default (parameterless) constructor will be generated if not defined

• When total stack memory of all members is 16 bytes or less
• When all members are value types
• When it won’t be inherited

public struct
not immutable unless you add readonly keyword
can use .Equals to compare to instances (but not ==)

public record struct
immutable (creates copy of values)
can use .Equals or == to compare instances

An interface is a special class with method signatures for some expected functionality.
Any type that implements an interface promises that those methods will work on this type.
This class CAN DO these things.
A class can implement multiple interfaces.
Not to be used to instantiate objects, only to add functionality.
Every member of an interface must be public (or internal if only to be used in same assembly).
By default all members are abstract and public.
Some members may have default implementation (C# 8 or higher) which can be overridden.
Interfaces can have properties or methods, but not fields.
Any class that implements an interface or abstract class will not compile or instantiate unless fully implemented.

interface IAnimal
{
    void animalSound();  //signature only, does not have implementation
    void run();          //both these members MUST be implemented by any class that uses it
}

class Pig : IAnimal
{
   //override the two methods in the interface
   public void animalSound()   //Note don't need override keyword
    {
       WriteLine("wee wee wee");
    }
   public void run()   //must return same type as interface
   {
      WriteLine("The pig is running");
   }
}

Commonly used interfaces:

Used to store data about the object — together called state
Technically a Property is a method — runs with get/set — see below
Fields marked private are used with get/set — prefix with _underscore.
Fields marked static are shared across all instances
Fields marked const are set when declared/compiled and never change
To retrieve both static and const fields use class name, not instance name
Fields marked readonly are a better choice for non-changeable values,
– can be loaded at runtime and are attached to instance variables
Fields marked required must be given values (even null) at instantiation

Class functions that execute statements — with or without return value
public static — don’t need an instance of an object to be usable
public void MyMethod() — no result expected
public string MyMethod() — string expected with a return statement

Parameters

public string MyMethod(int namedParam) — required – value copy only exists inside method
public string MyMethod(int namedParam = 100) — optional parameter (put at end)
public string MyMethod(in int namedParam) — in cannot be changed inside the method
public string MyMethod(out int namedParam) — out must be set inside the method
– pass the receiving variable into method with out keyword myObj.MyMethod(out someInt);
– or can declare when passing myObj.MyMethod(out int someInt);
public string MyMethod(ref int namedParam) — ref in-out, doesn’t have to be set in the method
– pass variable into method with ref keyword myObj.MyMethod(ref someInt);

Overloading

Same name of method but using unique signatures (list of parameters with different types)

Extension Methods

In a static class, a method that extends the functionality of a passed in parameter (another class), adds a new method to it without altered the original class.

public static class CarExtensions  //make your class static
{
   //your method can return whatever you like, or alter and return original object
   public static bool IsRegistered(this Car car)  //use the this keyword before parameter
{ 
...

//now can use it in your code
Car myCar= new Car();
bool registered = myCar.IsRegistered();   //works like a method on base Car class

Special Method Categories

Constructor

Called when object with new keyword

//basic
public Book() {}

//or can set default values for fields
//including readonly fields
public Book()
{
    CreatedOn = DateTime.Now;
}

//with parameters to force the setting of required fields
//uses decorator from System.Diagnostics.CodeAnalysis 
[SetsRequiredMembers]  
public Book(string? isbn, string? title) : this() //inherit from default constructor
{
   Isbn = isbn;  //set as required in field definition
   Title = title;  //required
}

//overloaded constructor uses different signature (params with different types)
[SetsRequiredMembers]
public Book(string? isbn, string? title, int pages) : this()
{
   Isbn = isbn;  //set as required in field definition
   Title = title;  //required
   PageCount = pages;
}

Primary Constructor — defined with class

//positional params are a part of class definition (can only define one)
public class Headset(string manufacturer, string productName) //put right at the top with class
{
    public string Manufacturer { get; set; } = manufacturer;  //still need to set
    public string ProductName { get; set; } = productName;
}

Create new object using positional args: Headset bose = new Headset("Bose", "AudioMax");

Default Parameterless Constructor

//calls primary constructor to set default values
public Headset() : this("Microsoft", "HoloLens") {};  //note it inherits from itself with this

NOTE: Primary Constructors are controversial. Better to define constructors separately.

Property (Getter/Setter)

Called when getting or setting data
– readonly (only has a get method) public string Age => birthYear - DateTime.Now.Year;
– readwrite (must have both get & set) public string? FavoriteMovie {get; set;}
– init-only cannot change after initialized (replace set with init)
– with private field:

private string? _favoriteIceCream; //place to store

public string? FavoriteIceCream
{
     get
      {
        return _favoriteIceCream;
      }
     set
      {
       //do something here then 
       _favoriteIceCream = value;   //note implicit keyword 'value' (what is being assigned)
      }
}

Deconstructor

Use with tuples to deconstruct an object into its parts

public void Deconstruct(out string? name, out DateTime dob)
{
     name = Name;
     dob = Born;
}

//can overload with different signatures
public void Deconstruct(out string? name, out DateTime dob, out decimal gpa)
{
     name = Name;
     dob = Born;
     gpa = GradePointAverage
}

Indexer

Uses array[] syntax, when you want to get/set an element in a collection

public Person this[int index]   //note this[] is used to define an indexer signature, 
                                // can be any type but usually int
{
   get
   {
      return Children[index];  //returns the item from the collection
   }
    set
    {
      Children[index] = value;   //sets the item in the collection
    }
}

Now you can get using index syntax
Person child = bob[0]; //indexer gets Child object at position 0
bob[0] = newbabyObject; //indexer set – overwrites the 0 object in collection
bob["Clayton"] = newbabyObject; //can use string too (will need to alter code above)

Operator

When you want to use an operator like + – / etc. on your class

public static bool operator +(Person p1, Person p2)
{
     Marry(p1, p2);                     <---- call a method you've already defined
     return p1.Married && p2.Married;   <---- cannot return void
}

Guard Clause Methods — to check if args are valid

ThrowIfNullOrEmpty
ThrowIfNullOrWhiteSpace
ThrowIfNull
ThrowIfEqual
ThrowIfGreaterThan
ThrowIfGreaterThanOrEqual
ThrowIfLessThan
ThrowIfLessThanOrEqual
ThrowIfNegative
ThrowIfNegativeOrZero
ThrowIfNotEqual
ThrowIfZero
Argument.ThrowIfNullOrWhiteSpace(inputArgName, paramName: nameof(inputArgName));

Documenting Your Methods

Add three slashes above method declaration to add documentation to all callable functions

/// <summary>
/// Pass a 32-bit unsigned integer and it will be converted into its ordinal equivalent.
/// </summary>
/// <param name="number">Number as a cardinal value e.g. 1, 2, 3, and so on.</param>
/// <returns>Number as an ordinal value e.g. 1st, 2nd, 3rd, and so on.</returns>
static string CardinalToOrdinal(uint number)
...

Partial Methods

A way to delcare a placeholder function within a partial class and allow other developers to implement it how they want in the merged partial class.

within first partial class file:
partial void placeholderFunction(); //notice no implementation
first partial class can call it but
it will be ignored until an implementation is merged into it

within second partial class file:
partial void placeholderFunction()
{ //something happens here }

Both must be inside partial class. Both must return void. Both must say partial. No out params.

Delegate holds the signature of a method
Used to pass a method as an argument to other methods
Subscriber: OK when X happens, here’s what I want you to do
To exchange messages between objects
To handle events in a flexible way
Delegate acts as the go-between

Predefined Delegates

MS-defined delegate types that you should use
public delegate void EventHandler(object? sender, EventArgs e);
OR
public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);

where
delegate — keyword to declare the delegate
EventHandler — the name of the delegate type (MS defined this)
sender — the object that triggers the event and will be notified when finished
EventArgs — an array of arguments for whatever method will be called
TEventArgs — for multiple types of args

Declare event (a method) in your class using predefined delegate:
public event EventHandler? OnPokeEvent; //starts as null

Link the method in your class that will trigger the event
public void Poke
{
//triggers OnPoke event
OnPokeEvent(this, EventArgs.Empty);
}

Write a handler method in a Program.EventHandler partial file:
public void HandlePoke (object? sender, EventArgs e)
{
WriteLine("Stop it!"); //what actually happens
}

In Object instance subscribe the handler to the event
harry.OnPokeEvent += HandlePoke;

Now when harry object runs Poke() he will react to it. Other objects can also subscribe to it and pass the same handler, or a different one.

using static System.Console; — either at top of code file
or in project directive file like this:

<ItemGroup Label="make console static">
  <Using Include="System.Console" static="true" />
</ItemGroup>

Write("something"); — writes without carriage return
WriteLine("something"); — adds carriage return

Detecting Key Presses

Write("Press key: "); — user prompt
ConsoleKeyInfo key = ReadKey(); — waits for user input
key.Key — the key’s id to computer
key.KeyChar — the translation of key pressed (what shows on screen)
key.Modifiers — Shift, Control, Alt.

Run Arguments

MyProgram arg1, arg2, arg3

Arguments are an array of strings, always passed at top level program, though hidden
Test in Project > Arguments Properties > Debug > General > Open Debug Launch Profiles UI

Helpful methods in System class to detect the OS:
OperatingSystem.IsWindowsVersionAtLeast(major: 10))
OperatingSystem.IsWindows()
OperatingSystem.IsIOSVersionAtLeast(major: 14, minor: 5))
OperatingSystem.IsBrowser()

Compile Directives

Using predefined constants to only compile certain code for specific OS:

#if NET7_0_ANDROID
  //statements that will only work for Android
#elif NET7_0_IOS
  //statements that will only work for IOS
#else
  //statements For everything else
#endif

See list of OS constants here https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/preprocessor-directives

Avoid over-catching exceptions
catch (FormatException) //catch specific
catch (Exception ex) //catch all else – declare System.Exception variable
ex.GetType() //eg System.FormatException
ex.Message //The default message of the exception
catch (FormatException when (amount.Contains(‘$’)) //use a filter

//to check for overflow exceptions
try
{
  checked   //avoids silent overflow
  {
    int x = int.MaxValue;
    x++;
  }
}
catch (OverflowException)
{
    WriteLine("Caught!");
}

Throwing

throw; //rethrows keeping original call stack
throw ex; //rethrow at the current level in call stack, will lose potential helpful call stack info
throw new InvalidOperationException(
message: “Calculation had invalid values. See inner exception for why.”,
innerException: ex); //to add helpful info

Defining Custom Exceptions

Define your own exception class inheriting from Exception class and define your own constructor using same signatures as base

public class PersonException : Exception
{
    public PersonException() : base() {} 
    public PersonException(string message) : base(message) {}
    public PersonException(string message, Exception innerException)
      : base(message, innerException) {}
}

Reserved words
base — the inherited class reference
const — for hardcoded, never-changing fields, call with class name not obj instance
delegate — labels code as type delegate (intermediary function)
event — a special type of delegate that allows multiple assignment
init — used in place of set to make a property immutable after it’s been initialized
object => stand-in for System.Object
operator — used to define an operator method in a class
params — used to pass a variable number of parameters to a method as an array
partial — able to be merged with other so-named code
readonly — for fields, set at initialization then immutable
record — special type of immutable class
sealed — with class => prevent inheritance, with overridden method => prevent further overriding
static — for object members, call with class name not object instance ex: Math.Pi
this — current instance of an object (not used with static members)
value — implicitly passed into setters, what is being assigned
void — method doesn’t return a value
with — altering a record class after instantiation (makes a copy)