- •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
type-declaration: class-declaration struct-declaration interface-declaration enum-declaration delegate-declaration
7A.2.6 Classes
8class-declaration:
9 |
attributesopt class-modifiersopt partialopt class identifier type-parameter-listopt |
10 |
class-baseopt type-parameter-constraints-clausesopt class-body ;opt |
11 |
class-modifiers: |
12 |
class-modifier |
13 |
class-modifiers class-modifier |
14 |
class-modifier: |
15 |
new |
16 |
public |
17 |
protected |
18 |
internal |
19 |
private |
20 |
abstract |
21 |
sealed |
22static
23class-base:
24 |
: |
class-type |
25 |
: |
interface-type-list |
26: class-type , interface-type-list
27interface-type-list:
28 |
interface-type |
29 |
interface-type-list , interface-type |
30 class-body:
31{ class-member-declarationsopt }
32class-member-declarations:
33 |
class-member-declaration |
34 |
class-member-declarations class-member-declaration |
35 |
class-member-declaration: |
36 |
constant-declaration |
37 |
field-declaration |
38 |
method-declaration |
39 |
property-declaration |
40 |
event-declaration |
41 |
indexer-declaration |
42 |
operator-declaration |
43 |
constructor-declaration |
44 |
destructor-declaration |
45 |
static-constructor-declaration |
46 |
type-declaration |
47 |
constant-declaration: |
48 |
attributesopt constant-modifiersopt const type constant-declarators ; |
449
|
C# LANGUAGE SPECIFICATION |
1 |
constant-modifiers: |
2 |
constant-modifier |
3 |
constant-modifiers constant-modifier |
4 |
constant-modifier: |
5 |
new |
6 |
public |
7 |
protected |
8 |
internal |
9private
10constant-declarators:
11 |
constant-declarator |
12 |
constant-declarators , constant-declarator |
13 |
constant-declarator: |
14 |
identifier = constant-expression |
15 |
field-declaration: |
16 |
attributesopt field-modifiersopt type variable-declarators ; |
17 |
field-modifiers: |
18 |
field-modifier |
19 |
field-modifiers field-modifier |
20 |
field-modifier: |
21 |
new |
22 |
public |
23 |
protected |
24 |
internal |
25 |
private |
26 |
static |
27 |
readonly |
28volatile
29variable-declarators:
30 |
variable-declarator |
|
31 |
variable-declarators , variable-declarator |
|
32 |
variable-declarator: |
|
33 |
identifier |
|
34 |
identifier = variable-initializer |
|
35 |
variable-initializer: |
|
36 |
expression |
|
37 |
array-initializer |
|
38 |
method-declaration: |
|
39 |
method-header method-body |
|
40 |
method-header: |
|
41 |
attributesopt method-modifiersopt return-type member-name |
type-parameter-listopt |
42 |
( formal-parameter-listopt ) type-parameter-constraints-clausesopt |
|
43 |
method-modifiers: |
|
44 |
method-modifier |
|
45 |
method-modifiers method-modifier |
|
450
Annex A Grammar
1 |
method-modifier: |
2 |
new |
3 |
public |
4 |
protected |
5 |
internal |
6 |
private |
7 |
static |
8 |
virtual |
9 |
sealed |
10 |
override |
11 |
abstract |
12extern
13return-type:
14 |
type |
15void
16member-name:
17 |
identifier |
18 |
interface-type . identifier |
19 |
method-body: |
20 |
block |
21;
22formal-parameter-list:
23 |
fixed-parameters |
24 |
fixed-parameters , parameter-array |
25 |
parameter-array |
26 |
fixed-parameters: |
27 |
fixed-parameter |
28 |
fixed-parameters , fixed-parameter |
29 |
fixed-parameter: |
30 |
attributesopt parameter-modifieropt type identifier |
31 |
parameter-modifier: |
32 |
ref |
33out
34parameter-array:
35 |
attributesopt params array-type identifier |
36 |
property-declaration: |
37 |
attributesopt property-modifiersopt type member-name { accessor-declarations } |
38 |
property-modifiers: |
39 |
property-modifier |
40 |
property-modifiers property-modifier |
451
|
C# LANGUAGE SPECIFICATION |
1 |
property-modifier: |
2 |
new |
3 |
public |
4 |
protected |
5 |
internal |
6 |
private |
7 |
static |
8 |
virtual |
9 |
sealed |
10 |
override |
11 |
abstract |
12extern
13member-name:
14 |
identifier |
|
|
15 |
interface-type . identifier |
|
|
16 |
accessor-declarations: |
|
|
17 |
get-accessor-declaration set-accessor-declarationopt |
||
18 |
set-accessor-declaration get-accessor-declarationopt |
||
19 |
get-accessor-declaration: |
|
|
20 |
attributesopt accessor-modifieropt |
get |
accessor-body |
21 |
set-accessor-declaration: |
|
|
22 |
attributesopt accessor-modifieropt |
set |
accessor-body |
23 |
accessor-modifier: |
|
|
24 |
protected |
|
|
25 |
internal |
|
|
26 |
private |
|
|
27 |
protected internal |
|
|
28internal protected
29accessor-body:
30 |
block |
31;
32event-declaration:
33 |
attributesopt |
event-modifiersopt |
event |
type |
variable-declarators ; |
34 |
attributesopt |
event-modifiersopt |
event |
type |
member-name { event-accessor-declarations |
35}
36event-modifiers:
37 |
event-modifier |
38 |
event-modifiers event-modifier |
39 |
event-modifier: |
40 |
new |
41 |
public |
42 |
protected |
43 |
internal |
44 |
private |
45 |
static |
46 |
virtual |
47 |
sealed |
48 |
override |
49 |
abstract |
50 |
extern |
452
|
Annex A Grammar |
1 |
event-accessor-declarations: |
2 |
add-accessor-declaration remove-accessor-declaration |
3 |
remove-accessor-declaration add-accessor-declaration |
4 |
add-accessor-declaration: |
5 |
attributesopt add block |
6 |
remove-accessor-declaration: |
7 |
attributesopt remove block |
8 |
indexer-declaration: |
9 |
attributesopt indexer-modifiersopt indexer-declarator { accessor-declarations } |
10 |
indexer-modifiers: |
11 |
indexer-modifier |
12 |
indexer-modifiers indexer-modifier |
13 |
indexer-modifier: |
14 |
new |
15 |
public |
16 |
protected |
17 |
internal |
18 |
private |
19 |
virtual |
20 |
sealed |
21 |
override |
22 |
abstract |
23extern
24indexer-declarator:
25 |
type this [ formal-parameter-list ] |
26 |
type interface-type . this [ formal-parameter-list ] |
27 |
operator-declaration: |
28 |
attributesopt operator-modifiers operator-declarator operator-body |
29 |
operator-modifiers: |
30 |
operator-modifier |
31 |
operator-modifiers operator-modifier |
32 |
operator-modifier: |
33 |
public |
34 |
static |
35extern
36operator-declarator:
37 |
unary-operator-declarator |
|
|
|
|
|
|
|
||||
38 |
binary-operator-declarator |
|
|
|
|
|
|
|
||||
39 |
conversion-operator-declarator |
|
|
|
|
|
|
|||||
40 |
unary-operator-declarator: |
|
|
|
|
|
|
|
||||
41 |
type operator overloadable-unary-operator ( type identifier ) |
|
|
|
||||||||
42 |
overloadable-unary-operator: one of |
|
|
|
|
|
|
|||||
43 |
+ |
- |
! |
~ |
++ |
-- |
true |
false |
|
|
|
|
44 |
binary-operator-declarator: |
|
|
|
|
|
|
|
||||
45 |
type operator overloadable-binary-operator ( type identifier , type identifier ) |
|||||||||||
46 |
overloadable-binary-operator: one of |
|
<< right-shift |
|
|
|
|
|||||
47 |
+ |
- |
* |
/ |
% & |
| |
^ |
== |
!= |
> |
< |
|
48 |
|
>= |
|
<= |
|
|
|
|
|
|
|
|
453