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 →
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 →

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 →

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

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

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.