Glossary

.NET and C# glossary

The vocabulary of C# and .NET, defined in a sentence or two of plain English. Each term links to the lesson that explains it properly. If a word in a lesson, a job description or a pull request is unfamiliar, this is the page to open.

A

Abstract class
A class that cannot be instantiated directly and exists to be inherited from; it may contain both implemented members and abstract members that derived classes must implement. Lesson →
Access modifier
A keyword (public, private, protected, internal, file) that controls which code can see a type or member. Lesson →
Assembly
The unit of deployment in .NET: a compiled .dll or .exe containing IL code and metadata. A project produces one assembly. Lesson →
ASP.NET Core
The cross-platform framework in .NET for building web applications and APIs, built around a middleware pipeline and dependency injection. Lesson →
Async / await
Language keywords that let a method pause at an await while an operation completes, freeing the thread, and resume afterwards. Used for I/O-bound work. Lesson →
Attribute
Metadata attached to code in square brackets, such as [Obsolete] or [HttpGet], that tools, frameworks and reflection can read at runtime. Lesson →
Authentication / authorization
Authentication establishes who a caller is; authorization decides what they may do. Two separate steps, in that order. Lesson →

B

BCL (Base Class Library)
The standard library that ships with .NET: collections, file I/O, networking, text, dates, JSON and thousands of other types you use without installing anything. Lesson →
Boxing
Wrapping a value type in a heap object so it can be treated as object or an interface. Each box is an allocation; unboxing is the cast back. Lesson →

C

CancellationToken
A value passed through async calls so that long-running work can be asked to stop cooperatively. Lesson →
Circuit breaker
A resilience pattern that stops calling a failing dependency for a period after repeated failures, so it can recover instead of being hammered. Lesson →
Clean architecture
A layering style where dependencies point inward toward the domain, and infrastructure (database, web, messaging) sits on the outside implementing interfaces the inner layers define. Lesson →
Closed hierarchy
A base class marked with the C# 15 closed modifier, so its direct subclasses must live in the same assembly. Because the list of subclasses is fixed, a switch that handles each one is exhaustive. Lesson →
Closure
A lambda or local function that captures variables from its enclosing scope and keeps them alive for as long as it exists. Lesson →
CLR (Common Language Runtime)
The engine that runs .NET code: it loads assemblies, JIT-compiles IL to machine code, manages memory with the garbage collector, and enforces type safety. Lesson →
Collection expression
The [1, 2, 3] syntax for creating any collection type, including the spread operator [..a, ..b]. Lesson →
Covariance / contravariance
Rules that let a generic interface of a derived type be used as one of a base type (out T, covariance) or the reverse (in T, contravariance). Lesson →

D

DbContext
The Entity Framework Core class that represents a session with the database: it tracks entities, translates LINQ to SQL and saves changes as a unit of work. Lesson →
Deadlock
Two or more operations each waiting for the other to release something, so none can proceed. In .NET most often caused by blocking on an async result. Lesson →
Deferred execution
The LINQ behaviour where a query does no work until it is enumerated, and runs again every time it is enumerated. Lesson →
Delegate
A type that represents a reference to a method with a particular signature, so methods can be passed around and invoked later. Action and Func are the built-in ones. Lesson →
Dependency injection (DI)
Supplying a class's dependencies from the outside (usually via the constructor) rather than having it create them, so they can be configured and replaced. Built into ASP.NET Core. Lesson →
Dispose / IDisposable
The contract for releasing scarce resources (files, connections, handles) deterministically; using calls Dispose() automatically at the end of a scope. Lesson →
Domain-driven design (DDD)
An approach that models software around the business domain and its language, with entities, value objects, aggregates and bounded contexts. Lesson →

E

Encapsulation
Keeping a type's data private and exposing behaviour through methods and properties, so its invariants cannot be broken from outside. Lesson →
Entity Framework Core (EF Core)
The object-relational mapper in .NET: you work with C# objects and LINQ, and EF Core generates the SQL. Lesson →
Enum
A value type that gives names to a set of integer constants, such as OrderStatus.Shipped. Lesson →
Event
A member that lets a class notify subscribers when something happens, built on delegates with += to subscribe and -= to unsubscribe. Lesson →
Exception
An object thrown to signal an error that the current code cannot handle; caught with try/catch further up the call stack. Lesson →
Expression tree
A representation of code as data (Expression<Func<T,bool>>) that libraries such as EF Core inspect to translate a lambda into SQL. Lesson →
Extension method / extension member
A static method that appears to be an instance method on another type; C# 14 extends this to properties and static members via extension blocks. Lesson →

