CLR & Runtime

The GC (garbage collector) automatically reclaims managed-heap objects that are no longer reachable from any root (locals, statics, GC handles). It runs on its own schedule, so freeing is non-deterministic: you allocate objects but never free them manually, and you cannot predict exactly when an unreachable object's memory is reclaimed. This eliminates dangling-pointer and double-free bugs.

An assembly is the fundamental unit of deployment and versioning in .NET, packaged as a .dll or .exe. It contains compiled IL code, a manifest (assembly identity, version, and referenced assemblies), type metadata describing every type and member, and optional embedded resources. The CLR loads and version-checks code at assembly granularity.

Managed code runs under the CLR (Common Language Runtime), which provides garbage collection, type safety, exception handling, and JIT compilation. Unmanaged code (e.g. C/C++) compiles straight to native machine code and runs directly on the OS, managing its own memory and lifetime without those runtime services.

The C# compiler emits IL (Intermediate Language) — a CPU-independent bytecode — into the assembly along with metadata, not native code. At runtime the JIT (Just-In-Time) compiler translates each method's IL into native machine code lazily, on its first call, then caches the result so later calls run native. This lets one assembly target any CPU and optimize for the actual host.

LINQ (Language Integrated Query) is a unified set of query operators and a query syntax that work over any sequence implementing IEnumerable or IQueryable — collections, databases, XML. Operators like Where, Select, and OrderBy compose into a pipeline. Most queries execute lazily (deferred): nothing runs until you enumerate the result, and each item flows through the pipeline on demand.

Reflection inspects type metadata at runtime via System.Reflection and the Type class: you can enumerate types, members, attributes, and signatures of any loaded assembly. Beyond inspection, it can act — instantiating types, reading and setting fields and properties, and invoking methods dynamically by name. This powers serializers, dependency injection, ORMs, and test frameworks that work over types unknown at compile time.

Serialization converts an in-memory object graph into a portable form — JSON, XML, or binary — that can be stored or transmitted. Deserialization is the reverse: it reconstructs the object graph from that form. It is used to persist state to disk or a database, send objects over a network or message queue, and cache data, so the same object can cross process, machine, or time boundaries.

An expression tree (Expression<Func<...>>) represents code as an inspectable data structure — a tree of nodes for operations, parameters, and constants — rather than executable IL. Because it is data, a LINQ provider can walk and analyze it at runtime: providers like Entity Framework translate the tree into another language such as SQL, instead of running the lambda in memory. You can also compile a tree to a delegate on demand.

A finalizer (~Type()) runs non-deterministically on a dedicated GC thread just before an object is reclaimed, with no guarantee of when or in what order. Because finalizable objects survive an extra collection cycle (placed on the finalization queue, then collected later), they delay reclamation and add GC pressure. Prefer IDisposable/Dispose for deterministic cleanup, and keep a finalizer only as a safety net for unmanaged resources.

The GC partitions the managed heap into generations 0, 1, and 2. New objects start in gen 0; objects that survive a collection get promoted to the next, higher generation. This exploits the generational hypothesis — most objects die young — so the GC can collect gen 0 frequently and cheaply, touching only recently allocated memory, while expensive full gen-2 collections that scan everything run far less often.

A strong name gives an assembly a globally unique identity composed of its simple name, version, culture, and public key, plus a digital signature over the assembly. The signature lets the CLR detect tampering and bind to an exact version, and the unique identity allows the assembly to be installed into the GAC (Global Assembly Cache) for machine-wide sharing without name collisions.