Glossary

The small XML file that describes one C# project and how to build it.

A file listing what Git should never track, such as bin/ and obj/.

The older, Windows-only .NET, now in maintenance only.

The software that loads and runs a built .NET program.

The toolkit for building .NET programs: compiler, build system, CLI, and templates.

A historical spec that let one library run on both .NET Framework and modern .NET.

The single zip file a NuGet package ships as.

A class you can't create directly; it exists to be derived from.

A keyword like private or public that says who can use a member.

One exception that holds several others inside it.

A tool built on a language model that suggests, explains or writes code for you.

Asking for a new piece of heap memory, which the garbage collector must later clean up.

The part of a job that can't be split up limits how much faster more cores can make it.

A quick unnamed object like new { Name, Total }, made on the spot.

The text after a command's name that says what to act on.

Set things up, do the one thing being tested, then check the result.

A fixed-size row of values of one type, numbered from 0.

The .dll file a .NET build produces: IL plus metadata.

The line in a test that checks the result and fails the test if it's wrong.

A sequence whose items arrive over time, each one awaited as it comes.

Starting a slow job and getting on with other things until it finishes.

A step that happens all at once, so no other thread can see it half done.

The thing an attribute is attached to, which a prefix like return: or assembly: can change.

Checking who someone is.

Checking what someone who has signed in is allowed to do.

Pause this method until the task finishes, without holding up the thread.

A full queue making a fast producer wait for a slower consumer.

The large set of ready-made types that ships with .NET.

A careful, repeated measurement of how fast some code runs and how much memory it uses.

An operator that works on the individual bits of a number.

Having the same bytes in C# and in native code, so it crosses without conversion.

A thread standing still, doing nothing, while it waits for something.

A true-or-false value.

Wrapping a value type in an object on the heap.

Repository rules that stop anyone merging to main until reviews and CI checks pass.

A marker that pauses the program at a line so you can look around.

A named set of build settings, usually Debug for developing and Release for shipping.

The stack of method calls that haven't finished yet.

A method you hand to other code so it can call you back.

A tag on an optional parameter that makes the compiler fill in a fact about where the call was written.

A signal you pass along so a long job can be told to stop early.

A long-lived object holding on to a short-lived one, so it outlives its time.

Capital and small letters count as different.

Writing (type)value to force a conversion that might lose information.

Keeping every package version for a whole solution in one file.

EF Core remembering which loaded objects you changed, so it knows what to save.

A thread-safe queue where some code puts items in and other code takes them out.

A single character, written in single quotes.

A second version of an operator that runs inside checked(...) and should throw on overflow.

A blueprint for objects: the data they hold and what they can do.

A project that builds reusable code into a .dll other projects can use.

A lambda that remembers variables from around it.

A tool built into the compiler that points out likely bugs and style problems as warnings.

How much of your code the tests actually ran.

A teammate reading your changes before they're merged, to catch mistakes and share knowledge.

A sign in the code that something may be badly organized, like a very long method.

An AI tool that edits files and runs commands such as build and test for you.

Square-bracket syntax for building a collection: [1, 2, 3].

Tricking a program into running extra operating-system commands by hiding them in its input.

Text in code the compiler ignores, written for people.

A mistake the compiler refuses to build.

A program that translates source code into another form ahead of running it.

Building an object out of other objects instead of inheriting.

The one place near a program's start where its objects are created and connected.

A shortcut like += that updates a variable.

Several jobs in progress over the same stretch of time.

A true-or-false expression that decides which code runs.

A breakpoint that only pauses when a condition you give is true.

condition ? a : b: a one-line if/else that produces a value.

Settings your program reads at startup instead of having them written into the code.

The text that tells a program which database to open and how to log in.

A named value that can never change.

A generic type with its type arguments filled in, like List.

Code that runs when an object is created, to set it up.

A ValueTask may be awaited only once; call AsTask() if you need more.

A packaged, runnable snapshot of an app plus the operating-system files it needs.

Having a server build and test every change automatically, so breakage shows up right away.

A class grouping related API actions, the older and still common way to build APIs.

The lines inside a lock, run by one thread at a time.

Getting a web page to run an attacker's script by sneaking it into content the page displays.

A text file of rows, with the values in each row separated by commas.

