| Abstract Class | A class that cannot be instantiated directly and may contain abstract members that derived classes must implement. |
| Assembly | A compiled unit of code in C#, typically an .exe or .dll file. |
| Async/Await | Language-level support for asynchronous programming; async marks a method as asynchronous and await suspends it until a Task completes without blocking the thread. |
| Attribute | Metadata added to code elements using square brackets, used for reflection or behavior control. |
| Base Class | A class from which another class inherits implementation and functionality through the inheritance mechanism. |
| Boxing/Unboxing | The process of wrapping a value type in a heap-allocated object (boxing) or extracting it back (unboxing). |
| Class | A blueprint for creating objects. Can include fields, properties, methods, and events. |
| Closure | A lambda or local function that captures variables from its enclosing scope, keeping them alive as long as the function exists. |
| Constructor | A special method that initializes a new instance of a class. |
| Contravariance | Generic type variance allowing a generic interface or delegate typed on a base type to be used where one typed on a derived type is expected. |
| Covariance | Generic type variance allowing a generic interface or delegate typed on a derived type to be used where one typed on a base type is expected. |
| Deconstruction | Syntax for unpacking a tuple or record into individual variables: (var x, var y) = point;. |
| Default Interface Methods | Implementation code provided directly in an interface definition, available to all implementing types without requiring them to override it. |
| Deferred Execution | The behavior where a LINQ query does not execute until the result sequence is actually enumerated. |
| Delegate | A type-safe function pointer used to reference methods or implement callbacks and events. |
| Dynamic | A type that bypasses compile-time type checking, deferring member resolution to runtime. |
| Enum | A distinct type representing a set of named constants. |
| Event | A mechanism used to provide notifications, typically implemented with delegates. |
| Exception | An error-handling object used with try, catch, and throw. |
| Explicit Implementation | Interface member implementation that is hidden from the type's public surface and accessible only through the interface type. |
| Expression-Bodied Member | A method or property written with => providing a concise single-expression implementation. |
| Extension Method | A static method in a static class whose first parameter uses this, allowing it to be called as if it were an instance method on that type. |
| Field | A variable defined inside a class or struct. |
| Garbage Collection | Automatic memory management that reclaims unreachable heap objects without explicit programmer action. |
| Generic Constraint | A where clause that restricts what types may be supplied as arguments to a generic type parameter. |
| IDisposable | An interface with a single Dispose() method enabling deterministic cleanup of unmanaged resources, typically via a using statement. |
| IEnumerable | An interface that exposes an enumerator over a sequence, forming the basis for foreach and LINQ queries. |
| Indexer | Allows objects to be indexed like arrays using the this[] syntax. |
| Inheritance | A mechanism where a class derives from one base class, inheriting its members and behavior and optionally overriding virtual members. |
| Init-Only Property | A property with an init accessor that can be set only during object initialization, providing immutability after construction. |
| Interface | A contract that defines members a class or struct must implement. |
| Iterator | A method using yield return or yield break that produces values lazily through the IEnumerable pattern. |
| Just-In-Time Compilation | Runtime compilation of .NET intermediate language (IL) to native machine code, performed by the CLR when a method is first called. |
| Lambda Expression | An anonymous function written using => syntax. |
| LINQ | Language Integrated Query - a set of query capabilities built into C# for filtering, projecting, and aggregating sequences. |
| Local Function | A method defined inside another method, invisible outside its enclosing scope and able to capture outer variables. |
| Managed Heap | The memory area managed by the garbage collector where all reference-type objects are allocated. |
| Method | A function defined within a class or struct. |
| Multicast Delegate | A delegate instance that holds multiple method references and invokes all of them in sequence; targets are added and removed with += and -=. |
| Named Argument | A method call argument specified by parameter name rather than position, allowing arguments to be passed in any order. |
| Namespace | A container for organizing related classes and types. |
| Nullable Reference Type | A reference type annotated with ? to indicate it may hold null, enabling compile-time null-safety warnings. |
| Nullable Type | A value type that can also hold null, written as int?, bool?, etc. |
| Null-Coalescing Operator | The ?? operator that returns its right operand when the left operand is null. |
| Null-Conditional Operator | The ?. operator that evaluates a member access only when the object is not null, returning null otherwise. |
| Object | An instance of a class. In C#, all types derive from System.Object. |
| Operator Overloading | Custom definition of operator behavior (+, -, ==, etc.) for user-defined types. |
| Optional Parameter | A method parameter with a default value that may be omitted by callers. |
| Out Parameter | A by-reference parameter the method is required to assign before returning, used to return additional values. |
| Overloading | Defining multiple methods with the same name but different parameter lists. |
| Override | Replacing a base class virtual method implementation in a derived class. |
| Pattern Matching | Language feature for type-safe conditional logic that simultaneously tests a value's type and properties, commonly used in switch expressions and is expressions. |
| Primary Constructor | A constructor declared directly in the class or struct header whose parameters are in scope throughout the type body. |
| Property | A member that provides controlled access to a field using get and set accessors. |
| Record | A concise reference type (or value type with record struct) optimized for immutable data, with built-in equality and with expression support. |
| Readonly Struct | An immutable value type declared with readonly that prevents any field from being modified after construction. |
| Ref Parameter | A by-reference parameter that lets a method read and modify the caller's original variable. |
| Reference Type | A type (class, string, array, delegate, interface) whose variable holds a reference to heap-allocated data rather than the data itself. |
| Reflection | The ability to inspect type metadata and invoke members dynamically at runtime via System.Reflection. |
| Sealed Class | A class that cannot be used as a base class for inheritance. |
| Sealed Override | An override marked sealed to prevent further overriding in classes derived from the current class. |
| Span | A stack-allocated view over a contiguous region of memory (array, string, or native buffer) enabling high-performance slicing without allocation. |
| Stack | The per-thread memory region that holds local variables, method parameters, and return addresses for the active call chain. |
| Static | Indicates a member or class belongs to the type itself rather than to any instance. |
| Static Abstract Member | A static member declared abstract in an interface, enabling generic algorithms that require static operators or factory methods on type parameters. |
| Static Lambda | A lambda prefixed with static that is forbidden from capturing instance or local state, preventing unintended allocations. |
| Struct | A value type similar to a class, stored inline (on the stack or inside another type), without support for inheritance. |
| Target-Typed New | Syntax allowing new() without repeating the type name when the type is already known from context. |
| Thread | An execution path within a program. C# supports multithreading via System.Threading and the Task parallel library. |
| Try-Catch-Finally | Control structure for handling exceptions and guaranteeing cleanup code runs regardless of whether an exception occurred. |
| Tuple | A lightweight value type that groups heterogeneous values without defining a named class, using syntax like (int x, string y). |
| Type Inference | Compiler feature that determines a variable's type from its initializer when declared with var. |
| Unmanaged Type | A generic constraint (where T : unmanaged) restricting a type parameter to types that contain no managed references and can be used in unsafe pointer operations. |
| Using | Used for namespace import or, with IDisposable, to ensure deterministic resource disposal at the end of a block. |
| Value Type | A type (int, double, bool, char, struct, enum) whose variable holds data directly and is copied on assignment. |
| Virtual | Marks a method as overrideable in a derived class, enabling runtime polymorphism. |
| With Expression | Record syntax for non-destructive mutation: creates a new instance with specified properties changed, leaving the original unchanged. |
| Yield Return | A keyword inside an iterator method that emits one value to the caller and suspends execution until the next value is requested. |