- •Foreword
- •Introduction
- •Scope
- •Conformance
- •Normative references
- •Definitions
- •Notational conventions
- •Acronyms and abbreviations
- •General description
- •Language overview
- •Getting started
- •Types
- •Predefined types
- •Conversions
- •Array types
- •Type system unification
- •Variables and parameters
- •Automatic memory management
- •Expressions
- •Statements
- •Classes
- •Constants
- •Fields
- •Methods
- •Properties
- •Events
- •Operators
- •Indexers
- •Instance constructors
- •Destructors
- •Static constructors
- •Inheritance
- •Static classes
- •Partial type declarations
- •Structs
- •Interfaces
- •Delegates
- •Enums
- •Namespaces and assemblies
- •Versioning
- •Extern Aliases
- •Attributes
- •Generics
- •Why generics?
- •Creating and consuming generics
- •Multiple type parameters
- •Constraints
- •Generic methods
- •Anonymous methods
- •Iterators
- •Lexical structure
- •Programs
- •Grammars
- •Lexical grammar
- •Syntactic grammar
- •Grammar ambiguities
- •Lexical analysis
- •Line terminators
- •Comments
- •White space
- •Tokens
- •Unicode escape sequences
- •Identifiers
- •Keywords
- •Literals
- •Boolean literals
- •Integer literals
- •Real literals
- •Character literals
- •String literals
- •The null literal
- •Operators and punctuators
- •Pre-processing directives
- •Conditional compilation symbols
- •Pre-processing expressions
- •Declaration directives
- •Conditional compilation directives
- •Diagnostic directives
- •Region control
- •Line directives
- •Pragma directives
- •Basic concepts
- •Application startup
- •Application termination
- •Declarations
- •Members
- •Namespace members
- •Struct members
- •Enumeration members
- •Class members
- •Interface members
- •Array members
- •Delegate members
- •Member access
- •Declared accessibility
- •Accessibility domains
- •Protected access for instance members
- •Accessibility constraints
- •Signatures and overloading
- •Scopes
- •Name hiding
- •Hiding through nesting
- •Hiding through inheritance
- •Namespace and type names
- •Unqualified name
- •Fully qualified names
- •Automatic memory management
- •Execution order
- •Types
- •Value types
- •The System.ValueType type
- •Default constructors
- •Struct types
- •Simple types
- •Integral types
- •Floating point types
- •The decimal type
- •The bool type
- •Enumeration types
- •Reference types
- •Class types
- •The object type
- •The string type
- •Interface types
- •Array types
- •Delegate types
- •Boxing and unboxing
- •Boxing conversions
- •Unboxing conversions
- •Variables
- •Variable categories
- •Static variables
- •Instance variables
- •Instance variables in classes
- •Instance variables in structs
- •Array elements
- •Value parameters
- •Reference parameters
- •Output parameters
- •Local variables
- •Default values
- •Definite assignment
- •Initially assigned variables
- •Initially unassigned variables
- •Precise rules for determining definite assignment
- •General rules for statements
- •Block statements, checked, and unchecked statements
- •Expression statements
- •Declaration statements
- •If statements
- •Switch statements
- •While statements
- •Do statements
- •For statements
- •Break, continue, and goto statements
- •Throw statements
- •Return statements
- •Try-catch statements
- •Try-finally statements
- •Try-catch-finally statements
- •Foreach statements
- •Using statements
- •Lock statements
- •General rules for simple expressions
- •General rules for expressions with embedded expressions
- •Invocation expressions and object creation expressions
- •Simple assignment expressions
- •&& expressions
- •|| expressions
- •! expressions
- •?: expressions
- •Anonymous method expressions
- •Yield statements
- •Variable references
- •Atomicity of variable references
- •Conversions
- •Implicit conversions
- •Identity conversion
- •Implicit numeric conversions
- •Implicit enumeration conversions
- •Implicit reference conversions
- •Boxing conversions
- •Implicit type parameter conversions
- •Implicit constant expression conversions
- •User-defined implicit conversions
- •Explicit conversions
- •Explicit numeric conversions
- •Explicit enumeration conversions
- •Explicit reference conversions
- •Unboxing conversions
- •User-defined explicit conversions
- •Standard conversions
- •Standard implicit conversions
- •Standard explicit conversions
- •User-defined conversions
- •Permitted user-defined conversions
- •Evaluation of user-defined conversions
- •User-defined implicit conversions
- •User-defined explicit conversions
- •Anonymous method conversions
- •Method group conversions
- •Expressions
- •Expression classifications
- •Values of expressions
- •Operators
- •Operator precedence and associativity
- •Operator overloading
- •Unary operator overload resolution
- •Binary operator overload resolution
- •Candidate user-defined operators
- •Numeric promotions
- •Unary numeric promotions
- •Binary numeric promotions
- •Member lookup
- •Base types
- •Function members
- •Argument lists
- •Overload resolution
- •Applicable function member
- •Better function member
- •Better conversion
- •Function member invocation
- •Invocations on boxed instances
- •Primary expressions
- •Literals
- •Simple names
- •Invariant meaning in blocks
- •Parenthesized expressions
- •Member access
- •Identical simple names and type names
- •Invocation expressions
- •Method invocations
- •Delegate invocations
- •Element access
- •Array access
- •Indexer access
- •This access
- •Base access
- •Postfix increment and decrement operators
- •The new operator
- •Object creation expressions
- •Array creation expressions
- •Delegate creation expressions
- •The typeof operator
- •The checked and unchecked operators
- •Default value expression
- •Anonymous methods
- •Anonymous method signatures
- •Anonymous method blocks
- •Outer variables
- •Captured outer variables
- •Instantiation of local variables
- •Anonymous method evaluation
- •Implementation example
- •Unary expressions
- •Unary plus operator
- •Unary minus operator
- •Logical negation operator
- •Bitwise complement operator
- •Prefix increment and decrement operators
- •Cast expressions
- •Arithmetic operators
- •Multiplication operator
- •Division operator
- •Remainder operator
- •Addition operator
- •Subtraction operator
- •Shift operators
- •Relational and type-testing operators
- •Integer comparison operators
- •Floating-point comparison operators
- •Decimal comparison operators
- •Boolean equality operators
- •Enumeration comparison operators
- •Reference type equality operators
- •String equality operators
- •Delegate equality operators
- •The is operator
- •The as operator
- •Logical operators
- •Integer logical operators
- •Enumeration logical operators
- •Boolean logical operators
- •Conditional logical operators
- •Boolean conditional logical operators
- •User-defined conditional logical operators
- •Conditional operator
- •Assignment operators
- •Simple assignment
- •Compound assignment
- •Event assignment
- •Expression
- •Constant expressions
- •Boolean expressions
- •Statements
- •End points and reachability
- •Blocks
- •Statement lists
- •The empty statement
- •Labeled statements
- •Declaration statements
- •Local variable declarations
- •Local constant declarations
- •Expression statements
- •Selection statements
- •The if statement
- •The switch statement
- •Iteration statements
- •The while statement
- •The do statement
- •The for statement
- •The foreach statement
- •Jump statements
- •The break statement
- •The continue statement
- •The goto statement
- •The return statement
- •The throw statement
- •The try statement
- •The checked and unchecked statements
- •The lock statement
- •The using statement
- •The yield statement
- •Namespaces
- •Compilation units
- •Namespace declarations
- •Extern alias directives
- •Using directives
- •Using alias directives
- •Using namespace directives
- •Namespace members
- •Type declarations
- •Qualified alias member
- •Classes
- •Class declarations
- •Class modifiers
- •Abstract classes
- •Sealed classes
- •Static classes
- •Class base specification
- •Base classes
- •Interface implementations
- •Class body
- •Partial declarations
- •Class members
- •Inheritance
- •The new modifier
- •Access modifiers
- •Constituent types
- •Static and instance members
- •Nested types
- •Fully qualified name
- •Declared accessibility
- •Hiding
- •this access
- •Reserved member names
- •Member names reserved for properties
- •Member names reserved for events
- •Member names reserved for indexers
- •Member names reserved for destructors
- •Constants
- •Fields
- •Static and instance fields
- •Readonly fields
- •Using static readonly fields for constants
- •Versioning of constants and static readonly fields
- •Volatile fields
- •Field initialization
- •Variable initializers
- •Static field initialization
- •Instance field initialization
- •Methods
- •Method parameters
- •Value parameters
- •Reference parameters
- •Output parameters
- •Parameter arrays
- •Static and instance methods
- •Virtual methods
- •Override methods
- •Sealed methods
- •Abstract methods
- •External methods
- •Method body
- •Method overloading
- •Properties
- •Static and instance properties
- •Accessors
- •Virtual, sealed, override, and abstract accessors
- •Events
- •Field-like events
- •Event accessors
- •Static and instance events
- •Virtual, sealed, override, and abstract accessors
- •Indexers
- •Indexer overloading
- •Operators
- •Unary operators
- •Binary operators
- •Conversion operators
- •Instance constructors
- •Constructor initializers
- •Instance variable initializers
- •Constructor execution
- •Default constructors
- •Private constructors
- •Optional instance constructor parameters
- •Static constructors
- •Destructors
- •Structs
- •Struct declarations
- •Struct modifiers
- •Struct interfaces
- •Struct body
- •Struct members
- •Class and struct differences
- •Value semantics
- •Inheritance
- •Assignment
- •Default values
- •Boxing and unboxing
- •Meaning of this
- •Field initializers
- •Constructors
- •Destructors
- •Static constructors
- •Struct examples
- •Database integer type
- •Database boolean type
- •Arrays
- •Array types
- •The System.Array type
- •Array creation
- •Array element access
- •Array members
- •Array covariance
- •Arrays and the generic IList interface
- •Array initializers
- •Interfaces
- •Interface declarations
- •Interface modifiers
- •Base interfaces
- •Interface body
- •Interface members
- •Interface methods
- •Interface properties
- •Interface events
- •Interface indexers
- •Interface member access
- •Fully qualified interface member names
- •Interface implementations
- •Explicit interface member implementations
- •Interface mapping
- •Interface implementation inheritance
- •Interface re-implementation
- •Abstract classes and interfaces
- •Enums
- •Enum declarations
- •Enum modifiers
- •Enum members
- •The System.Enum type
- •Enum values and operations
- •Delegates
- •Delegate declarations
- •Delegate instantiation
- •Delegate invocation
- •Exceptions
- •Causes of exceptions
- •The System.Exception class
- •How exceptions are handled
- •Common Exception Classes
- •Attributes
- •Attribute classes
- •Attribute usage
- •Positional and named parameters
- •Attribute parameter types
- •Attribute specification
- •Attribute instances
- •Compilation of an attribute
- •Run-time retrieval of an attribute instance
- •Reserved attributes
- •The AttributeUsage attribute
- •The Conditional attribute
- •Conditional Methods
- •Conditional Attribute Classes
- •The Obsolete attribute
- •Unsafe code
- •Unsafe contexts
- •Pointer types
- •Fixed and moveable variables
- •Pointer conversions
- •Pointers in expressions
- •Pointer indirection
- •Pointer member access
- •Pointer element access
- •The address-of operator
- •Pointer increment and decrement
- •Pointer arithmetic
- •Pointer comparison
- •The sizeof operator
- •The fixed statement
- •Stack allocation
- •Dynamic memory allocation
- •Generics
- •Generic class declarations
- •Type parameters
- •The instance type
- •Members of generic classes
- •Static fields in generic classes
- •Static constructors in generic classes
- •Accessing protected members
- •Overloading in generic classes
- •Parameter array methods and type parameters
- •Overriding and generic classes
- •Operators in generic classes
- •Nested types in generic classes
- •Generic struct declarations
- •Generic interface declarations
- •Uniqueness of implemented interfaces
- •Explicit interface member implementations
- •Generic delegate declarations
- •Constructed types
- •Type arguments
- •Open and closed types
- •Base classes and interfaces of a constructed type
- •Members of a constructed type
- •Accessibility of a constructed type
- •Conversions
- •Using alias directives
- •Generic methods
- •Generic method signatures
- •Virtual generic methods
- •Calling generic methods
- •Inference of type arguments
- •Using a generic method with a delegate
- •Constraints
- •Satisfying constraints
- •Member lookup on type parameters
- •Type parameters and boxing
- •Conversions involving type parameters
- •Iterators
- •Iterator blocks
- •Enumerator interfaces
- •Enumerable interfaces
- •Yield type
- •This access
- •Enumerator objects
- •The MoveNext method
- •The Current property
- •The Dispose method
- •Enumerable objects
- •The GetEnumerator method
- •Implementation example
- •Lexical grammar
- •Line terminators
- •White space
- •Comments
- •Unicode character escape sequences
- •Identifiers
- •Keywords
- •Literals
- •Operators and punctuators
- •Pre-processing directives
- •Syntactic grammar
- •Basic concepts
- •Types
- •Expressions
- •Statements
- •Classes
- •Structs
- •Arrays
- •Interfaces
- •Enums
- •Delegates
- •Attributes
- •Generics
- •Grammar extensions for unsafe code
- •Undefined behavior
- •Implementation-defined behavior
- •Unspecified behavior
- •Other Issues
- •Capitalization styles
- •Pascal casing
- •Camel casing
- •All uppercase
- •Capitalization summary
- •Word choice
- •Namespaces
- •Classes
- •Interfaces
- •Enums
- •Static fields
- •Parameters
- •Methods
- •Properties
- •Events
- •Case sensitivity
- •Avoiding type name confusion
- •Documentation Comments
- •Introduction
- •Recommended tags
- •<code>
- •<example>
- •<exception>
- •<list>
- •<para>
- •<param>
- •<paramref>
- •<permission>
- •<remarks>
- •<returns>
- •<seealso>
- •<summary>
- •<value>
- •Processing the documentation file
- •ID string format
- •ID string examples
- •An example
- •C# source code
- •Resulting XML
Chapter 14 Expressions
1class Test
2{
3 |
void F() { |
4 |
__Locals1 __locals1 = new __Locals1(); |
5 |
__locals1.__this = this; |
6 |
__locals1.y = 123; |
7 |
for (int i = 0; i < 10; i++) { |
8 |
__Locals2 __locals2 = new __Locals2(); |
9 |
__locals2.__locals1 = __locals1; |
10 |
__locals2.z = i * 2; |
11 |
D d = new D(__locals2.__Method1); |
12 |
} |
13 |
} |
14 |
class __Locals1 |
15 |
{ |
16 |
public Test __this; |
17 |
public int y; |
18 |
} |
19 |
class __Locals2 |
20 |
{ |
21 |
public __Locals1 __locals1; |
22 |
public int z; |
23 |
public void __Method1() { |
24 |
Console.WriteLine(__locals1.__this.x + __locals1.y + z); |
25 |
} |
26}
27}
28end note]
2914.6 Unary expressions
30unary-expression:
31 |
primary-expression |
|
32 |
+ |
unary-expression |
33 |
- |
unary-expression |
34 |
! |
unary-expression |
35 |
~ |
unary-expression |
36 |
pre-increment-expression |
|
37 |
pre-decrement-expression |
|
38 |
cast-expression |
|
3914.6.1 Unary plus operator
40For an operation of the form +x, unary operator overload resolution (§14.2.3) is applied to select a specific
41operator implementation. The operand is converted to the parameter type of the selected operator, and the
42type of the result is the return type of the operator. The predefined unary plus operators are:
43int operator +(int x);
44uint operator +(uint x);
45long operator +(long x);
46ulong operator +(ulong x);
47float operator +(float x);
48double operator +(double x);
49decimal operator +(decimal x);
50For each of these operators, the result is simply the value of the operand.
5114.6.2 Unary minus operator
52For an operation of the form –x, unary operator overload resolution (§14.2.3) is applied to select a specific
53operator implementation. The operand is converted to the parameter type of the selected operator, and the
54type of the result is the return type of the operator. The predefined negation operators are:
187
C# LANGUAGE SPECIFICATION
1• Integer negation:
2int operator –(int x);
3long operator –(long x);
4The result is computed by subtracting x from zero. In a checked context, if the value of x is the
5smallest int or long (−231 or −263, respectively), a System.OverflowException is thrown. In an
6unchecked context, if the value of x is the smallest int or long, the result is that same value and the
7overflow is not reported.
8If the operand of the negation operator is of type uint, it is converted to type long, and the type of the
9result is long. An exception is the rule that permits the int value −2147483648 (−231) to be written as a
10decimal integer literal (§9.4.4.2).
11• Negation of ulong is an error:
12void operator –(ulong x);
13Selection of this operator by unary operator overload resolution (§14.2.3) always results in a compile-
14time error. Consequently, if the operand of the negation operator is of type ulong, a compile-time error
15occurs. An exception is the rule that permits the long value −9223372036854775808 (−263) to be
16written as a decimal integer literal (§9.4.4.2).
17• Floating-point negation:
18float operator –(float x);
19double operator –(double x);
20The result is the value of x with its sign inverted. If x is NaN, the result is also NaN.
21• Decimal negation:
22decimal operator –(decimal x);
23The result is computed by subtracting x from zero.
24Decimal negation is equivalent to using the unary minus operator of type System.Decimal.
2514.6.3 Logical negation operator
26For an operation of the form !x, unary operator overload resolution (§14.2.3) is applied to select a specific
27operator implementation. The operand is converted to the parameter type of the selected operator, and the
28type of the result is the return type of the operator. Only one predefined logical negation operator exists:
29bool operator !(bool x);
30This operator computes the logical negation of the operand: If the operand is true, the result is false. If
31the operand is false, the result is true.
3214.6.4 Bitwise complement operator
33For an operation of the form ~x, unary operator overload resolution (§14.2.3) is applied to select a specific
34operator implementation. The operand is converted to the parameter type of the selected operator, and the
35type of the result is the return type of the operator. The predefined bitwise complement operators are:
36int operator ~(int x);
37uint operator ~(uint x);
38long operator ~(long x);
39ulong operator ~(ulong x);
40For each of these operators, the result of the operation is the bitwise complement of x.
41Every enumeration type E implicitly provides the following bitwise complement operator:
42E operator ~(E x);
43The result of evaluating ~x, where x is an expression of an enumeration type E with an underlying type U, is
44exactly the same as evaluating unchecked((E)(~(U)x)). This operator is only considered by unary
45operator overload resolution when the operand type is the enum type E (§14.2.3).
188
Chapter 14 Expressions
114.6.5 Prefix increment and decrement operators
2pre-increment-expression:
3++ unary-expression
4pre-decrement-expression:
5-- unary-expression
6The operand of a prefix increment or decrement operation shall be an expression classified as a variable, a
7property access, or an indexer access. The result of the operation is a value of the same type as the operand.
8If the operand of a prefix increment or decrement operation is a property or indexer access, the property or
9indexer shall have both a get and a set accessor. If this is not the case, a compile-time error occurs.
10Unary operator overload resolution (§14.2.3) is applied to select a specific operator implementation.
11Predefined ++ and -- operators exist for the following operand types: sbyte, byte, short, ushort, int,
12uint, long, ulong, char, float, double, decimal, and any enum type. The result type of each of these
13predefined operators is the same as the operand type. The predefined ++ operators return the value produced
14by adding 1 to the operand, and the predefined -- operators return the value produced by subtracting 1 from
15the operand. In a checked context, if the result of this addition or subtraction is outside the range of the
16result type, a System.OverflowException is thrown.
17There shall be an implicit conversion from the return type of the selected unary operator to the type of the
18primary-expression, otherwise a compile-time error occurs.
19The run-time processing of a prefix increment or decrement operation of the form ++x or --x consists of the
20following steps:
21• If x is classified as a variable:
22o x is evaluated to produce the variable.
23o The value of x is converted to the operand type of the selected operator and the operator is invoked
24with this value as its argument.
25o The value returned by the operator is converted to the type of x. The resulting value is stored in the
26location given by the evaluation of x and becomes the result of the operation.
27• If x is classified as a property or indexer access:
28o The instance expression (if x is not static) and the argument list (if x is an indexer access)
29associated with x are evaluated, and the results are used in the subsequent get and set accessor
30invocations.
31o The get accessor of x is invoked.
32o The value returned by the get accessor is converted to the operand type of the selected operator and
33operator is invoked with this value as its argument.
34o The value returned by the operator is converted to the type of x. The set accessor of x is invoked
35with this value as its value argument. This value also becomes the result of the operation.
36The ++ and -- operators also support postfix notation (§14.5.9). The result of x++ or x-- is the value of x
37before the operation, whereas the result of ++x or --x is the value of x after the operation. In either case, x
38itself has the same value after the operation.
39An operator ++ or operator -- implementation can be invoked using either postfix or prefix notation.
40It is not possible to have separate operator implementations for the two notations.
4114.6.6 Cast expressions
42A cast-expression is used to explicitly convert an expression to a given type.
43cast-expression:
44 |
( type ) unary-expression |
189