The language-and-region settings that decide things like the decimal separator.

Your own attribute: a class that derives from Attribute, used as a tag in square brackets.

The package that lets EF Core talk to one kind of database, such as SQLite or SQL Server.

Moving clocks forward in spring and back in autumn, which makes some local times skip or repeat.

The EF Core object that is your session with the database.

Two threads each waiting forever for something the other one holds.

A tool that pauses a running program so you can look inside it.

A number type that stores base-10 digits exactly, used for money.

Unpacking a tuple or record into separate variables.

A wrapper that adds behavior to an object while looking like the same kind of object.

An interface member with a body that implementers inherit unless they write their own.

A query that waits to run until you actually loop over its results.

The checklist a piece of work must pass before you call it finished.

A variable that holds a method you can call later.

Handing a class what it depends on from outside, usually through its constructor.

Depend on an interface, not on a specific class.

A named, reusable shape of solution to a problem that keeps coming up in code.

The code, like CS0103, that names a compiler error or warning.

A lookup table from keys to values.

A file whose settings apply to every project in the folders below it.

A database that stores whole JSON-like documents instead of rows in tables.

The dotnet command you type in a terminal to create, build, run, test, and publish.

C#'s everyday number type for values with fractions.

Three rules of thumb: don't repeat knowledge, keep it simple, and don't build what you don't need yet.

A plain object shaped for data crossing a boundary, like an API response.

A saved snapshot of a running program's memory, for study later.

A type that skips compile-time checking; errors show up only when running.

A settings file that tells every editor and the build how your code should be formatted and styled.

Hiding an object's data so it can only change in allowed ways.

The rule for turning characters into bytes and back.

The date a .NET release stops getting any fixes, including security fixes.

One address plus method your API answers, like GET /orders/5.

A C# class whose objects are stored as rows in a table.

A type with a fixed set of named values.

The rule that ==, !=, both Equals methods and GetHashCode must all agree about what equal means.

A way for an object to notify others when something happens.

An object that says "this operation failed", thrown to stop normal flow.

An extra condition on a catch, written with when, that must be true to catch.

Covering every possible input.

A member written as IName.Member, reachable only through that interface.

A piece of code that produces a value.

The dot-and-letters ending of a file name, like .cs.

A property, static member, operator or method added to a type from outside it, in a C# 14 extension block.

A static method you can call with a dot, as if a type you don't own had it.

A method or object whose job is to create other objects, hiding the details of how.

A merge where Git just slides the branch pointer forward because nothing else changed.

The hundreds digit of an SDK version: a batch of SDK tooling on the same runtime.

A variable that belongs to an object or class.

A C# program that is just one .cs file, run with dotnet run app.cs.

A type marked file, usable only inside the one source file that declares it.

A namespace declaration ending in a semicolon that covers the whole file.

A cleanup method the garbage collector may run some time after an object becomes unreachable.

Cleanup code that runs whether the try part worked or failed.

The moment an exception is thrown, before any catch sees it.

A test that sometimes passes and sometimes fails with no code change.

A container for files and other folders.

A loop that visits each item in a collection once.

A code like C2 or N0 that says how to display a number or date.

A base-class change that breaks derived classes nobody touched.

A published app that relies on .NET already being installed; self-contained brings its own copy.

Built-in delegate types: Func returns a value, Action doesn't.

The address of a static method, called like a method but with no delegate object.

The part of .NET that frees memory used by objects nothing can reach any more.

An attribute class with a type parameter, so the type it names is checked like any generic.

A rule limiting which types a type parameter accepts.

The standard .NET app shell that sets up services, settings, logging and shutdown for you.

A type with a slot for another type, like List<int>.

A tool that records snapshots of your project so you can go back and see what changed.

A separate line of commits in Git where you can work without disturbing the main code.

A check at the top of a method that throws if an argument is bad.

When an AI states something false with confidence, such as a method that doesn't exist.

A collection of unique items with fast membership tests.

A named piece of extra information sent with a request or response.

The memory area where objects live until nothing refers to them.

A class the host starts with the program and stops on shutdown.

The code that runs so often that its speed decides the speed of the whole program.

Applying code edits to a program while it keeps running.

The language browsers and programs use to ask servers for things over the web.

The .NET class your program uses to send web requests and read the replies.

