14.7.5 Subtraction operator

For an operation of the form x - y, binary operator overload resolution (?4.
2.4) is applied to select a
specific operator implementation. The operands are converted to the
parameter types of the selected
operator, and the type of the result is the return type of the operator.
The predefined subtraction operators are listed below. The operators all
subtract y from x.
?Integer subtraction:
int operator -(int x, int y);
uint operator -(uint x, uint y);
long operator -(long x, long y);
ulong operator -(ulong x, ulong y);
In a checked context, if the difference is outside the range of the result
type, a
System.OverflowException is thrown. In an unchecked context, overflows are
not reported and
any significant high-order bits outside the range of the result type are
discarded.
?Floating-point subtraction:
float operator -(float x, float y);
double operator -(double x, double y);
The difference is computed according to the rules of IEC 60559 arithmetic.
The following table lists the
results of all possible combinations of nonzero finite values, zeros,
infinities, and NaNs. In the table, x
and y are nonzero finite values, and z is the result of x - y. If x and y
are equal, z is positive zero. If
x - y is too large to represent in the destination type, z is an infinity
with the same sign as x - y. If
x - y is too small to represent in the destination type, z is a zero with
the same sign as x - y.

    y   +0  -0  +8  -8  NaN
x   z   x   x   -8  +8  NaN
+0  -y  +0  +0  -8  +8  NaN
-0  -y  -0  +0  -8  +8  NaN
+8  +8  +8  +8  NaN +8  NaN
-8  -8  -8  -8  -8  NaN NaN
NaN NaN NaN NaN NaN NaN NaN

?Decimal subtraction:
decimal operator -(decimal x, decimal y);
If the resulting value is too large to represent in the decimal format, a
System.OverflowException
is thrown. The scale of the result, before any rounding, is the larger of
the scales of the two operands.
Decimal subtraction is equivalent to using the subtraction operator of type
System.Decimal.
?Enumeration subtraction. Every enumeration type implicitly provides the
following predefined operator,
where E is the enum type, and U is the underlying type of E:
U operator -(E x, E y);
This operator is evaluated exactly as (U)((U)x - (U)y). In other words, the
operator computes the
difference between the ordinal values of x and y, and the type of the
result is the underlying type of the
enumeration.
C# LANGUAGE SPECIFICATION
162
E operator -(E x, U y);
This operator is evaluated exactly as (E)((U)x - y). In other words, the
operator subtracts a value
from the underlying type of the enumeration, yielding a value of the
enumeration.
?Delegate removal. Every delegate type implicitly provides the following
predefined operator, where D is
the delegate type:
D operator -(D x, D y);
The binary - operator performs delegate removal when both operands are of
some delegate type D. (If
the operands have different delegate types, a compile-time error occurs.)
If the first operand is null, the
result of the operation is null. Otherwise, if the second operand is null,
then the result of the operation
is the value of the first operand. Otherwise, both operands represent
invocation lists (?2.1) having one
or more entries, and the result is a new invocation list consisting of the
first operand?s list with the
second operand?s entries removed from it, provided the second operand?s
list is a proper contiguous
subset of the first?s. (For determining subset equality, corresponding
entries are compared as for the
delegate equality operator (?4.9.8).) Otherwise, the result is the value
of the left operand. Neither of the
operands? lists is changed in the process. If the second operand?s list
matches multiple subsets of
contiguous entries in the first operand?s list, the right-most matching
subset of contiguous entries is
removed. If removal results in an empty list, the result is null. [Example:
For example:
using System;
delegate void D(int x);
class Test
{
public static void M1(int i) { /* ? */ }
public static void M2(int i) { /* ? */ }
}
class Demo
{
static void Main() {
D cd1 = new D(Test.M1);
D cd2 = new D(Test.M2);
D cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1
cd3 -= cd1; // => M1 + M2 + M2
cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1
cd3 -= cd1 + cd2; // => M2 + M1
cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1
cd3 -= cd2 + cd2; // => M1 + M1
cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1
cd3 -= cd2 + cd1; // => M1 + M2
cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1
cd3 -= cd1 + cd1; // => M1 + M2 + M2 + M1
}
}
end example]