C#

Every type is either a value type or a reference type. This one distinction explains most C# behaviour questions.

• Value types hold the data itself and are copied on assignment. Examples: int, long, double, decimal, bool, char, enum, struct, DateTime.
• Reference types hold a reference to data on the heap; assigning copies the reference, so both variables point to the same object. Examples: class, string, arrays, object, interfaces, delegates.

int a = 1; int b = a; b = 9;            // a stays 1 (value copied)

int[] x = { 1 }; int[] y = x; y[0] = 9; // x[0] is now 9 (same array)

• var — the compiler infers the type; the variable is still strongly typed.
• const — compile-time constant. readonly — set once, in the constructor.
• Nullable: value types are non-null by default; int? allows null. Use ?., ??, ??= for null-safety (name ??= "anon";).
• Boxing = wrapping a value type in a heap object; unboxing reverses it. It allocates, so avoid it in hot loops.

Access modifiers — who can see a member:

• public — anywhere.
• private — only inside the same class (the default for class members).
• protected — the class and its subclasses.
• internal — anywhere in the same project/assembly.
• protected internal / private protected — combinations, rarely needed.

Other modifiers you'll be asked about:

• static — belongs to the type, not an instance.
• abstract — no body; must be overridden; the class can't be instantiated.
• virtual — has a default body but can be overridden; override replaces it; sealed stops further overriding.
• const / readonly — immutability (compile-time vs set-once).
• new — hides an inherited member.

The four pillars, briefly:

• Encapsulation — keep fields private, expose them through public properties (get/set).
• Inheritance — a class extends one base class (: Base).
• Polymorphism — virtual/override so the right method runs for the actual object type.
• Abstraction — expose what, hide how, via abstract classes and interfaces.

public abstract class Shape {              // shared base
    public string Name { get; init; }
    public abstract double Area();         // no body -> subclass must override
}
public interface IDrawable {               // capability
    void Draw();
}

// extend ONE class, implement MANY interfaces
public sealed class Circle : Shape, IDrawable {
    public double R { get; init; }
    public override double Area() => Math.PI * R * R;
    public void Draw() => Console.WriteLine($"O r={R}");
}

public record User(int Id, string Name);

var u1 = new User(1, "Ada");
var u2 = u1 with { Name = "Grace" };   // copy with one change
u1 == new User(1, "Ada");              // true — value equality

string is a reference type but immutable — once created it never changes. Every "modification" (+, Replace, ToUpper) returns a new string and leaves the original untouched.

string s = "hello";
s.ToUpper();        // returns "HELLO" but s is STILL "hello"
s = s.ToUpper();    // reassign to keep the result

Why make it immutable?

• Thread-safe by nature — no one can change a shared string underneath you.
• Safe as a dictionary / hash key — its hash never changes.
• Enables interning: identical string literals are cached and shared in a pool.

The cost: concatenating in a loop creates a new object each pass (O(n²) garbage). Use StringBuilder when you build a string in many steps.

var sb = new StringBuilder();
foreach (var row in rows) sb.Append(row).Append('\n');
string report = sb.ToString();   // one final allocation

"ab" == "a" + "b";               // true — == on strings compares VALUE

The single most likely C# deep-dive for a Playwright/SDET role, since the API is async throughout.

• async marks a method returning Task/Task<T>/ValueTask; await suspends without blocking the calling thread.
• It frees the thread while I/O completes — concurrency without extra threads.
• Return Task, not void (except event handlers); async void can't be awaited and swallows exceptions.
• Avoid .Result/.Wait() — they can deadlock; await all the way up.
• Task.WhenAll runs work concurrently; CancellationToken cooperatively cancels.

public async Task<User> GetUserAsync(int id, CancellationToken ct = default)
{
    var resp = await _client.GetAsync($"/users/{id}", ct);
    resp.EnsureSuccessStatusCode();
    return await resp.Content.ReadFromJsonAsync<User>(cancellationToken: ct);
}

// run several requests concurrently, then await all
var users = await Task.WhenAll(ids.Select(id => GetUserAsync(id)));

Declarative querying over any IEnumerable<T>. Method (fluent) syntax is most common in test code:

var adults = people
    .Where(p => p.Age >= 18)
    .OrderByDescending(p => p.Age)
    .Select(p => p.Name)
    .ToList();

// grouping & aggregation
var byDept = people
    .GroupBy(p => p.Dept)
    .Select(g => new { Dept = g.Key, Count = g.Count(), AvgAge = g.Average(p => p.Age) });

bool anyMinor = people.Any(p => p.Age < 18);
var lookup    = people.ToDictionary(p => p.Id);

• Deferred execution — the query runs when enumerated (ToList, foreach, Count), not when defined; the source can change in between.
• Key operators: Where, Select, SelectMany, First/FirstOrDefault, Single, Any/All, GroupBy, OrderBy, Aggregate.
• FirstOrDefault/SingleOrDefault return default instead of throwing when empty — handy in assertions.

Delegates are type-safe function pointers. The built-ins cover most needs: Func<...,TResult> (returns a value), Action<...> (void), Predicate<T> (returns bool). Lambdas (x => x * 2) are inline delegates and the backbone of LINQ.

Func<int, int> square = x => x * x;
Action<string> log = msg => Console.WriteLine(msg);
Func<User, bool> isAdult = u => u.Age >= 18;

square(5);                 // 25
people.Where(isAdult);     // delegates compose with LINQ

Events are a publish/subscribe wrapper over delegates (event EventHandler Clicked;). Generics give type safety and reuse with constraints (where T : class, new()).

public static T[] Repeat<T>(T value, int n) where T : struct {
    var arr = new T[n];
    Array.Fill(arr, value);
    return arr;
}

string Classify(object o) => o switch {
    int n when n < 0   => "negative",
    int                => "non-negative int",
    string { Length: 0 } => "empty string",
    null               => "null",
    _                  => "other"
};

Used most in practice: List<T> for ordered items and Dictionary<K,V> for key lookups cover the large majority of test code.

var names = new List<string> { "Ada", "Grace" };
names.Add("Linus");
bool has = names.Contains("Ada");

var ages = new Dictionary<string, int> { ["Ada"] = 36 };
if (ages.TryGetValue("Ada", out var age)) { /* age = 36, no exception */ }

IEnumerable<T> = lazy, forward-only and the base for LINQ. Return the narrowest interface that fits (e.g. IReadOnlyList<T>).

All exceptions derive from System.Exception. Unlike Java, C# has no checked exceptions — nothing forces you to declare or catch them.

• try — the code that might fail.
• catch — handle a specific exception type (catch the narrowest first).
• finally — always runs (cleanup), whether or not an exception was thrown.
• throw; rethrows and keeps the original stack trace; throw ex; resets it — prefer throw;.

try {
    var data = await _client.GetStringAsync(url);
    Process(data);
} catch (HttpRequestException ex) {
    _log.Error(ex, "request failed");
    throw;                       // rethrow, preserve the stack trace
} finally {
    _stopwatch.Stop();           // always runs
}

using / IDisposable gives deterministic cleanup of resources (HTTP clients, browser contexts, files) — Dispose() is called automatically at scope exit, even on exception. await using + IAsyncDisposable handles async cleanup.

await using var context = await browser.NewContextAsync();
var page = await context.NewPageAsync();
// context disposed automatically when the scope ends

• NUnit — [Test], [SetUp]/[OneTimeSetUp], [TestCase]/[TestCaseSource] for data-driven tests, rich Assert.That constraint model.
• xUnit — [Fact]/[Theory], constructor + IDisposable for setup/teardown, parallel by default.
• Playwright for .NET — async API; PageTest/ContextTest base classes wire fixtures and a fresh context per test.
• RestSharp / HttpClient for API tests; Moq for mocking; FluentAssertions for readable asserts.

[TestCase(2, 4)]
[TestCase(3, 9)]
public void Squares(int input, int expected)
    => Assert.That(input * input, Is.EqualTo(expected));

// Moq
var repo = new Mock<IUserRepo>();
repo.Setup(r => r.Find(1)).Returns(new User(1, "Ada"));
Assert.That(new UserService(repo.Object).NameOf(1), Is.EqualTo("Ada"));
repo.Verify(r => r.Find(1), Times.Once);