C# — Engineering
Notes for Modern .NET

$ dotnet new console -o app
$ dotnet run
$ dotnet build -c Release
$ dotnet test

int a = 1; int b = a; b++;   // a stays 1 — value copy

var p1 = new Point(); var p2 = p1;
p2.X = 9;                   // p1.X is 9 too — same object

var list = new List<int>();   // type is List<int>, fixed at compile time
List<int> l2 = new();      // target-typed new (C# 9+)
const int Max = 100;        // compile-time constant
readonly int _id;            // set once, in ctor

string name = "omar";
string msg = $"hi {name}, x{n:D3}";  // interpolation
var sb = new StringBuilder();
foreach (var s in parts) sb.Append(s);  // O(n), not O(n²)

int? len = user?.Name?.Length;        // null if any link is null
string n = name ?? "anonymous";        // null-coalescing
cache ??= new();                       // assign if currently null
var first = list?[0];                  // null-conditional index

string label = code switch
{
  200 => "ok",
  >= 400 and < 500 => "client error",
  _ => "other"
};

void Swap(ref int a, ref int b);   // modify caller's vars
bool TryParse(string s, out int v); // extra return channel
int Hash(in BigStruct s);          // pass by readonly ref
int Square(int x) => x * x;            // expression body

class Account(string owner)
{
  private decimal _balance;
  public string Owner { get; } = owner;
  public void Deposit(decimal n) => _balance += n;
}

public string Name { get; set; }
public string Id { get; init; }        // set only during init
public int Area => Width * Height;        // computed, read-only

readonly struct Money(decimal amount)
{
  public decimal Amount { get; } = amount;
}

public record User(string Id, string Name);

var u1 = new User("1", "Omar");
var u2 = u1 with { Name = "Rupam" };   // non-destructive copy
u1 == new User("1", "Omar");          // true — value equality

interface IRepository<T>
{
  Task<T?> GetAsync(string id);
  Task SaveAsync(T item);
}

class Base { public virtual void F() {} }
class Derived : Base { public override void F() {} }

T Max<T>(T a, T b) where T : IComparable<T>
  => a.CompareTo(b) >= 0 ? a : b;

class Cache<T> where T : class, new() { /* ... */ }

Func<int, int, int> add = (a, b) => a + b;
Action<string> log = Console.WriteLine;

bus.OnJob += Handler;
bus.OnJob -= Handler;   // MUST unsubscribe

int factor = 3;
Func<int,int> f = x => x * factor;  // captures factor → heap closure
Func<int,int> g = static x => x * 3;  // no capture, no alloc

var q = nums.Where(n => n > 2).Select(n => n * n);
// nothing has run yet
var list = q.ToList();   // NOW it executes

(int min, int max) Range(int[] a) => (a.Min(), a.Max());
var (lo, hi) = Range(data);   // deconstruct

string Describe(object o) => o switch
{
  int n when n < 0 => "negative",
  string { Length: > 0 } s => $"text {s}",
  [0, .., 9] => "0…9 list",
  null => "null",
  _ => "other"
};

string  always;     // must not be null — warned if it can be
string? maybe;      // may be null — must check before use
var len = maybe!.Length;  // ! = "trust me" (use rarely)

try { Risky(); }
catch (HttpRequestException e) when (e.StatusCode == 429)
{ Backoff(); }
catch (Exception e)
{ _logger.LogError(e, "failed"); throw; }  // rethrow, keep stack

using var conn = new SqlConnection(cs);   // disposed at scope end
await using var stream = File.OpenRead(p);  // async dispose

async Task<User> LoadAsync(string id)
{
  using var r = await _http.GetAsync($"/u/{id}");
  r.EnsureSuccessStatusCode();
  return await r.Content.ReadFromJsonAsync<User>();
}

ReadOnlySpan<char> s = "2026-05-17";
var year = s[..4];          // slice — no substring allocation
int.Parse(s.Slice(5, 2));   // parse without allocating

[Obsolete("Use V2")] void OldApi() {}

var props = typeof(User).GetProperties();   // reflection