- •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
Annex A Grammar
1
2
3
4
5
6
7
expression: conditional-expression assignment
constant-expression: expression
boolean-expression: expression
8A.2.5 Statements
9statement:
10 |
labeled-statement |
11 |
declaration-statement |
12 |
embedded-statement |
13 |
embedded-statement: |
14 |
block |
15 |
empty-statement |
16 |
expression-statement |
17 |
selection-statement |
18 |
iteration-statement |
19 |
jump-statement |
20 |
try-statement |
21 |
checked-statement |
22 |
unchecked-statement |
23 |
lock-statement |
24 |
using-statement |
25 |
yield-statement |
26 block:
27{ statement-listopt }
28statement-list:
29 |
statement |
30 |
statement-list statement |
31 empty-statement:
32;
33labeled-statement:
34 |
identifier : statement |
35 |
declaration-statement: |
36 |
local-variable-declaration ; |
37 |
local-constant-declaration ; |
38 |
local-variable-declaration: |
39 |
type local-variable-declarators |
40 |
local-variable-declarators: |
41 |
local-variable-declarator |
42 |
local-variable-declarators , local-variable-declarator |
43 |
local-variable-declarator: |
44 |
identifier |
45 |
identifier = local-variable-initializer |
46 |
local-variable-initializer: |
47 |
expression |
48 |
array-initializer |
445
|
C# LANGUAGE SPECIFICATION |
|
1 |
local-constant-declaration: |
|
2 |
const type constant-declarators |
|
3 |
constant-declarators: |
|
4 |
constant-declarator |
|
5 |
constant-declarators , constant-declarator |
|
6 |
constant-declarator: |
|
7 |
identifier = constant-expression |
|
8 |
expression-statement: |
|
9 |
statement-expression ; |
|
10 |
statement-expression: |
|
11 |
invocation-expression |
|
12 |
object-creation-expression |
|
13 |
assignment |
|
14 |
post-increment-expression |
|
15 |
post-decrement-expression |
|
16 |
pre-increment-expression |
|
17 |
pre-decrement-expression |
|
18 |
selection-statement: |
|
19 |
if-statement |
|
20 |
switch-statement |
|
21 |
if-statement: |
|
22 |
if ( boolean-expression |
) embedded-statement |
23 |
if ( boolean-expression ) embedded-statement else embedded-statement |
|
24 |
boolean-expression: |
|
25 |
expression |
|
26 |
switch-statement: |
|
27 |
switch ( expression ) |
switch-block |
28 switch-block:
29{ switch-sectionsopt }
30switch-sections:
31 |
switch-section |
32 |
switch-sections switch-section |
33 |
switch-section: |
34 |
switch-labels statement-list |
35 |
switch-labels: |
36 |
switch-label |
37 |
switch-labels switch-label |
38 |
switch-label: |
39 |
case constant-expression : |
40default :
41iteration-statement:
42 |
while-statement |
43 |
do-statement |
44 |
for-statement |
45 |
foreach-statement |
46 |
while-statement: |
47 |
while ( boolean-expression ) embedded-statement |
446
|
|
|
Annex A Grammar |
1 |
do-statement: |
|
|
2 |
do embedded-statement while |
( boolean-expression ) |
; |
3 |
for-statement: |
|
|
4 |
for ( for-initializeropt ; for-conditionopt ; for-iteratoropt |
) embedded-statement |
|
5 |
for-initializer: |
|
|
6 |
local-variable-declaration |
|
|
7 |
statement-expression-list |
|
|
8 |
for-condition: |
|
|
9 |
boolean-expression |
|
|
10 |
for-iterator: |
|
|
11 |
statement-expression-list |
|
|
12 |
statement-expression-list: |
|
|
13 |
statement-expression |
|
|
14 |
statement-expression-list , statement-expression |
|
|
15 |
foreach-statement: |
|
|
16 |
foreach ( type identifier in |
expression ) embedded-statement |
|
17 |
jump-statement: |
|
|
18 |
break-statement |
|
|
19 |
continue-statement |
|
|
20 |
goto-statement |
|
|
21 |
return-statement |
|
|
22 |
throw-statement |
|
|
23 break-statement:
24break ;
25continue-statement:
26continue ;
27goto-statement:
28 |
goto |
identifier ; |
29 |
goto |
case constant-expression ; |
30goto default ;
31return-statement:
32return expressionopt ;
33throw-statement:
34throw expressionopt ;
35try-statement:
36 |
try block catch-clauses |
37 |
try block finally-clause |
38 |
try block catch-clauses finally-clause |
39 |
catch-clauses: |
40 |
specific-catch-clauses general-catch-clauseopt |
41 |
specific-catch-clausesopt general-catch-clause |
42 |
specific-catch-clauses: |
43 |
specific-catch-clause |
44 |
specific-catch-clauses specific-catch-clause |
45 |
specific-catch-clause: |
46 |
catch ( class-type identifieropt ) block |
447
C# LANGUAGE SPECIFICATION
1 general-catch-clause:
2catch block
3finally-clause:
4finally block
5checked-statement:
6checked block
7unchecked-statement:
8unchecked block
9lock-statement:
10 |
lock ( expression ) embedded-statement |
|
11 |
using-statement: |
|
12 |
using |
( resource-acquisition ) embedded-statement |
13 |
yield-statement: |
|
14 |
yield |
return expression ; |
15yield break ;
16resource-acquisition:
17 |
local-variable-declaration |
||
18 |
expression |
|
|
19 |
namespace-declaration: |
||
20 |
namespace qualified-identifier namespace-body ;opt |
||
21 |
qualified-identifier: |
|
|
22 |
identifier |
|
|
23 |
qualified-identifier . identifier |
||
24 |
namespace-body: |
|
|
25 |
{ extern-alias-directivesopt using-directivesopt namespace-member-declarationsopt } |
||
26 |
extern-alias-directives: |
||
27 |
extern-alias-directive |
||
28 |
extern-alias-directives extern-alias-directive |
||
29 |
extern-alias-directive: |
identifier ; |
|
30 |
extern |
alias |
|
31 |
using-directives: |
|
|
32 |
using-directive |
|
|
33 |
using-directives using-directive |
||
34 |
using-directive: |
|
|
35 |
using-alias-directive |
||
36 |
using-namespace-directive |
||
37 |
using-alias-directive: |
|
|
38 |
using |
identifier |
= namespace-or-type-name ; |
39 using-namespace-directive:
40using namespace-name ;
41namespace-member-declarations:
42 |
namespace-member-declaration |
43 |
namespace-member-declarations namespace-member-declaration |
44 |
namespace-member-declaration: |
45 |
namespace-declaration |
46 |
type-declaration |
448