F

Field
A variable declared directly in a class or struct that holds the object's state. Usually private, with a property in front of it. Lesson →
field keyword
The C# 14 keyword that refers to a property's compiler-generated backing field inside its accessors, so you can add logic without declaring the field yourself. Lesson →
Filter (ASP.NET Core)
Code that runs before or after an action or endpoint — for authorization, validation, exception handling or result shaping — inside the framework's pipeline rather than the raw middleware pipeline. Lesson →

G

Garbage collector (GC)
The part of the runtime that automatically frees memory occupied by objects nothing references any more. Generational: young objects are collected often, old ones rarely. Lesson →
Generics
Types and methods parameterised by other types, such as List<T>, so one implementation works for any element type with full type safety and no boxing. Lesson →
Generic constraint
A where T : ... clause that restricts which types can be used for a type parameter and tells the compiler what members it has. Lesson →

H

Health check
An endpoint that reports whether a service and its dependencies are working, used by orchestrators and load balancers to decide where to send traffic. Lesson →
Heap
The region of memory where objects are allocated and managed by the garbage collector, as opposed to the stack. Lesson →
HttpClient
The class for making HTTP requests. Long-lived and shared (via IHttpClientFactory) rather than created per request, to avoid socket exhaustion. Lesson →

I

Idempotency
The property that performing an operation more than once has the same effect as performing it once, which makes retries safe. Lesson →
IEnumerable<T>
The interface for anything that can be iterated with foreach; the foundation of LINQ. Lesson →
IL (Intermediate Language)
The CPU-independent bytecode that C# compiles to, which the JIT compiler turns into native code at runtime. Lesson →
Immutability
The property of an object that cannot change after construction. Strings and records with init properties are immutable; immutable objects are safe to share across threads. Lesson →
Inheritance
Defining a class as a specialisation of another, gaining its members and the ability to override virtual ones. Lesson →
Interface
A contract listing members a type promises to provide, with no state; a type can implement many. Lesson →
IQueryable<T>
A LINQ sequence whose operators are captured as expression trees and translated by a provider — usually into SQL — rather than run in memory. Lesson →

J

JIT (Just-In-Time) compiler
The runtime component that compiles IL into native machine code the first time a method runs, and recompiles hot methods with more optimisation (tiered compilation). Lesson →
JWT (JSON Web Token)
A signed, self-contained token carrying claims about a user, validated by an API without a database call. Lesson →

L

Lambda expression
An inline anonymous function, x => x * 2, used wherever a delegate or expression tree is expected. Lesson →
LINQ (Language Integrated Query)
A set of query operators (Where, Select, GroupBy, …) and a query syntax that work over any sequence, in memory or in a database. Lesson →
Large object heap (LOH)
The part of the managed heap for objects of 85,000 bytes or more, collected only with generation 2 and not compacted by default. Lesson →
Lock
A statement that ensures only one thread at a time runs a block of code, protecting shared state from races. Lesson →
LTS / STS release
The two .NET support tracks. Long Term Support releases (even numbers, such as .NET 10) and Standard Term Support releases (odd numbers, such as .NET 11) are equally production-ready; LTS is supported for three years and STS for two. Lesson →

M

Middleware
A component in the ASP.NET Core request pipeline that can inspect or modify the request and response and decide whether to pass the request on. Lesson →
Migration (EF Core)
A generated class that describes a change to the database schema so it can be applied, versioned and rolled back alongside the code. Lesson →
Minimal API
The ASP.NET Core style of defining HTTP endpoints as lambdas mapped to routes, with less ceremony than controllers. Lesson →
Mocking
Replacing a dependency with a stand-in in a test so the code under test can be exercised in isolation and its interactions verified. Lesson →

N

N+1 problem
Loading a list with one query and then running one additional query per item, turning a single round trip into hundreds. Lesson →
Nullable reference types
The compiler feature that distinguishes string (never null) from string? (may be null) and warns about unsafe dereferences. Lesson →
NuGet
The package manager for .NET; libraries are published as packages and referenced in the project file. Lesson →

O

Observability
Being able to understand what a running system is doing from the outside, through logs, metrics and distributed traces — in .NET, typically via OpenTelemetry. Lesson →
Options pattern
Binding a section of configuration to a strongly typed class and injecting it as IOptions<T>. Lesson →
Outbox pattern
Writing an outgoing message to a table in the same transaction as a business change, and publishing it separately, so the two can never disagree. Lesson →
Overloading / overriding
Overloading is several methods with the same name and different parameters; overriding is a derived class replacing a base class's virtual method. Lesson →