Like IDisposable, but the cleanup itself is awaited.

An editor with building, running, and debugging built in.

Safe to repeat: sending it twice ends the same as sending it once.

The interface for objects that hold something you must give back, like an open file.

The interface for anything you can loop over with foreach.

The in-between language the C# compiler produces.

A query call that does its work right away and gives you the answer.

A debugger panel where you type C# while paused and see the result.

Can't be changed after it's created.

A collection that can't be changed; "changes" produce a new one.

A type change C# makes for you because nothing can be lost.

++ adds one to a variable; -- subtracts one.

A source generator written as a cached pipeline, so the editor only redoes work when something relevant changed.

The position number of an item; the first is 0.

^1 means the last item, ^2 the one before it.

A member that lets code use an object with square brackets, like obj[2] or obj["key"].

A loop whose condition never becomes false.

Building a new class on top of an existing one.

A property that can be set only while the object is being created.

A fixed number of values stored right inside a struct, with no separate array object.

The original exception kept inside a newer one that wraps it.

Checking input before trusting it.

C#'s everyday whole-number type.

Dividing two whole numbers, which drops the fraction.

A test that checks several real parts working together, like code plus a real file.

Generated code that replaces one specific method call in your program with a different method.

A list of members a type promises to provide.

A rule about an object's data that must always stay true.

A query that gets translated into another language, like SQL, instead of run in memory.

The standard date format that looks like 2026-09-26T14:30:00Z.

A method that hands back items one at a time, pausing between them.

The part of the runtime that turns IL into machine code while the program runs.

A text format for data made of objects, lists, strings, numbers, true/false and null.

A signed token a client sends with each request to prove who it is.

A short inline method, like x => x * 2.

Which edition of the C# language the compiler accepts for your project.

A program trained on huge amounts of text that predicts plausible next words; it can sound sure and still be wrong.

Splitting an app into layers, such as business rules, use cases and databases, with rules about which may use which.

C#'s built-in way to filter, sort, group and total any collection.

The part of an IQueryable that reads the query's expression tree and turns it into another language, like SQL.

A pattern that matches a sequence's elements, like [1, .., 9].

A resizable list that keeps items in order.

A value written directly in code, like 42 or "hi".

A method declared inside another method.

A rule that lets only one thread at a time run a piece of code.

A file recording the exact package versions used, so every build gets the same ones.

The program runs but does the wrong thing.

A breakpoint that writes a message instead of pausing.

Code that repeats.

A long-term-support .NET release, supported for three years.

The numeric instructions a processor actually executes.

An attribute with no behavior of its own, used only to mark code for a generator or tool to find.

Converting a value between its C# form and the form native code expects.

A go-between that routes requests to the code that handles them, so senders and handlers don't know each other.

A reflection object that describes one member of a type, such as a property or a method.

A span-like window that can be stored in fields and kept across an await.

What happens when two branches changed the same lines and Git can't decide which to keep.

A named block of code you can call, optionally with inputs and a result.

A step every request passes through, in order, like logging or checking who's calling.

A saved step that changes the database's tables to match your updated classes.

A web API written as a few lines mapping addresses straight to C# functions.

The smallest program that still shows a bug, with made-up data.

A stand-in object used in a test in place of the real thing.

The current, cross-platform .NET (currently .NET 10).

One deployable app split inside into well-separated modules.

A method the runtime calls by itself, once, before any other code in its assembly runs.

The build engine that reads project files and turns them into a program.

An entry in a list in a project file, such as a source file or a package.

A named setting in a project file, like the target framework.

A named step of a build, like Restore or Build, made of smaller tasks.

One delegate holding several methods, run in order.

Breaking the code on purpose to check that your tests notice.

A name that groups related types, like a folder for code.

Compiling an app straight to machine code before it ships, so it needs no JIT and starts fast.

The delegate type a lambda gets on its own, so var can hold it.

A property linking one entity to related ones, like an order's lines.

A popular older JSON library you'll see in a lot of existing code.

Something a version deliberately won't do, written down so nobody builds it.

Restore's automatic check for packages with known security problems.

A downloadable bundle of someone else's assemblies you can add to a project.

The value meaning "no object here".

a ?? b: use a, or b if a is null.

A ! after an expression that tells the compiler "trust me, it isn't null".

