14.7.4 Addition 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 addition operators are listed below. For numeric and
　　enumeration types, the predefined
　　addition operators compute the sum of the two operands. When one or both
　　operands are of type string,
　　the predefined addition operators concatenate the string representation of
　　the operands.
　　?Integer addition:
　　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 sum 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 addition:
　　float operator +(float x, float y);
　　double operator +(double x, double y);
　　The sum 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 NaN?s. In the table, x
　　and y are nonzero finite values, and z is the result of x + y. If x and y
　　have the same magnitude but
　　opposite signs, 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  +8  NaN NaN
　　-8  -8  -8  -8  NaN -8  NaN
　　NaN NaN NaN NaN NaN NaN NaN
　　
　　?Decimal addition:
　　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 addition is equivalent to using the addition operator of type
　　System.Decimal.
　　?Enumeration addition. Every enumeration type implicitly provides the
　　following predefined operators,
　　where E is the enum type, and U is the underlying type of E:
　　E operator +(E x, U y);
　　E operator +(U x, E y);
　　The operators are evaluated exactly as (E)((U)x + (U)y).
　　?String concatenation:
　　string operator +(string x, string y);
　　string operator +(string x, object y);
　　string operator +(object x, string y);
　　The binary + operator performs string concatenation when one or both
　　operands are of type string. If
　　an operand of string concatenation is null, an empty string is substituted.
　　Otherwise, any non-string
　　argument is converted to its string representation by invoking the virtual
　　ToString method inherited
　　from type object. If ToString returns null, an empty string is substituted.
　　[Example:
　　using System;
　　class Test
　　{
　　static void Main() {
　　string s = null;
　　Console.WriteLine("s = >" + s + "<"); // displays s = ><
　　int i = 1;
　　Console.WriteLine("i = " + i); // displays i = 1
　　float f = 1.2300E+15F;
　　Console.WriteLine("f = " + f); // displays f = 1.23E+15
　　decimal d = 2.900m;
　　Console.WriteLine("d = " + d); // displays d = 2.900
　　}
　　}
　　end example]
　　The result of the string concatenation operator is a string that consists
　　of the characters of the left
　　operand followed by the characters of the right operand. The string
　　concatenation operator never returns
　　a null value. A System.OutOfMemoryException may be thrown if there is not
　　enough memory
　　available to allocate the resulting string.
　　?Delegate combination. 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 combination 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,
　　Chapter 14 EXPressions
　　161
　　the result of the operation is the value of the second operand (even if
　　that is also null). Otherwise, if the
　　second operand is null, then the result of the operation is the value of
　　the first operand. Otherwise, the
　　result of the operation is a new delegate instance that, when invoked,
　　invokes the first operand and then
　　invokes the second operand. [Note: For examples of delegate combination,
　　see ?4.7.5 and ?2.3. Since
　　System.Delegate is not a delegate type, operator + is not defined for it.
　　end note]