P

Pattern matching
Language features (is patterns, switch expressions, property and list patterns) for testing a value's shape and extracting from it in one step. Lesson →
Polymorphism
Calling a method through a base type and getting the derived type's implementation, so one piece of code can work with many kinds of object. Lesson →
Primary constructor
Constructor parameters declared directly on the class or struct declaration, class Order(ICatalog catalog), available throughout the body. Lesson →
Property
A member that looks like a field but is backed by get/set accessors, so reads and writes can run code. Lesson →

R

Race condition
A bug where the outcome depends on the timing of threads accessing shared state, producing results that are wrong only sometimes. Lesson →
Record
A type with compiler-generated value equality, ToString, deconstruction and with expressions, for data defined by its contents. Lesson →
Reflection
Inspecting and invoking types, members and attributes at runtime by name, used by serialisers, DI containers and test frameworks. Lesson →
Repository pattern
An abstraction that exposes domain-oriented data access methods and hides the persistence mechanism. Useful in some designs; redundant on top of DbContext in others. Lesson →
Resilience
The ability of a service to keep working when dependencies fail, using retries, timeouts, circuit breakers and fallbacks. Lesson →
Runtime async
A .NET 11 preview feature in which the runtime, not compiler-generated state machines, suspends and resumes async methods, giving shorter stack traces and less overhead. Enabled per project with <Features>runtime-async=on</Features>. Lesson →

S

Scoped / transient / singleton
The three DI lifetimes: one instance per request, a new instance every time, and one instance for the whole application. Lesson →
Sealed
A modifier that prevents a class from being inherited or an override from being overridden further. Lesson →
SOLID
Five design principles — single responsibility, open/closed, Liskov substitution, interface segregation, dependency inversion — for code that is easy to change. Lesson →
Source generator
A compiler plug-in that inspects your code at build time and emits additional C# source, used for serialisation, logging and more without reflection. Lesson →
Span<T>
A stack-only view over contiguous memory that lets you slice and process data with no allocation. Lesson →
Stack
The per-thread region of memory that holds method frames and local variables, allocated and freed automatically as methods are called and return. Lesson →
Static member
A member that belongs to the type itself rather than to any instance, shared by all code using the type. Lesson →
Struct
A user-defined value type: copied by value, usually small and immutable, with no inheritance. Lesson →
Synchronization context
The mechanism that decides which thread an async continuation resumes on; present in UI frameworks, absent in ASP.NET Core. Lesson →

T

Target framework (TFM)
The .NET version a project is built for, set in the project file, such as <TargetFramework>net11.0</TargetFramework>. It also decides the default C# version: net11.0 means C# 15. Lesson →
Task / Task<T>
The type representing an asynchronous operation that will complete in the future, possibly with a result. What async methods return and await consumes. Lesson →
Testcontainers
A library that starts real dependencies (SQL Server, Postgres, Redis) in Docker containers for integration tests, and tears them down afterwards. Lesson →
Thread pool
The runtime's managed set of worker threads that run tasks and async continuations, sized automatically. Lesson →
Tracking (EF Core)
EF Core's default of remembering every loaded entity so changes can be detected and saved; AsNoTracking() turns it off for read-only queries. Lesson →
Transaction
A group of database operations that either all succeed or all roll back, so multi-step changes can never half-happen. Lesson →
Tuple
A lightweight grouping of values, (int Count, string Name), returned or deconstructed without declaring a type. Lesson →

U

Union type
A C# 15 type whose value is exactly one of a fixed list of case types, declared as public union Pet(Cat, Dog, Bird);. A switch that handles every case type needs no default arm. Lesson →
Unit of work
A pattern that groups related changes and commits them together; DbContext.SaveChanges is one. Lesson →
Unit test
An automated test of one piece of logic in isolation, fast and deterministic, with external dependencies replaced by doubles. Lesson →

V

Value type / reference type
A value type holds its data directly and is copied on assignment; a reference type holds a reference to a heap object, and copying it shares the object. The most important distinction in C#. Lesson →
ValueTask
A struct alternative to Task for methods that usually complete synchronously, avoiding an allocation on the fast path. May be awaited only once. Lesson →
Virtual / override
virtual marks a member that derived classes may replace; override replaces it, and the replacement is used even through a base-type reference. Lesson →

Y

yield
The keyword that turns a method into a lazy iterator, producing one element at a time as the consumer asks for it. Lesson →

Missing a term you expected? Tell us and we will add it. For the words in action, the C# cheat sheet shows the syntax side by side.