Glossary
87 key terms from the course, each linked to the lesson that explains it.
A
- ACID
- The guarantees of database transactions — Atomicity (all or nothing), Consistency (constraints hold), Isolation (concurrent transactions don't see each other's unfinished work) and Durability (committed data survives crashes). → Indexes and transactions
- API
- Application Programming Interface — a contract that lets programs talk to each other. A web API exposes a backend's capabilities over HTTP. → Designing REST APIs
- Assembly
- The output of compiling a .NET project (a .dll or .exe) containing IL code, metadata about every type, and a manifest. → How compilation works
- async / await
- C# keywords for asynchronous code. await pauses a method until a Task completes without blocking the thread; the method resumes afterwards. → async and await
- Authentication
- Establishing who a user or client is — with a password, passkey, token or external identity provider. Missing authentication results in 401. → Authentication: sessions, tokens and passwords
B
- Boxing
- Wrapping a value type in a heap-allocated object so it can be treated as object or an interface. Unboxing copies it back out. → The stack, the heap and boxing
C
- Cache-aside
- Caching pattern where the application checks the cache first, loads from the source on a miss, and stores the result in the cache. → Caching
- CancellationToken
- A signal passed to asynchronous work so it can stop cooperatively when the caller no longer needs the result or a timeout expires. → Cancellation and timeouts
- CAP theorem
- During a network partition, a distributed data store must choose between consistency (no stale reads) and availability (always answering). → Microservices, CAP and resilience
- CDN
- Content Delivery Network — servers around the world that cache and serve static files close to users. → Caching
- Channel
- System.Threading.Channels — an async producer/consumer queue for passing data between concurrent operations, optionally bounded for back-pressure. → Thread safety and channels
- Circuit breaker
- Resilience pattern that stops calling a failing dependency for a while after repeated failures, failing fast until it recovers. → Microservices, CAP and resilience
- Claim
- A piece of information about a user (id, name, role, email) carried in a token or cookie and exposed as part of a ClaimsPrincipal. → Authentication and authorization in ASP.NET Core
- Class
- A reference type that bundles data (fields, properties) and behavior (methods). Objects are instances of a class. → Classes and objects
- Closure
- A lambda together with the outer variables it captures. Captured variables are shared, not copied, and live as long as the delegate. → Closures and higher-order functions
- CLR
- Common Language Runtime — the .NET runtime that loads assemblies, JIT-compiles IL, manages memory with the garbage collector and handles exceptions. → What is .NET?
- Connection pool
- A set of open database connections reused across requests, so opening a connection is usually instant. → ADO.NET and Dapper
- Container
- A running instance of an image that packages an app with its runtime and dependencies, so it runs the same everywhere. → Docker for .NET
- CORS
- Cross-Origin Resource Sharing — headers that let a server allow specific other websites' JavaScript to read its responses in the browser. → Web security essentials
- CQRS
- Command Query Responsibility Segregation — separating operations that change state (commands) from those that read it (queries). → Clean Architecture and CQRS
- CSRF
- Cross-Site Request Forgery — tricking a browser into sending an authenticated request to another site. Defended with SameSite cookies and anti-forgery tokens. → Web security essentials
D
- DbContext
- The EF Core class representing a session with the database — exposes DbSets for querying and tracks changes until SaveChanges. → Entity Framework Core basics
- Deferred execution
- LINQ queries describe work that runs only when enumerated (foreach, ToList, Count…), and run again on every enumeration. → Deferred execution and iterators
- Delegate
- A type representing a method signature; a delegate variable can hold a method or lambda. Func and Action are the built-in generic delegates. → Delegates and lambdas
- Dependency injection
- Giving a class the dependencies it needs (usually through its constructor) instead of letting it create them; a container wires them up. → Dependency injection
- DNS
- Domain Name System — translates names like shop.example into IP addresses, with caching controlled by TTLs. → How the web works
- DTO
- Data Transfer Object — a simple object shaped for an API request or response, separate from the domain entities. → Minimal APIs
E
- Encapsulation
- Keeping an object's data private and exposing behavior through methods and properties, so the class controls its own invariants. → Properties and encapsulation
- Entity Framework Core
- .NET's object-relational mapper — maps classes to tables, translates LINQ to SQL, tracks changes and manages migrations. → Entity Framework Core basics
- Enum
- A value type defining a set of named constants, backed by integers. [Flags] enums can combine values. → Enums
- Event
- A class member that lets subscribers attach handlers (+=) that run when the publisher raises the event. → Events
- Eventual consistency
- A model where replicas may briefly return stale data after a write, but converge to the same state over time. → Relational vs NoSQL databases
- Exception
- An object representing an error, thrown to interrupt normal flow and caught with try/catch further up the call stack. → Exceptions
- Extension method
- A static method with this on its first parameter that can be called as if it were an instance method of that type. LINQ is built on them. → Extension methods and tuples
F
- Foreign key
- A column referencing another table's primary key, linking related rows and preventing references to rows that don't exist. → SQL fundamentals
G
- Garbage collector
- The runtime component that frees memory of objects no longer reachable from roots, organized in generations 0, 1 and 2. → The garbage collector
- Generics
- Classes and methods with type parameters (List<T>, Max<T>) that work with any type while staying type-safe. → Generics
- gRPC
- A high-performance RPC framework using Protocol Buffers over HTTP/2, popular for service-to-service communication. → Beyond REST: GraphQL, gRPC and WebSockets
H
- Health check
- An endpoint (e.g. /health) that load balancers and orchestrators call to decide whether an instance is alive and ready for traffic. → Running in production
- HTTP
- The request/response protocol of the web — methods, paths, headers, bodies and status codes. → Anatomy of an HTTP request
I
- Idempotent
- An operation that has the same effect whether it's performed once or several times — what makes retries safe. → Designing REST APIs
- IDisposable
- Interface for types holding resources (files, connections) that must be released deterministically, usually with a using statement. → IDisposable and using
- IL
- Intermediate Language — the CPU-independent instructions the C# compiler produces, JIT-compiled to machine code at run time. → How compilation works
- Index
- A database structure (usually a B-tree) that makes lookups by certain columns fast, at the cost of storage and slower writes. → Indexes and transactions
- Interface
- A contract listing members that implementing classes or structs must provide. A class can implement many interfaces. → Interfaces
J
- JIT
- Just-In-Time compiler — translates a method's IL into machine code the first time it's called; tiered compilation optimizes hot code later. → How compilation works
- JWT
- JSON Web Token — a signed (not encrypted) token carrying claims, commonly used as a bearer access token for APIs. → Authentication: sessions, tokens and passwords
L
- Lambda
- An anonymous inline function, like x => x * 2, usable wherever a delegate is expected. → Delegates and lambdas
- LINQ
- Language-Integrated Query — methods like Where, Select and GroupBy for querying any IEnumerable<T> (and databases, via EF Core). → LINQ basics: filter, project, sort
- Load balancer
- A component that spreads incoming requests across several server instances and routes around unhealthy ones. → Scaling and load balancing
M
- Middleware
- A component in the request pipeline that can act on the request, call the next component, and act on the response — or short-circuit. → The middleware pipeline
- Migration
- Versioned code describing a database schema change, generated and applied with dotnet ef. → Entity Framework Core basics
N
- N+1 problem
- Running one query for a list and then one more query per item (often via lazy loading) instead of loading related data in one query. → Relationships and efficient queries
- NuGet
- The .NET package manager; packages are listed as PackageReferences in the .csproj and restored from nuget.org. → NuGet packages
- Null-conditional operator
- The ?. operator, which returns null instead of throwing when the left side is null. Often combined with ?? for a fallback. → null and nullable types
O
- OAuth 2.0
- A framework for delegated authorization — granting an app limited, revocable access (scopes) to an API without sharing a password. → OAuth 2.0 and OpenID Connect
- OpenID Connect
- An identity layer on top of OAuth 2.0 that standardizes login with ID tokens — the basis of "Sign in with…" and SSO. → OAuth 2.0 and OpenID Connect
- Options pattern
- Binding a configuration section to a typed class and injecting it as IOptions<T>. → Configuration and logging
P
- Pattern matching
- Testing values against patterns — types, constants, ranges, properties, positions and list shapes — with is and switch. → Pattern matching
- Polymorphism
- Code written against a base type or interface automatically runs each derived type's own implementation (virtual/override). → Polymorphism: virtual, override and abstract
- Primary key
- The column (or columns) uniquely identifying each row of a table. → SQL fundamentals
- Property
- A class member that looks like a field to callers but runs get/set code, allowing validation and restricted writes. → Properties and encapsulation
Q
- Queue
- A first-in, first-out structure — in memory (Queue<T>) or as a message broker between services for background work. → Message queues and background jobs
R
- Race condition
- A bug where the result depends on the timing of concurrent operations touching shared data, such as two threads incrementing a counter. → Thread safety and channels
- Rate limiting
- Restricting how many requests a client may make in a period; excess requests get 429 Too Many Requests. → Scaling and load balancing
- Record
- A type with value-based equality, a readable ToString and with-expressions — ideal for immutable data. → Records
- Reference type
- A type whose variables hold references to objects on the heap (classes, arrays, strings); copying the variable shares the object. → Value types vs reference types
- REST
- An architectural style for web APIs built around resources at URLs, HTTP methods as verbs and status codes for outcomes. → Designing REST APIs
- Retry with backoff
- Retrying a failed operation after increasing delays (often with random jitter) to ride out transient failures without overwhelming the dependency. → Microservices, CAP and resilience
S
- Scoped lifetime
- A DI lifetime where one instance is created per scope — in ASP.NET Core, per HTTP request. Typical for DbContext. → Dependency injection
- SignalR
- An ASP.NET Core library for real-time communication that pushes messages to connected clients, using WebSockets when available. → Razor Pages, Blazor and SignalR
- SOLID
- Five design principles — single responsibility, open/closed, Liskov substitution, interface segregation and dependency inversion. → SOLID principles
- Span<T>
- A ref struct providing a view over contiguous memory (arrays, strings, stack) so you can slice and parse without copying. → Span<T> and allocation-free code
- SQL injection
- A vulnerability where untrusted input is concatenated into a query and changes its meaning. Prevented with parameterized queries. → Web security essentials
- Stack
- Per-thread memory holding method frames (parameters, locals) that is freed instantly when a method returns — or the LIFO collection Stack<T>. → The stack, the heap and boxing
- Stateless
- Each request is self-contained and the server keeps no per-client memory between requests — what lets any instance serve any request. → Inside a backend server
- Struct
- A value type; assigning or passing it copies its data. Best for small, immutable values. → Structs and value semantics
T
- Task
- An object representing an operation that will complete in the future, optionally with a result (Task<T>). → Tasks and threads
- TLS
- Transport Layer Security — encrypts and authenticates connections using certificates; HTTPS is HTTP over TLS. → Headers, cookies and HTTPS
- Transaction
- A group of database operations that succeed or fail together, committed or rolled back as a unit. → Indexes and transactions
- TTL
- Time To Live — how long a cached value (or DNS answer) may be used before it expires. → Caching
U
- Unit test
- An automated test of a small piece of logic in isolation — fast, deterministic, without real databases or networks. → Unit testing with xUnit
V
- Value type
- A type whose variables contain the value itself (int, bool, structs, enums); assignment copies the data. → Value types vs reference types
W
- WebSocket
- A persistent, two-way connection between client and server, upgraded from HTTP, used for real-time communication. → Beyond REST: GraphQL, gRPC and WebSockets
X
- XSS
- Cross-site scripting — user content rendered as markup in a page. Prevented by encoding output (the default in Razor, Blazor and React) and a Content Security Policy. → Web security essentials
Y
- yield return
- Produces one element of a lazy sequence from an iterator method, pausing it until the consumer asks for the next element. → Deferred execution and iterators