The compiler tracking whether each reference might be null at each point.

A ? after a type, like string?, meaning the value may be null.

A value type that can also be null, like int?.

The crash you get when you use a reference that points to nothing.

One thing built from a class, with its own data.

Setting properties right after new, inside braces.

An object tells a list of listeners when something happens.

A loop that runs one pass too many or too few.

How far a local clock is ahead of or behind UTC, like -05:00.

A standard machine-readable description of an API's addresses, inputs and outputs.

A symbol like +, ==, or && that combines values.

A System.Numerics interface promising one operator, such as + or <, for use in a generic constraint.

Writing a method that says what a symbol like + or == means for your own type.

Letting people edit freely, then refusing a save if someone else changed the row first.

Reading a group of settings into a small class your code asks for.

Comparing strings character code by character code, ignoring language rules.

A library that lets you work with database rows as ordinary C# objects.

When a client sets fields it shouldn't, because the API bound its input straight onto an entity.

A result too big (or too small) for its type.

Several methods sharing a name but taking different parameters.

How C# calls a function exported by a native library, such as the OS's C library.

A place packages are downloaded from, like nuget.org or a company server.

The old way .NET Framework projects listed their NuGet packages, in a separate file.

Jobs literally running at the same instant on different processor cores.

A named input a method declares.

How ASP.NET Core fills your handler's parameters from the address, query string, headers and body.

A query where values are sent separately from the SQL, never pasted into it.

One test method run many times with different inputs.

A program that reads code's structure without running it.

Reading text and turning it into a value such as a number.

A class whose code is split across several files.

A member declared in one part of a partial class and implemented in another.

Storing a scrambled, one-way version of a password instead of the password itself.

The address of a file or folder.

A test a value can match, like > 10 or "quit".

Stopping the garbage collector from moving an object while code holds its address.

A type such as int* that holds a memory address.

One call, different behavior depending on the object's real type.

The rules for which operators group first.

Making code faster before you know it is slow, usually at the cost of clarity.

A feature that ships early for trying out and may still change before release.

Constructor parameters written right after the type name.

The column that uniquely names each row; a foreign key points at another table's primary key.

Using a bare int or string for a value that has its own meaning, like an order ID.

A queue that always hands out the most urgent item next.

A standard JSON shape for describing what went wrong in an API request.

A tool that watches a running program and reports where its time and memory go.

A set of instructions a computer can carry out.

A precise notation for writing instructions a computer can carry out.

A folder with a .csproj file describing one program or library to build.

A line in one project that says "I use the code in that other project".

Turning each item into something else, like picking one field.

A member that looks like a field but runs code when read or written.

A pattern that checks an object's properties, like { Age: >= 18 }.

Preparing the exact set of files you copy to another machine to run your app.

A saved set of publish settings you can reuse instead of typing options each time.

A request to merge your branch into the main code, where teammates review the changes first.

The part of a library that turns a LINQ query into something else, such as SQL.

The from ... where ... select way of writing a LINQ query.

First in, first out: like a line at a counter.

A bug where the result depends on which thread happens to get there first.

Text in triple quotes where backslashes and quotes need no escaping.

Still findable by following references from something the program is using.

A type built for holding data, with value-based equality.

A method calling itself on a smaller version of the problem.

A field in a ref struct that is another name for someone else's variable.

A local variable that is another name for existing storage, not a box of its own.

A parameter that is an alias for the caller's variable.

A reference you may read through but not write through.

A method that hands back a reference to storage instead of a copy of its value.

A struct that may live only on the stack, like Span.

Changing how code is organized without changing what it does.

Two references are equal only if they point at the same object.

A type whose variables hold a reference to an object, not the object itself.

A test written for a bug you fixed, so it can't quietly come back.

A pattern for matching text, like "three digits then a dash".

A database that stores data in tables of rows and columns, linked by keys.

A pattern that compares, like > 10.

An object that stores and fetches your domain objects so the rest of the code doesn't talk to the database directly.

Making calls survive brief failures, with timeouts, retries and backing off.

A common style for web APIs: resources at addresses, changed with standard HTTP methods.

Downloading the packages a project needs before it can build.

The result a method hands back.

A failure that happens while the program is running.

A short name for an operating system and processor, like win-x64 or osx-arm64.

