> ## 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# Unary Plus The `+` operator in C# is a heavily overloaded token that functions as a unary identity operator, a binary arithmetic addition operator, a string concatenation operator, a delegate combination operator, an enumeration offset operator, and a pointer arithmetic operator, depending on the compile-time types of its operands. ## Unary Plus Operator The unary `+` operator is predefined for all numeric types. It acts as an identity operator, returning the exact value of its operand. ```csharp theme={"dark"} int operand = 5; int result = +operand; // result is 5 ``` For user-defined types, the unary `+` can be overloaded. If an operand is of type `byte`, `sbyte`, `short`, or `ushort`, implicit numeric promotion occurs, and the operation returns an `int`. ## Binary Arithmetic Addition When both operands are of numeric types, the `+` operator computes their sum. It is predefined for integer (`int`, `uint`, `long`, `ulong`), floating-point (`float`, `double`), and `decimal` types. ```csharp theme={"dark"} int operand1 = 10; int operand2 = 20; int result = operand1 + operand2; // result is 30 ``` **Mechanics:** * **Numeric Promotion:** If the operands are of different types, the compiler applies implicit numeric promotions to align them to a common type before evaluating the addition. For example, adding a `short` and an `int` results in an `int`. * **Overflow Context:** For integer types, the behavior of the `+` operator upon exceeding the type's maximum value depends on the execution context. In an `unchecked` context (the default), the result is truncated by discarding high-order bits. In a `checked` context, a `System.OverflowException` is thrown. * **Floating-Point:** For `float` and `double`, addition is performed according to IEEE 754 arithmetic, which includes handling for `NaN` (Not a Number) and `Infinity`. ## Enumeration Addition The `+` operator is predefined to allow the addition of an enumeration type and its underlying integral type. ```csharp theme={"dark"} System.DayOfWeek day = System.DayOfWeek.Monday; // Underlying value is 1 System.DayOfWeek nextDay = day + 2; // result is System.DayOfWeek.Wednesday (3) ``` **Mechanics:** * The operation adds the integral value to the underlying numeric value of the enumeration. * The resulting numeric value is explicitly cast back to the enumeration type. ## Pointer Arithmetic In an `unsafe` context, the `+` operator allows adding an integer offset to a pointer. ```csharp theme={"dark"} unsafe { int[] numbers = { 10, 20, 30 }; fixed (int* pointerOperand = &numbers[0]) { int* result = pointerOperand + 1; // Points to numbers[1] (20) } } ``` **Mechanics:** * The pointer type `T*` must be an unmanaged type, and the offset must be of type `int`, `uint`, `long`, or `ulong`. * Adding an integer `n` to a pointer `P` of type `T*` yields a new pointer positioned `n * sizeof(T)` bytes after `P`. ## String Concatenation If at least one operand in a binary `+` operation is of type `string`, the operator functions as a string concatenator. The non-string operand must be of a type that can be implicitly converted to `object` or `string`. ```csharp theme={"dark"} string stringOperand = "Value: "; int intOperand = 42; string result = stringOperand + intOperand; // result is "Value: 42" ``` **Mechanics:** * The compiler translates the `+` operation into a call to `System.String.Concat()`. * Modern C# compilers (Roslyn) optimize concatenation with value types by directly calling `.ToString()` on the value type and emitting a call to `String.Concat(string, string)`. This specifically avoids the performance penalty of boxing allocations that occurred in older .NET framework versions. * If an operand is `null`, it is treated as an empty string (`String.Empty`) rather than throwing a `NullReferenceException`. * **Type Restrictions:** Pointer types (`T*`) and `ref struct` types (such as `Span`) cannot be implicitly converted to `object` or `string`. Attempting to use them as operands in a `+` string concatenation operation will result in a compilation error. ## Delegate Combination When both operands are of the same delegate type, the `+` operator combines them into a new multicast delegate. ```csharp theme={"dark"} System.Action delegate1 = () => System.Console.Write("A"); System.Action delegate2 = () => System.Console.Write("B"); System.Action combinedDelegate = delegate1 + delegate2; // Invoking combinedDelegate() outputs "AB" ``` **Mechanics:** * The compiler translates this operation into a call to `System.Delegate.Combine(delegate1, delegate2)`. * The resulting multicast delegate contains the invocation lists of both operands in sequential order. * If either operand is `null`, the operator returns the non-null operand. If both are `null`, it returns `null`. ## Operator Overloading Custom `class` and `struct` types can redefine the behavior of the `+` operator by declaring a `public static` method using the `operator` keyword. ```csharp theme={"dark"} public struct Vector2 { public int X { get; } public int Y { get; } public Vector2(int x, int y) { X = x; Y = y; } // Binary addition overload public static Vector2 operator +(Vector2 a, Vector2 b) { return new Vector2(a.X + b.X, a.Y + b.Y); } // Unary identity overload public static Vector2 operator +(Vector2 a) { return new Vector2(+a.X, +a.Y); } } ``` **Mechanics:** * At least one of the parameters in the overload signature must be of the containing type. * The method must return a value matching the specified return type. * Overloading the binary `+` operator implicitly overloads the `+=` compound assignment operator. C# does not allow `+=` to be overloaded directly.
Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More