C# Interview Questions and Answers

Value types store their data directly and are copied on assignment. Reference types store a reference to heap data, and copying copies the reference.

• Value types: numeric types, bool, char, enum, struct and tuples. Usually on the stack or inline in a containing object.
• Reference types: class, interface, delegate, string, arrays and records (unless declared record struct).

struct Point { public int X, Y; }
class Shape { public int X, Y; }

var p1 = new Point { X = 1 };
var p2 = p1;       // independent copy
p2.X = 99;         // p1.X stays 1

var s1 = new Shape { X = 1 };
var s2 = s1;       // same object
s2.X = 99;         // s1.X is now 99

Boxing wraps a value type in an object and is a common performance pitfall in tight loops. string is a reference type but behaves like a value because it is immutable. Prefer structs for small, short-lived, immutable data and classes for objects with identity.

string is immutable: every operation such as concatenation or Replace allocates a new string. StringBuilder is a mutable buffer backed by a resizable array, so appends modify the buffer in place.

string s = "";
for (int i = 0; i < 10000; i++) s += i;   // O(n^2), many allocations

var sb = new StringBuilder();
for (int i = 0; i < 10000; i++) sb.Append(i);
string result = sb.ToString();            // O(n)

Use string for a fixed number of concatenations; the compiler and string.Concat handle those efficiently. Use StringBuilder inside loops and when building large text from many pieces. StringBuilder is not thread-safe.

For joining collections, string.Join is usually the clearest option. Interpolation with $"..." compiles to string.Format or concatenation and is fine for small cases. Immutability of string is also why it is safe to share across threads.

A field is a variable declared directly in a class. A property is a member with get and set accessors that looks like a field to callers but runs code, enabling validation, computed values, lazy loading and encapsulation.

public class Person {
    private int _age;                  // field
    public string Name { get; set; }   // auto-property

    public int Age {                    // full property
        get => _age;
        set => _age = value >= 0
            ? value
            : throw new ArgumentOutOfRangeException();
    }

    public string Display => $"{Name} ({Age})"; // get-only
}

Auto-properties let the compiler generate the backing field. Prefer properties in public APIs so you can change the implementation later without breaking binary compatibility or callers.

init accessors allow assignment only during object initialisation, supporting immutable objects. Expression-bodied get-only properties are concise for computed values. Properties can also have different access levels, such as public string Id { get; private set; }.