Unary operators in C# are operators that operate on a single operand to perform operations like incrementing, decrementing, negating, or inverting values. They allow you to perform various operations without the need for multiple operands. Here's a detailed explanation of the unary operators available in C#, along with examples for each.

1. Unary Operators Overview

2. Detailed Explanation

Unary Plus (+)

The unary plus operator is used to indicate a positive value. It is often used for clarity, especially when dealing with negative values, but it does not change the value of the operand.

Example:

int a = 5;
int b = +a; // b is 5

Unary Minus (-)

The unary minus operator negates the value of its operand, changing its sign from positive to negative or vice versa.

Example:

int a = 5;
int b = -a; // b is -5

Increment (++)

The increment operator increases the value of its operand by 1. It can be used in two forms:

• Prefix Increment (++a): Increments a and then returns the new value.
• Postfix Increment (a++): Returns the current value of a and then increments it.

Example:

int a = 5;
int b = ++a; // a is now 6, b is 6 (prefix)
int c = a++; // a is now 7, c is 6 (postfix)

Decrement (--)

The decrement operator decreases the value of its operand by 1. Similar to increment, it can also be used in two forms:

• Prefix Decrement (--a): Decrements a and then returns the new value.
• Postfix Decrement (a--): Returns the current value of a and then decrements it.

Example:

int a = 5;
int b = --a; // a is now 4, b is 4 (prefix)
int c = a--; // a is now 3, c is 4 (postfix)

Logical NOT (!)

The logical NOT operator inverts the value of a boolean expression. If the expression is true, it becomes false, and vice versa.

Example:

bool condition = true;
bool result = !condition; // result is false

Bitwise NOT (~)

The bitwise NOT operator inverts each bit of its operand. This operator is typically used with integer types, flipping 0 to 1 and 1 to 0.

Example:

int a = 5;  // Binary: 0101
int result = ~a; // result is -6 (Binary: 1010 in two's complement representation)

3. Using Unary Operators in C#

Unary operators simplify code and allow for efficient manipulation of values. Here’s an example demonstrating how to use various unary operators:

using System;

class Program
{
    static void Main()
    {
        int a = 5;

        // Unary Plus
        int b = +a; // b is 5
        Console.WriteLine($"Unary Plus: {b}");

        // Unary Minus
        int c = -a; // c is -5
        Console.WriteLine($"Unary Minus: {c}");

        // Increment
        int d = ++a; // a is now 6, d is 6 (prefix)
        Console.WriteLine($"Prefix Increment: {d}");

        int e = a++; // a is now 7, e is 6 (postfix)
        Console.WriteLine($"Postfix Increment: {e}");

        // Decrement
        int f = --a; // a is now 6, f is 6 (prefix)
        Console.WriteLine($"Prefix Decrement: {f}");

        int g = a--; // a is now 5, g is 6 (postfix)
        Console.WriteLine($"Postfix Decrement: {g}");

        // Logical NOT
        bool condition = true;
        bool result = !condition; // result is false
        Console.WriteLine($"Logical NOT: {result}");

        // Bitwise NOT
        int h = 5; // Binary: 0101
        int bitwiseResult = ~h; // bitwiseResult is -6 (Binary: 1010)
        Console.WriteLine($"Bitwise NOT: {bitwiseResult}");
    }
}

4. Summary

• Unary operators in C# operate on a single operand, allowing you to perform various operations like incrementing, decrementing, negating, or inverting values.
• The main unary operators include + (Unary Plus), - (Unary Minus), ++ (Increment), -- (Decrement), ! (Logical NOT), and ~ (Bitwise NOT).
• These operators help simplify code and make it more readable by reducing the number of lines needed to perform operations on single values.
• Understanding how to use unary operators effectively is essential for writing clear and efficient C# programs.