C# fundamentals & OOP

Encapsulation hides internal state and exposes controlled behavior. Abstraction exposes what something does, not how. Inheritance lets a class reuse and extend a base class. Polymorphism lets the same call behave differently depending on the runtime type, through virtual methods or interfaces. In practice I prefer composition and interfaces over deep inheritance hierarchies.

A class is a reference type: assignment copies a reference, so two variables can refer to the same object. A struct is a value type: assignment copies its value, including any reference fields, rather than deep-copying their objects. Storage depends on context and runtime optimization, not a universal stack-versus-heap rule. A class can inherit one base class; a struct cannot inherit another struct or class, but can implement interfaces. I consider structs for small, preferably immutable values and measure copying and boxing costs rather than treating a size guideline as a language limit.

A record generates value equality, a useful ToString, and a shallow non-destructive copy with with. Positional record classes have init-only properties; positional record structs are mutable unless declared readonly. Records can also contain mutable members, so they aren't automatically immutable. I use records for DTOs, messages and value objects, and classes for entities with identity and behavior. See the official record reference.

An interface defines a capability; a class can implement many, and an interface cannot declare instance fields. An abstract class is a partial base type: it can have instance state, constructors and shared implementation, but a class inherits only one. I default to interfaces for flexibility and testability, and use an abstract class when several types share code, like a base report that defines the export flow.

public is visible everywhere; private only inside the type, the default for members; protected inside the type and derived types; internal within the same assembly, the default for top-level types; protected internal means same assembly or any derived type; private protected means derived types in the same assembly; and file, since C# 11, limits a type to its source file. In modular code, internal is how a module hides its implementation.

A const is a compile-time constant baked into every caller, so changing it in a library requires recompiling consumers, and it supports constant-compatible types such as numbers, booleans, characters, strings and enums. A readonly field is assigned at runtime in its declaration or constructor and never changes afterwards; each instance can have its own value. static readonly is one runtime value per type, which I use for things like TimeSpans or shared instances.

A static member belongs to the type rather than an instance, so there's a single copy. A static class can't be instantiated or inherited and contains only static members, like Math or a class of extension methods. I avoid mutable static state because it's shared across threads and hard to test; shared services are registered as singletons in DI instead.

All three pass by reference. ref requires the variable to be initialized and lets the method read and modify it. out doesn't need initialization, but the method must assign it, which is the TryParse pattern. in passes by reference as read-only, mainly to avoid copying large structs. In modern code I often return a tuple or a result type instead of using out parameters.

For money I always use decimal. It's a base-10 type with 28 to 29 significant digits, so values like 0.1 are exact. float and double are binary floating point: fast and with a huge range, but 0.1 + 0.2 isn't exactly 0.3, which is unacceptable for currency. decimal is slower and uses 16 bytes, so scientific and graphics code uses double. The literal suffixes are m for decimal and f for float; an unsuffixed literal like 10.5 is a double.

By default Math.Round uses banker's rounding: midpoints go to the nearest even number, so 2.5 becomes 2 and 3.5 becomes 4, which avoids systematic bias when summing many values. If the business expects 2.5 to become 3, I pass MidpointRounding.AwayFromZero explicitly, and keep all rounding in one place such as a Money type.

Boxing wraps a value type in a heap object when it's treated as object or as an interface; unboxing copies it back out. Each box is an allocation, so in hot loops or non-generic collections like ArrayList it adds GC pressure. Generics avoid it because List of int stores the ints directly.

Generics let me write one type-safe implementation for many types, without casts or boxing, like List of T or a generic repository. Constraints with the where keyword restrict T to a class or struct, types with a parameterless constructor, non-nullable types, or types implementing an interface, which lets me call members such as CompareTo on T safely.

Covariance, marked out T, lets a generic interface or delegate that only produces T be treated as producing a base type: an IEnumerable of string is an IEnumerable of object. Contravariance, marked in T, lets something that only consumes T accept a more derived type: an Action of object works as an Action of string. It applies only to interfaces and delegates, and only where it's type-safe, which is why List of T is invariant.

They're built-in generic delegate types. Func takes up to sixteen inputs and returns a value, with the last type parameter as the return type. Action takes inputs and returns nothing. Predicate of T takes a T and returns a bool, the same as Func of T and bool. Lambdas are usually assigned to them, and LINQ methods accept them.