A class that owns a native handle and releases it exactly once.

A number conversion that clamps a value to the nearest end of the target type's range.

A promise that a ref or span parameter or local never leaves its method.

A class or override that can't be extended further.

A password, key or token that grants access and must never be written into code.

Version numbers like 2.4.1 where each part says how big the change was.

Anything you can walk through one item at a time with foreach.

Turning an object into text or bytes you can save or send, and back again.

The part of .NET that creates your objects and hands each one what it needs.

How long the container keeps reusing one object: never, per request, or forever.

A class that fetches what it needs from the container itself, hiding its real needs.

Stopping as soon as the answer is known, so the right side may not run.

An app published as one executable file instead of a folder of files.

Five design guidelines for classes that are easy to change and test.

A file grouping several related projects so they can be opened and built together.

A set or dictionary that keeps its items in order automatically.

The text of a program, written by a person in a programming language.

The compiler writing extra code for you while it builds your program.

A window onto part of an array or other memory, without copying it.

The language for asking a relational database to find and change data.

An attack where user input is pasted into SQL and changes what the query does.

The list of method calls that were in progress when an error happened.

Last in, first out: like a stack of plates.

One complete instruction, usually ending in a semicolon.

A static member every implementing type must supply; the basis of generic math.

A member that belongs to the class itself, not to any one object.

A static interface member with a default body that each implementing type may replace.

The three-digit number in a response saying how the request went, like 200 or 404.

Running a paused program one line or one call at a time.

Swapping in different behavior by passing a different object that implements the same interface.

A pipe of bytes you read from or write to a piece at a time.

A piece of text.

Putting values straight into text with $"…{value}…".

A changeable text buffer for building a string in many steps.

A tiny wrapper type for one kind of ID, so different kinds can't be mixed up.

A small value type you define yourself.

Logging named values, not just text, so logs can be searched and filtered.

A compact way to pick a value by matching cases: x switch { … }.

An object standing for work that may not have finished yet.

A window where you type commands instead of clicking.

A stand-in implementation that a test controls, such as a fake clock.

Shared setup that several tests in a class reuse.

The program that finds your tests, runs them and reports what passed.

One line of work the computer runs; a program can have several at once.

A shared set of ready-made threads that tasks borrow and give back.

A region's clock rules, including when daylight saving starts and ends.

A file that pins the .NET command-line tools a repository uses, so everyone gets the same versions.

A table of each variable's value at each step of a program.

A group of database changes that all happen or none of them do.

A package you get because a package you added needs it.

A build setting that makes any warning fail the build, so none are ignored.

Cutting unused code out of a self-contained app so it ships smaller.

A method that returns true or false for success and hands the result back through out.

Code that says "try this, and if that kind of failure happens, do this instead".

A method that tries to parse text and tells you whether it worked, instead of crashing.

A quick bundle of a few values, like (name, score).

The kind of value a variable holds, which decides what you can do with it.

The compiler working out type arguments from the values you pass.

The placeholder T in a generic type or method.

A pattern that tests a value's type, like is string s.

A class that wraps one web API, given a ready-made HttpClient by the container.

A box-and-arrow picture of classes and how they relate.

A generic type written with empty angle brackets, such as List<>.

An exception nobody catches; it ends the program with an error report.

An object that collects changes and saves them all together, or not at all.

A small automatic check that one piece of code does what it should.

A value type made only of plain bytes, with no references inside at any depth.

Code in a marked region where C# stops checking memory access, so pointers are allowed.

Any data that comes from outside your program and could have been written by an attacker.

A private settings file on your own machine for passwords and keys while developing.

One thing one kind of user wants, written from their side.

A method that lets your type turn into another type, with or without a cast.

A using line that gives a type a second, shorter name in one file.

A line that lets you use a namespace's types without typing its full name.

A way to make sure a file or other resource gets closed when you're done.

The one world clock that doesn't change with location or daylight saving.

A string literal with a u8 suffix, giving its UTF-8 bytes instead of text.

A small type defined by its data and rules, like an Email that checks its text.

A type whose variables hold the data itself, copied on assignment.

A keyword that lets the compiler work out a variable's type from its starting value.

A named place that holds a value of one type.

Whether a generic type can stand in for a related one, like IEnumerable for IEnumerable