C# LANGUAGE SPECIFICATION

1When x is of type int or long, the low-order bits of x are discarded, the remaining bits are shifted

2right, and the high-order empty bit positions are set to zero if x is non-negative and set to one if x is

3negative.

4When x is of type uint or ulong, the low-order bits of x are discarded, the remaining bits are shifted

5right, and the high-order empty bit positions are set to zero.

6For the predefined operators, the number of bits to shift is computed as follows:

7• When the type of x is int or uint, the shift count is given by the low-order five bits of count. In other

8 words, the shift count is computed from count & 0x1F.

9• When the type of x is long or ulong, the shift count is given by the low-order six bits of count. In

10other words, the shift count is computed from count & 0x3F.

11If the resulting shift count is zero, the shift operators simply return the value of x.

12Shift operations never cause overflows and produce the same results in checked and unchecked contexts.

13When the left operand of the >> operator is of a signed integral type, the operator performs an arithmetic

14shift right wherein the value of the most significant bit (the sign bit) of the operand is propagated to the

15high-order empty bit positions. When the left operand of the >> operator is of an unsigned integral type, the

16operator performs a logical shift right wherein high-order empty bit positions are always set to zero. To

17perform the opposite operation of that inferred from the operand type, explicit casts can be used. [Example:

18If x is a variable of type int, the operation unchecked((int)((uint)x >> y)) performs a logical shift

19right of x. end example]

2014.9 Relational and type-testing operators

21The ==, !=, <, >, <=, >=, is and as operators are called the relational and type-testing operators.

22relational-expression:

34The is operator is described in §14.9.9 and the as operator is described in §14.9.10.

35The ==, !=, <, >, <= and >= operators are comparison operators. For an operation of the form x op y, where

36op is a comparison operator, overload resolution (§14.2.4) is applied to select a specific operator

37implementation. The operands are converted to the parameter types of the selected operator, and the type of

38the result is the return type of the operator. If both operands of an equality-expression have the null type

39(and hence the null value as well), then overload resolution is not performed and the expression evaluates

40to a contant value of true or false according to whether the operator is == or !=.

41The predefined comparison operators are described in the following subclauses. All predefined comparison

42operators return a result of type bool, as described in the following table.

43

198

Chapter 14 Expressions

1

214.9.1 Integer comparison operators

3The predefined integer comparison operators are:

4bool operator ==(int x, int y);

5bool operator ==(uint x, uint y);

6bool operator ==(long x, long y);

7bool operator ==(ulong x, ulong y);

8void operator ==(long x, ulong y);

9void operator ==(ulong x, long y);

10bool operator !=(int x, int y);

11bool operator !=(uint x, uint y);

12bool operator !=(long x, long y);

13bool operator !=(ulong x, ulong y);

14void operator !=(long x, ulong y);

15void operator !=(ulong x, long y);

16bool operator <(int x, int y);

17bool operator <(uint x, uint y);

18bool operator <(long x, long y);

19bool operator <(ulong x, ulong y);

20void operator <(long x, ulong y);

21void operator >(ulong x, long y);

22bool operator >(int x, int y);

23bool operator >(uint x, uint y);

24bool operator >(long x, long y);

25bool operator >(ulong x, ulong y);

26void operator >(long x, ulong y);

27void operator >(ulong x, long y);

28bool operator <=(int x, int y);

29bool operator <=(uint x, uint y);

30bool operator <=(long x, long y);

31bool operator <=(ulong x, ulong y);

32void operator <=(long x, ulong y);

33void operator <=(ulong x, long y);

34bool operator >=(int x, int y);

35bool operator >=(uint x, uint y);

36bool operator >=(long x, long y);

37bool operator >=(ulong x, ulong y);

38void operator >=(long x, ulong y);

39void operator >=(ulong x, long y);

40Each of these operators compares the numeric values of the two integer operands and returns a bool

41value that indicates whether the particular relation is true or false. The operators with void return

42type always produce a compile-time error. Consequently, it is an error for one operand to be of type

43long and the other to be of type ulong.

4414.9.2 Floating-point comparison operators

45The predefined floating-point comparison operators are:

199

Chapter 14 Expressions

114.9.5 Enumeration comparison operators

2Every enumeration type implicitly provides the following predefined comparison operators:

3bool operator ==(E x, E y);

4bool operator !=(E x, E y);

5bool operator <(E x, E y);

6bool operator >(E x, E y);

7bool operator <=(E x, E y);

8bool operator >=(E x, E y);

9The result of evaluating x op y, where x and y are expressions of an enumeration type E with an underlying

10type U, and op is one of the comparison operators, is exactly the same as evaluating ((U)x) op ((U)y). In

11other words, the enumeration type comparison operators simply compare the underlying integral values of

12the two operands. These operators are only considered by overload resolution (§14.2.4) when one of the

13actual operands is of type E.

1414.9.6 Reference type equality operators

15Every class type C implicitly provides the following predefined reference type equality operators:

16bool operator ==(C x, C y);

17bool operator !=(C x, C y);

18unless predefined equality operators otherwise exists for C (for example, when C is string or

19System.Delegate).

20The operators return the result of comparing the two references for equality or non-equality.

21There are special rules for determining when a reference type equality operator is applicable. For an

22equality-expression with operands of type A and B, define A0 as follows:

23• If A is a type parameter that does not have the value type constraint (§26.7), let A0 be the effective base

24class of A.

25• Otherwise, if A is an interface type, a delegate type, an array type, a class type, or the null type, let A0

26be the same as A.

27• Otherwise, no reference type equality operator is applicable.

28Now define A1 as follows:

29• If A0 is an interface type, a delegate type, System.Delegate, or string, let A1 be object.

30• Otherwise, if A0 is an array type, let A1 be System.Array.

31• Otherwise, A0 is the null type or a class type and let A1 be the same as A0.

32Define B0 and B1 similarly. Now determine if any reference type equality operators are applicable as follows:

33• If both of the types A and B are the null type, then overload resolution is not performed and the result is

34a constant true or false, as specified in §14.9.

35• Otherwise, if A is the null type, then the reference type equality operator for B1 is applicable. If B is a

36type parameter and at run-time the type parameter is a value type, the result of the comparison is false.

37• Otherwise, if B is the null type, then the reference type equality operator for A1 is applicable. If A is a

38type parameter and at run-time the type parameter is a value type, the result of the comparison is false.

39• Otherwise, if either A or B is a type parameter that is not known to be a reference type (§26.7), then no

40reference type equality operator is applicable.

41• Otherwise, if there is no identity or reference conversion (implicit or explicit) from A0 to B0 or no

42identity or reference conversion (implicit or explicit) from B0 to A0, then no reference type equality

43operator is applicable.

201