Basic Types and Variables

public struct PointStruct { public int X; public int Y; }
public class  PointClass  { public int X; public int Y; }

public static class CopySemantics
{
    public static void Demo()
    {
        var vs = new PointStruct { X = 1, Y = 1 };
        var vsCopy = vs;                 // copies the two ints
        vsCopy.X = 99;
        Console.WriteLine(vs.X);         // 1  -- the original is untouched

        var rc = new PointClass { X = 1, Y = 1 };
        var rcAlias = rc;                // copies the reference only
        rcAlias.X = 99;
        Console.WriteLine(rc.X);         // 99 -- same object
    }
}

Console.WriteLine(0.1 + 0.2 == 0.3);        // False -- binary floating point
Console.WriteLine(0.1m + 0.2m == 0.3m);     // True  -- base-10 decimal

Console.WriteLine(double.PositiveInfinity); // ∞ -- IEEE 754 has infinities and NaN
Console.WriteLine(double.NaN == double.NaN);        // False! use double.IsNaN
Console.WriteLine(double.IsNaN(double.NaN));        // True

var count = 42;                        // int
var name = "Ada";                      // string
var items = new List<string>();        // List<string>
var pairs = new Dictionary<string, List<int>>();   // the case var was designed for

// var x;            // error CS0818: implicitly-typed variables must be initialized
// var y = null;     // error CS0815: cannot assign <null> to an implicitly-typed variable
object? z = null;    // write the type instead
Console.WriteLine($"{count} {name} {items.Count} {pairs.Count} {z is null}");

public sealed class Configuration
{
    // const: compile-time constant, implicitly static, baked into callers' IL.
    public const int MaxRetries = 3;
    public const string Scheme = "https";

    // readonly: assignable only in the declaration or a constructor; a run-time value.
    public readonly DateTime CreatedAt;
    public static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(30);

    public Configuration() => CreatedAt = DateTime.UtcNow;   // legal: a constructor
}

int i = default;                       // 0
bool b = default;                      // false
string? s = default;                   // null
DateTime dt = default;                 // 0001-01-01T00:00:00
Guid g = default;                      // 00000000-0000-0000-0000-000000000000

T Fallback<T>(T? value) where T : struct => value ?? default;   // target-typed `default`
Console.WriteLine($"{i} {b} {s is null} {dt:O} {g} {Fallback<int>(null)}");

int small = 42;
long wide = small;              // implicit widening
double asDouble = small;        // implicit int -> double

double pi = 3.99;
int truncated = (int)pi;        // explicit -- truncates toward zero, giving 3
byte tiny = unchecked((byte)300); // explicit -- wraps to 44

Console.WriteLine($"{wide} {asDouble} {truncated} {tiny}");

int max = int.MaxValue;

int wrapped = unchecked(max + 1);      // -2147483648, the default behaviour
Console.WriteLine(wrapped);

try
{
    int boom = checked(max + 1);
    Console.WriteLine(boom);
}
catch (OverflowException)
{
    Console.WriteLine("overflow detected");
}

// Blocks work too, and `checked` composes with the checked operators of C# 11.
checked
{
    int a = 1000, b = 1000;
    long safe = (long)a * b;           // cast first -- the multiply is then in 64 bits
    Console.WriteLine(safe);
}

// Parse: throws on failure.
int a = int.Parse("42");

// TryParse: returns false instead -- the right choice for untrusted input.
if (int.TryParse("not a number", out int b))
{
    Console.WriteLine(b);
}
else
{
    Console.WriteLine("could not parse");
}

// Culture matters. Always be explicit for machine-readable data.
double invariant = double.Parse("3.14", CultureInfo.InvariantCulture);

// Convert handles nulls and does rounding rather than truncation.
Console.WriteLine(Convert.ToInt32(3.5));    // 4 -- banker's rounding, unlike (int)3.5
Console.WriteLine(Convert.ToInt32(2.5));    // 2 -- ties go to even
Console.WriteLine($"{a} {invariant}");

int value = 42;
object boxed = value;            // boxing: heap allocation + copy
int unboxed = (int)boxed;        // unboxing: type check + copy

Console.WriteLine(unboxed);      // 42

// The copy is why this surprises people:
var list = new List<object> { value };
value = 99;
Console.WriteLine(list[0]);      // 42 -- the box holds the old copy

// An invalid unbox throws rather than converting.
try { _ = (long)boxed; } catch (InvalidCastException) { Console.WriteLine("boxed int is not a long"); }

Type t = typeof(int);
Console.WriteLine(t.FullName);            // System.Int32
Console.WriteLine(typeof(List<>).Name);   // List`1 -- an open generic type

Console.WriteLine(sizeof(int));           // 4
Console.WriteLine(sizeof(decimal));       // 16

object o = 42;
Console.WriteLine(o.GetType() == typeof(int));   // True -- GetType() is the run-time type