An event is a delegate with restricted access: outside the declaring class you can only subscribe and unsubscribe, not invoke it or replace the subscriber list. That enforces the observer pattern, where only the publisher raises the event. A common pitfall is forgetting to unsubscribe from a long-lived publisher, which keeps subscribers alive and leaks memory.

An extension method is a static method in a static class whose first parameter is marked with "this", so it can be called as if it were an instance method of that type, without modifying or inheriting from it. LINQ is built from extension methods. C# 14 adds extension members: an extension block can also declare extension properties and static members.

yield return turns a method into an iterator: the compiler generates a state machine that produces one value at a time, only when the caller asks for the next element. Nothing runs until enumeration starts, so in a pipeline like Take(3) only three values are computed. It's ideal for streaming large or infinite sequences without building a list. yield break ends the sequence.

throw; rethrows the current exception and preserves its original stack trace. throw ex; resets the stack trace to the current line, so you lose where the error actually occurred. I use throw; to rethrow, or wrap it in a new exception with the original as the inner exception when I need to add context.

I catch only specific exceptions I can actually handle, use filters when a condition matters, and release resources with using or finally. I never swallow exceptions silently, and I don't use them for expected outcomes like not-found or validation failures; those return results. Rethrows use throw;. In an API, a global exception handler logs details and returns a ProblemDetails response without leaking internals.

For reference types, == compares references by default unless the type overloads it, as string does. Equals can be overridden for value equality. If you override Equals you must override GetHashCode consistently, because Dictionary and HashSet find the bucket by hash first; equal objects with different hash codes would never be found. Records generate both correctly.

string is immutable, so each concatenation allocates a new string; in a loop that means repeated copying. StringBuilder keeps a resizable buffer and appends in place, so I use it, or string.Join, when building text in a loop. For a few concatenations, interpolation is fine.

using guarantees Dispose is called on an IDisposable at the end of the block, even if an exception occurs; the compiler turns it into try/finally. The using declaration form disposes at the end of the enclosing scope, and await using calls DisposeAsync. I use it for connections, streams, files and anything holding unmanaged resources.

int? is a nullable value type, short for Nullable of int. Nullable reference types, enabled by default in new projects, make the compiler track nullability: string should never be null and string? may be, and you get warnings when dereferencing something that might be null. I treat those warnings as errors and handle nulls with ?., ?? and ??=, plus C# 14's null-conditional assignment.

Reflection lets code inspect types and invoke members at runtime; DI containers, serializers, ORMs and test frameworks rely on it. It's slower, loses compile-time safety and conflicts with trimming and Native AOT. I use it mainly at startup, for example to scan an assembly and register handlers, cache the results, and prefer source generators on hot paths.

An expression tree represents code as a data structure. When a lambda is assigned to an Expression of Func, the compiler builds a tree describing it, which libraries can inspect and translate; that's how EF Core turns a LINQ Where on IQueryable into a SQL WHERE clause. A plain Func is compiled code that can only be executed.

dynamic defers member binding to runtime. It can simplify COM interop or loosely shaped data, but you lose IntelliSense and compile-time checks, errors surface at runtime and calls are slower. In application code I avoid it, using strong types or JsonElement and JsonNode for unknown JSON.

Immutable objects can't change after creation, so they can be shared across threads without locks or race conditions, and they're easier to reason about and test because there are no hidden side effects. In C# I use records, init-only and required properties, readonly fields, and immutable or frozen collections.

Overloading means several methods with the same name but different parameters, resolved at compile time. Overriding means a derived class replaces a virtual or abstract method, resolved at runtime from the actual object. Hiding with the new keyword is different: a call through a base-typed variable still runs the base method, which usually signals a bug.

virtual means a derived class may override the member; abstract means it must, and the member has no body; sealed prevents further inheritance or overriding. I seal classes by default unless they're designed for inheritance: it documents intent and lets the JIT devirtualize calls.

An init accessor allows assignment during initialization, while required makes the compiler require callers to assign the member. Neither guarantees a valid runtime value: a required property may be null or empty, and an init-only list can still be mutated. These are construction aids, not deep immutability. See the official required reference.