> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# Post-Increment The `++` (increment) operator is a unary arithmetic operator that increases the value of its operand by 1. The operand must be an assignable entity, specifically a variable, a property access, or an indexer access. The operator operates in two distinct evaluation modes based on its placement relative to the operand: ## Postfix Increment (`x++`) The postfix form evaluates the expression to the original value of the operand *before* the increment operation is applied. The increment occurs as a side effect after the value has been captured for the current expression. ```csharp theme={"dark"} int x = 10; int result = x++; // result is 10 // x is 11 ``` ## Prefix Increment (`++x`) The prefix form increments the operand first, and then evaluates the expression to the *new* mutated value. ```csharp theme={"dark"} int y = 10; int result = ++y; // y is 11 // result is 11 ``` ## Type Support and Behavior The compiler provides built-in support for the `++` operator across multiple types, with specific behaviors for certain type categories: * **Integral and Floating-Point Types:** (`int`, `long`, `float`, `double`, `decimal`, etc.) The value is incremented by exactly `1` of the respective type. * **Smaller Integral Types:** (`byte`, `sbyte`, `short`, `ushort`) The `++` operator automatically handles the implicit cast back to the original type. Standard addition promotes the operands to `int`, requiring an explicit cast, whereas the increment operator bypasses this requirement. ```csharp theme={"dark"} byte b = 0; b++; // Compiles successfully // b = b + 1; // Compiler error: Cannot implicitly convert type 'int' to 'byte' ``` * **Characters:** (`char`) Increments the underlying 16-bit integer representing the UTF-16 code unit. * **Enumerations:** (`enum`) The arithmetic operation is performed on the underlying integral type of the enumeration, but the resulting value is automatically cast back to the enumeration type itself. * **Pointers:** (`T*`) In an `unsafe` context, incrementing a pointer increases the memory address by `sizeof(T)` bytes, adhering to standard pointer arithmetic rules. ## Nullable Value Types When applied to a nullable value type (`Nullable`), C# utilizes lifted operators. If the operand evaluates to `null`, the increment operation is bypassed, and the result remains `null`. It does not throw a `NullReferenceException`. ```csharp theme={"dark"} int? x = null; x++; // x evaluates to null ``` ## Overflow Behavior The behavior of the `++` operator when incrementing an integral type at its maximum limit depends on the arithmetic overflow context (`checked` or `unchecked`). * **`unchecked` context (Default):** The value silently wraps around to the minimum representable value of the type. * **`checked` context:** The operation throws a `System.OverflowException`. ```csharp theme={"dark"} byte b1 = 255; unchecked { b1++; // b1 wraps around to 0 } byte b2 = 255; checked { b2++; // Throws System.OverflowException } ``` ## Operator Overloading Custom `class` and `struct` types can overload the `++` operator using the `operator` keyword. ```csharp theme={"dark"} public struct Vector { public int X; public static Vector operator ++(Vector v) { v.X++; return v; } } ``` In C#, you cannot overload the prefix and postfix forms independently. You define a single `operator ++` method, and the C# compiler automatically synthesizes the correct prefix and postfix evaluation semantics at the call site based on the operator's position relative to the operand. ## Intermediate Language (IL) and Thread Safety At the IL level, the `++` operator is not a single atomic instruction. It translates into a read-modify-write sequence: 1. Load the value from memory to the evaluation stack (`ldloc` / `ldfld`). 2. Add 1 to the value (`add`). 3. Store the new value back to memory (`stloc` / `stfld`). Because it is a multi-step operation, the `++` operator is **not thread-safe**. If multiple threads apply the `++` operator to the same variable concurrently, race conditions will occur, leading to lost updates. For atomic increments in multithreaded scenarios, the runtime provides the `System.Threading.Interlocked.Increment(ref int location)` method.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More