In this article i am going to explain what is Unary operator and how to use it.

Unary operators:

The following rules apply to unary operator declarations, where T denotes the instance type of the class or struct that contains the operator declaration:

A unary +, -, !, or ~ operator must take a single parameter of type T or T? and can return any type.

A unary ++ or -- operator must take a single parameter of type T or T? and must return that same type or a type derived from it.

A unary true or false operator must take a single parameter of type T or T? and must return type bool.

The signature of a unary operator consists of the operator token (+, -, !, ~, ++, --, true, or false) and the type of the single formal parameter. The return type is not part of a unary operator’s signature, nor is the name of the formal parameter.

The true and false unary operators require pair-wise declaration. A compile-time error occurs if a class declares one of these operators without also declaring the other.

The following example shows an implementation and subsequent usage of operator ++ for an integer vector class:

public class IntVector
{
    public IntVector(int length) {...}
    public int Length {...} // read-only property
    public int this[int index] {...} // read-write indexer

    public static IntVector operator ++(IntVector iv) 
    {
        IntVector temp = new IntVector(iv.Length);
        for (int i = 0; i < iv.Length; i++)
        temp[i] = iv[i] + 1;
        return temp;
    }
}

class Test
{
    static void Main()
    {
        IntVector iv1 = new IntVector(4); // vector of 4 x 0
        IntVector iv2;
        iv2 = iv1++; // iv2 contains 4 x 0, iv1 contains 4 x 1
        iv2 = ++iv1; // iv2 contains 4 x 2, iv1 contains 4 x 2
    }
}

Note how the operator method returns the value produced by adding 1 to the operand, just like the  postfix increment and decrement operators, and the prefix increment and decrement operators.

Unlike in C++, this method need not modify the value of its operand directly. In fact, modifying the operand value would violate the standard semantics of the postfix increment operator.