C# Annotated Standard

C# Annotated Standard
Copyright Page
Dedications
Contents
Foreword to the Annotated Standard
Preface to the Annotated Standard
Acknowledgments
About The Authors
Errata To The International Standard
The C# International Standard and Foreword
Introduction
CLI not required
Chapter 1: Scope
Chapter 2: Conformance
Interpreters
Chapter 3: Normative references
Chapter 4: Definitions
Application vs. program
Assembly vs. class files
Accessing class libraries
Programs, assemblies, applications and class libraries
Chapter 5: Notational conventions
Chapter 6: Acronyms and abbreviations
ASCII Rules!
The C# name
Chapter 7: General description
Where to look for requirements on unsafe constructs
Chapter 8: Language overview
Annotation free zone
8.1 Getting started
8.2 Types
8.2.1 Predefined types
8.2.2 Conversions
8.2.3 Array types
8.2.4 Type system unification
8.3 Variables and parameters
8.4 Automatic memory management
8.5 Expressions
8.6 Statements
8.7 Classes
8.7.1 Constants
8.7.2 Fields
8.7.3 Methods
8.7.4 Properties
8.7.5 Events
8.7.6 Operators
8.7.7 Indexers
8.7.8 Instance constructors
8.7.9 Finalizers
8.7.10 Static constructors
8.7.11 Inheritance
8.7.12 Static classes
8.7.13 Partial type declarations
8.8 Structs
8.9 Interfaces
8.10 Delegates
8.11 Enums
8.12 Namespaces and assemblies
8.13 Versioning
8.14 Extern aliases
8.15 Attributes
8.16 Generics
8.16.1 Why generics?
8.16.2 Creating and consuming generics
8.16.3 Multiple type parameters
8.16.4 Constraints
8.16.5 Generic methods
8.17 Anonymous methods
8.18 Iterators
8.19 Nullable types
Chapter 9: Lexical structure
9.1 Programs
Much ado about nothing
9.2 Grammars
9.2.1 Lexical grammar
9.2.2 Syntactic grammar
9.2.3 Grammar ambiguities
Rationale: the “following token” set
Similar cast expression ambiguity
F(G>7)
9.3 Lexical analysis
9.3.1 Line terminators
9.3.2 Comments
9.3.3 White space
9.4 Tokens
9.4.1 Unicode escape sequences
No escapes in verbatim strings
No escapes in comments
9.4.2 Identifiers
Identifier normalization
The humble underscore
Keyword escape mechanism
Code generation
9.4.3 Keywords
Language evolution
9.4.4 Literals
9.4.4.1 Boolean literals
Boolean arguments considered harmful?
9.4.4.2 Integer literals
Historical note
Boundary differences
9.4.4.3 Real literals
What is 1.D?
Money or deciMal?
9.4.4.4 Character literals
No octal character escapes
9.4.4.5 String literals
Platform independent newlines
Historical note
Happy birthday, Joel
Overspecification…
Hexadecimal escape character pitfalls
9.4.4.6 The null literal
9.4.5 Operators and punctuators
>>== tokenization oddity
Tokenization anecdote
9.5 Pre-processing directives
To pre-process, or not pre-process?
Why no delimited comments in #directives?
Why no macros?
9.5.1 Conditional compilation symbols
Conditional symbol oddity
No program-wide pre-processing symbols
9.5.2 Pre-processing expressions
Inequality is xor; equality is not-xor
9.5.3 Declaration directives
Rationale: pp-declaration placement
Conditional symbol style
9.5.4 Conditional compilation directives
Another issue with comments and #if
Carbuncle
9.5.5 Diagnostic directives
Diagnostic directive example
9.5.6 Region control
Historical note
9.5.7 Line directives
Historical note
#line example
9.5.8 Pragma directives
Chapter 10: Basic concepts
The emperor has no threads!
Example: Synchronization and Threads
10.1 Application startup
Main is callable
10.2 Application termination
Suppression of finalizers
No infanticide
10.3 Declarations
Declaration spaces and anonymous methods
10.4 Members
10.4.1 Namespace members
10.4.2 Struct members
10.4.3 Enumeration members
10.4.4 Class members
10.4.5 Interface members
10.4.7 Delegate members
10.5 Member access
10.5.1 Declared accessibility
Clarification of internal
Clarification of protected internal
Accessibility vs. visibility
Default considered harmful?
Default class accessibility pitfall
10.5.2 Accessibility domains
10.5.3 Protected access for instance members
Rationale: access to protected members
Access to other instantiations
Twin or just sibling?
10.5.4 Accessibility constraints
Declaration accessibility consistency
Constrained object creation
10.6 Signatures and overloading
Explicit interface implementation
Pitfall of overloading on ref or out
Why no ref and out overloading?
10.7 Scopes
Declaration scope within switch statements
Anonymous methods impact scope and lifetime
In scope but not referable
10.7.1 Name hiding
Context-sensitive name resolution
10.7.1.1 Hiding through nesting
Name hiding in a constructor
10.7.1.2 Hiding through inheritance
Abstract cannot be hidden
10.8 Namespace and type names
An extended example
10.8.1 Unqualified name
10.8.2 Fully qualified names
10.9 Automatic memory management
Constructors, exceptions, and finalizers: a volatile combination
One implementation’s garbage is another’s treasure
10.10 Execution order
Synchronous order, asynchronous chaos
Chapter 11: Types
Shallow copying of value types
Uniformity and hidden costs
11.1 Value types
The immediate base class of value types
11.1.1 The System.ValueType type
11.1.2 Default constructors
11.1.3 Struct types
11.1.4 Simple types
Use the keywords!
Keywords not allowed!
Do not use the keywords
11.1.5 Integral types
byte/sbyte naming oddity
11.1.6 Floating point types
Two’s company, three’s a crowd
The other floating point type
Rarity is relative
11.1.7 The decimal type
IEEE decimal
Using IEEE decimal in C#: supporting legacy data
11.1.8 The bool type
Strong Booleans
11.1.9 Enumeration types
Weak enums: distinct but similar
11.2 Reference types
Objects vs. values
11.2.1 Class types
11.2.2 The object type
11.2.3 The string type
Strings are immutable
Insecure strings
11.2.4 Interface types
Interface inheritance is not class inheritance
11.2.5 Array types
11.2.6 Delegate types
11.2.7 The null type
Pseudo-type
11.3 Boxing and unboxing
Can you tell whether a struct instance is boxed?
11.3.1 Boxing conversions
White lies and diaphanous types
11.3.2 Unboxing conversions
Sometimes your host bites…
11.4 Nullable types
11.4.1 Members
Default value
To be, or not to be…a value type
11.4.2 Implemented interfaces
Chapter 12: Variables
Aliasing
12.1 Variable categories
12.1.1 Static variables
12.1.2 Instance variables
12.1.2.1 Instance variables in classes
12.1.2.2 Instance variables in structs
12.1.3 Array elements
12.1.4 Value parameters
12.1.5 Reference parameters
Examples
Example: linked data structures
Example: avoiding repeated index calculations
Example: avoiding simple reassignment errors
12.1.6 Output parameters
Output parameters vs. reference parameters
Using output parameters to return multiple results
12.1.7 Local variables
Extended life or early death
12.2 Default values
Recursive initialization
Pointless instance field initialization
12.3 Definite assignment
Definitely assigned, maybe…
12.3.1 Initially assigned variables
12.3.2 Initially unassigned variables
12.3.3 Precise rules for determining definite assignment
Current compilers, constant expressions, and definite assignment
12.3.3.1 General rules for statements
Arriving from the unreachable
12.3.3.2 Block statements, checked, and unchecked statements
12.3.3.3 Expression statements
12.3.3.4 Declaration statements
12.3.3.5 If statements
Definitely confused?
12.3.3.6 Switch statements
12.3.3.7 While statements
12.3.3.8 Do statements
12.3.3.9 For statements
12.3.3.10 Break, continue, and goto statements
12.3.3.11 Throw statements
12.3.3.12 Return statements
12.3.3.13 Try-catch statements
12.3.3.14 Try-finally statements
12.3.3.15 Try-catch-finally statements
12.3.3.16 Foreach statements
12.3.3.17 Using statements
12.3.3.18 Lock statements
12.3.3.19 General rules for simple expressions
12.3.3.20 General rules for expressions with embedded expressions
12.3.3.21 Invocation expressions and object creation expressions
Trying to peek at an uninitialized variable
12.3.3.22 Simple assignment expressions
12.3.3.23 && expressions
12.3.3.24 || expressions
12.3.3.25 ! expressions
12.3.3.26 ?: expressions
12.3.3.27 Anonymous method expressions
12.3.3.28 Yield statements
12.3.3.29 ?? expressions
Alternative definite assignment rules for the ?? operator
12.4 Variable references
“classified as a variable”
12.5 Atomicity of variable references
Atomicity vs. volatility
Chapter 13: Conversions
13.1 Implicit conversions
13.1.1 Identity conversion
13.1.2 Implicit numeric conversions
Loss of precision
13.1.3 Implicit enumeration conversions
Equal rights for hexadecimals
13.1.4 Implicit reference conversions
Conversions to implemented interfaces
13.1.5 Boxing conversions
Leave my box alone…
13.1.6 Implicit type parameter conversions
13.1.7 Implicit constant expression conversions
Mind your constants
13.1.8 User-defined implicit conversions
13.2 Explicit conversions
Being explicitly implicit
13.2.1 Explicit numeric conversions
Why no double to decimal implicit conversions?
Decimal conversion exceptions dependent on format
13.2.2 Explicit enumeration conversions
Dubious explicit enum conversions
13.2.3 Explicit reference conversions
Never changes, maybe…
Conversion from System.Collections.Generic.IList
Mauled by the host, again…
13.2.4 Unboxing conversions
13.2.5 Explicit type parameter conversions
13.2.6 User-defined explicit conversions
13.3 Standard conversions
13.3.1 Standard implicit conversions
13.3.2 Standard explicit conversions
13.4 User-defined conversions
13.4.1 Permitted user-defined conversions
13.4.2 Evaluation of user-defined conversions
13.4.3 User-defined implicit conversions
13.4.4 User-defined explicit conversions
13.5 Anonymous method conversions
Anecdote: Mono widget design improves C#
13.6 Method group conversions
Non-orthogonality
Through a glass darkly…
13.7 Conversions involving nullable types
Wrapping conversions
13.7.1 Null type conversions
13.7.2 Nullable conversions
Nullable “identity” conversions
13.7.3 Lifted conversions
The same, but different
Chapter 14: Expressions
14.1 Expression classifications
14.1.1 Values of expressions
14.2 Operators
Operand order of evaluation
14.2.1 Operator precedence and associativity
Erratum and clarification
14.2.2 Operator overloading
14.2.3 Unary operator overload resolution
14.2.4 Binary operator overload resolution
14.2.5 Candidate user-defined operators
14.2.6 Numeric promotions
Land of surprises
Into the void
Loosely literal
Reasons for numeric promotion
14.2.6.1 Unary numeric promotions
14.2.6.2 Binary numeric promotions
14.2.7 Lifted operators
Null values in C# and in SQL
14.3 Member lookup
14.3.1 Base types
14.4 Function members
14.4.1 Argument lists
Unrealistic optimism
Hidden (small) costs of parameter arrays
String formatting not part of the Standard
14.4.2 Overload resolution
Overload resolution: C# vs. CIL
14.4.2.1 Applicable function member
14.4.2.2 Better function member
14.4.2.3 Better conversion
Lost digits
Better conversion pitfall
14.4.3 Function member invocation
No boxing
14.4.3.1 Invocations on boxed instances
From diaphanous to concrete
But wait, there is more…
14.5 Primary expressions
14.5.1 Literals
14.5.2 Simple names
14.5.2.1 Invariant meaning in blocks
Simpler confusion
14.5.3 Parenthesized expressions
14.5.4 Member access
14.5.4.1 Identical simple names and type names
14.5.5 Invocation expressions
14.5.5.1 Method invocations
What is not considered during overload resolution?
Sometimes there is no right answer…
14.5.5.2 Delegate invocations
Raising events and thread safety
14.5.6 Element access
14.5.6.1 Array access
Array indexing corner case
Red Katipo
14.5.6.2 Indexer access
14.5.7 This access
this = that?
14.5.8 Base access
Base access is nonvirtual
No override bypass
14.5.9 Postfix increment and decrement operators
Overflow eventually…
14.5.10 The new operator
New for old?
14.5.10.1 Object creation expressions
14.5.10.2 Array creation expressions
Java difference
14.5.10.3 Delegate creation expressions
Name equivalence and conversions
Creating a delegate from a delegate
Breaking change
14.5.11 The typeof operator
typeof(Generic<,>)
14.5.12 The sizeof operator
Marshal.SizeOf != sizeof
14.5.13 The checked and unchecked operators
Checked expression pitfall
(Un)checked constants
The meaning of (un)checked
14.5.14 Default value expression
Historical aside
14.5.15 Anonymous methods
Breaking the ties that bind…
Anonymous sharing
14.5.15.1 Anonymous method signatures
14.5.15.2 Anonymous method blocks
14.5.15.3 Outer variables
14.5.15.3.1 Captured outer variables
Captured local variables: modification and lifetime
Captured variable pitfall
Caution: space leaks
Visitor-style enumeration
14.5.15.3.2 Instantiation of local variables
Caution: local variables shared between threads
Caution: implementation-dependent space leaks
14.5.15.4 Anonymous method evaluation
Interlude: call-by-name
14.5.15.5 Implementation example
Anonymous methods, generic parameters, and a bug
14.6 Unary expressions
14.6.1 Unary plus operator
14.6.2 Unary minus operator
14.6.3 Logical negation operator
14.6.4 Bitwise complement operator
14.6.5 Prefix increment and decrement operators
Obscure C++ difference
14.6.6 Cast expressions
14.7 Arithmetic operators
Void arithmetic
Operator to instruction/method mapping not defined
14.7.1 Multiplication operator
14.7.2 Division operator
Divided we stand
A touch of Pentium
14.7.3 Remainder operator
Remainder latitude
IEC remainder
Further latitude
14.7.4 Addition operator
Hidden boxing
Implicitly avoiding the boxing
String concatenation efficiency
14.7.5 Subtraction operator
Negation, not negative
Legacy coding style
14.8 Shift operators
Negative shifts
Out of bounds shift count behavior?
Zero-extension signed shift
14.9 Relational and type-testing operators
Incomparable
All references are equal, but some are more equal than others
The invisible contract
Equality for all
Exploiting the built-in equality on value types
14.9.1 Integer comparison operators
14.9.2 Floating-point comparison operators
NaNs may be equal
14.9.3 Decimal comparison operators
14.9.4 Boolean equality operators
14.9.5 Enumeration comparison operators
14.9.6 Reference type equality operators
Specification mistake
Boxing not required
14.9.7 String equality operators
14.9.8 Delegate equality operators
Creating unique invocation list items
14.9.9 Equality operators and nullable types
14.9.10 is operator
14.9.11 as operator
is and as ignore user-defined conversions
14.10 Logical operators
14.10.1 Integer logical operators
Extra bits
Bit buckets
14.10.2 Enumeration logical operators
14.10.3 Boolean logical operators
Forgotten “long-circuiting” operators
14.10.4 The bool? logical operators
14.11 Conditional logical operators
14.11.1 Boolean conditional logical operators
14.11.2 User-defined conditional logical operators
true/false overloading
14.12 The null coalescing operator
Subtle interaction with implicit conversions
14.13 Conditional operator
14.14 Assignment operators
14.14.1 Simple assignment
14.14.2 Compound assignment
14.14.3 Event assignment
14.15 Expression
14.16 Constant expressions
Expressions can be constant
Compile time constant evaluation
Divide by zero always throws
14.17 Boolean expressions
Chapter 15: Statements
15.1 End points and reachability
Flow-analysis vs. unsigned types
15.2 Blocks
15.2.1 Statement lists
15.3 The empty statement
15.4 Labeled statements
15.5 Declaration statements
15.5.1 Local variable declarations
15.5.2 Local constant declarations
15.6 Expression statements
15.7 Selection statements
15.7.1 The if statement
15.7.2 The switch statement
Switching on a string
Switching on nullables…
Et tu, Mono?
Independent, within limits
Switch section reordering
Bad switch in a bad switch
15.8 Iteration statements
15.8.1 The while statement
15.8.2 The do statement
15.8.3 The for statement
Iteration count not fixed
15.8.4 The foreach statement
GetEnumerator() selection
Why is the iteration variable read-only?
Subtle change due to anonymous methods
Implications of MoveNext()
Iteration variable: read-only != readonly
15.9 Jump statements
15.9.1 The break statement
15.9.2 The continue statement
15.9.3 The goto statement
15.9.4 The return statement
15.9.5 The throw statement
null ! NullReferenceException
Plug-in style exception handling
Spot the difference
15.10 The try statement
Possible security vulnerability
Variety is the spice of life
Why is the exception variable name optional?
Rationale: Why is jumping out of a finally block forbidden?
Unstoppable exceptions?
Sometimes other code runs before finally
15.11 The checked and unchecked statements
Nested un/checking?
15.12 The lock statement
Lock thread safety?
Lock safety
15.13 The using statement
Rationale: designing for nonmemory resources
Redux: One implementation’s treasure is another’s garbage
15.14 The yield statement
yield syntax?
Chapter 16: Namespaces
16.1 Compilation units
Compilation-unit misnomer
Class libraries
16.2 Namespace declarations
16.3 Extern alias directives
Extern alias implied flexibility
16.4 Using directives
16.4.1 Using alias directives
Using alias constraints
Using alias reordering
16.4.2 Using namespace directives
Ouch, it bit me!
Intercepting calls
16.5 Namespace members
16.6 Type declarations
16.7 Qualified alias member
Chapter 17: Classes
17.1 Class declarations
Trailing semicolons
17.1.1 Class modifiers
17.1.1.1 Abstract classes
abstract + override == redundant?
abstract + override != redundant
17.1.1.2 Sealed classes
17.1.1.3 Static classes
Some bugs lead to features
17.1.2 Class base specification
Positional inheritance notation
17.1.2.1 Base classes
17.1.2.2 Interface implementations
17.1.3 Class body
17.1.4 Partial declarations
Divide and confuse…
But sometimes useful
17.2 Class members
Minor Java difference
17.2.1 Inheritance
17.2.2 The new modifier
17.2.3 Access modifiers
Absent modifier != default modifier
17.2.4 Constituent types
17.2.5 Static and instance members
No access to static members through instance expressions
Rationale: instance method call semantics
17.2.6 Nested types
Delegates and enums are types too
17.2.6.1 Fully qualified name
17.2.6.2 Declared accessibility
17.2.6.3 Hiding
17.2.6.4 this access
Simulating Java-style inner classes
17.2.6.5 Access to private and protected members of the containing type
Access clarification
Older C++ difference
17.2.7 Reserved member names
17.2.7.1 Member names reserved for properties
Neutral, but not agnostic
The meaning of “reserved”
17.2.7.2 Member names reserved for events
17.2.7.3 Member names reserved for indexers
Indexer names on CLI
17.2.7.4 Member names reserved for finalizers
17.3 Constants
Constant references do not trigger static initialization
Having nothing might be useful
17.4 Fields
17.4.1 Static and instance fields
17.4.2 Readonly fields
Readonly yet modifiable
17.4.2.1 Using static readonly fields for constants
17.4.2.2 Versioning of constants and static readonly fields
17.4.3 Volatile fields
Evolution of volatile
Unrealistic optimism redux
17.4.4 Field initialization
17.4.5 Variable initializers
17.4.5.1 Static field initialization
Static fields may never be initialized
17.4.5.2 Instance field initialization
Rationale: why field initializers cannot reference instance fields
Unable to create inner objects
17.5 Methods
Why no throw specifications?
17.5.1 Method parameters
17.5.1.1 Value parameters
17.5.1.2 Reference parameters
A round peg in a square hole…
17.5.1.3 Output parameters
17.5.1.4 Parameter arrays
Params arrays can be null
Is the params keyword needed?
17.5.2 Static and instance methods
17.5.3 Virtual methods
Instance methods are nonvirtual by default
Non-virtual calling of virtual methods
Invocation by compile-time and run-time type
17.5.4 Override methods
17.5.5 Sealed methods
17.5.6 Abstract methods
17.5.7 External methods
17.5.8 Method body
Foreign bodies
17.5.9 Method overloading
17.6 Properties
A property cannot be a ref or out parameter
The accessors of a property cannot be named
17.6.1 Static and instance properties
17.6.2 Accessors
More foreign bodies
Value hiding in an accessor
The most frequently requested new feature
17.6.3 Virtual, sealed, override, and abstract accessors
17.7 Events
Externally, events are write-only
17.7.1 Field-like events
Do-nothing delegate
Event –= vs. +=
Non-thread-safe struct events
17.7.2 Event accessors
Custom event handler semantics
17.7.3 Static and instance events
17.7.4 Virtual, sealed, override, and abstract accessors
17.8 Indexers
No static indexers
Named indexers
17.8.1 Indexer overloading
17.9 Operators
The best laid plans of mice and men…
Bedfellows: operators and structs
17.9.1 Unary operators
17.9.2 Binary operators
17.9.3 Conversion operators
Indirect implicit conversion to an interface
17.10 Instance constructors
17.10.1 Constructor initializers
Infinite recursion not erroneous
17.10.2 Instance variable initializers
17.10.3 Constructor execution
Rationale: field initialization before base constructor invocation
17.10.4 Default constructors
17.10.5 Private constructors
17.10.6 Optional instance constructor parameters
17.11 Static constructors
No access specifier; no parameter
Trigger one, trigger all
Constants are not “referenced”
Which static constructor is triggered?
Indeterminately deterministic
17.12 Finalizers
C++ destructors versus C# finalizers
Thwarting a finalizer
Thwarting a finalizer on the CLI
Finalizer issues
Final deadlock
Erroneous details
Chapter 18: Structs
Freedom of allocation
“Heap” allocation required
Union City blues
Premature optimization
Danger, UXB!
18.1 Struct declarations
18.1.1 Struct modifiers
18.1.2 Struct interfaces
18.1.3 Struct body
18.2 Struct members
18.3 Class and struct differences
readonly value-type fields
18.3.1 Value semantics
Struct layout cycles
Struct equality contracts
18.3.2 Inheritance
18.3.3 Assignment
18.3.4 Default values
Why do structs always have a default constructor?
18.3.5 Boxing and unboxing
18.3.6 Meaning of this
18.3.7 Field initializers
18.3.8 Constructors
Definite assignment inside a struct constructor
Non–dynamic allocation using new
18.3.9 Finalizers
Why no ~S() in struct type S?
18.3.10 Static constructors
Static constructor roulette
Chapter 19: Arrays
19.1 Array types
19.1.1 The System.Array type
19.2 Array creation
19.3 Array element access
foreach: simpler and faster
19.4 Array members
Arrays and vectors on the CLI
19.5 Array covariance
19.6 Arrays and the generic IList interface
19.7 Array initializers
Brace depth must equal array dimension
Chapter 20: Interfaces
20.1 Interface declarations
Partial interfaces?
20.1.1 Interface modifiers
20.1.2 Base interfaces
Different inheritance
20.1.3 Interface body
20.2 Interface members
20.2.1 Interface methods
20.2.2 Interface properties
20.2.3 Interface events
20.2.4 Interface indexers
20.2.5 Interface member access
20.3 Fully qualified interface member names
20.4 Interface implementations
Interfaces implemented through the base class
20.4.1 Explicit interface member implementations
Excess accessors not allowed in explicit interface member implementation
Simulating return type covariance
params oddity
20.4.2 Interface mapping
Morphing non-virtual methods
Inaccurate assertion
20.4.3 Interface implementation inheritance
Erratum?
Meaning of ‘‘implements’’
20.4.4 Interface re-implementation
Original implementation inaccessible
20.4.5 Abstract classes and interfaces
Abstract class interface alternatives
Chapter 21: Enums
Enums are integral
21.1 Enum declarations
Why no char underlying type?
21.2 Enum modifiers
21.3 Enum members
Second-class citizens
Type of an enum member
enum alternatives
21.4 The System.Enum type
21.5 Enum values and operations
Operations on enums
Chapter 22: Delegates
22.1 Delegate declarations
22.2 Delegate instantiation
Creation does not trigger static initialization
Delegates for value type instance methods
The C# pimpernel…
22.3 Delegate invocation
Chapter 23: Exceptions
Exceptions not advised as control flow
23.1 Causes of exceptions
Asynchronous exceptions
Unexpected exception
23.2 The System.Exception class
Optional InnerException
A good idea in theory, but not in practice
23.3 How exceptions are handled
Here be dragons
23.4 Common exception classes
Genteel exception classes?
Chapter 24: Attributes
24.1 Attribute classes
Suffix omission clarification
24.1.1 Attribute usage
24.1.2 Positional and named parameters
24.1.3 Attribute parameter types
24.2 Attribute specification
return vs. @return
Specification omission
Multiple declaration unclarity
24.3 Attribute instances
24.3.1 Compilation of an attribute
Constructor not called at compile-time
24.3.2 Run-time retrieval of an attribute instance
Reflection not part of C# standard
24.4 Reserved attributes
24.4.1 The AttributeUsage attribute
AttributeUsage and partial compile-time checks
24.4.2 The Conditional attribute
24.4.2.1 Conditional methods
Derived surprises
24.4.2.2 Conditional attribute classes
24.4.3 The Obsolete attribute
What error parameter?
Really obsolete
Chapter 25: Generics
Not separate, just pragmatic
C# generics compared to Ada, C++, Haskell, Java 1.5…
25.1 Generic class declarations
No type parameters in constructor declarations, but type arguments in constructor invocations
Overloading on number of type parameters
25.1.1 Type parameters
Null comparison despite no conversion
25.1.2 The instance type
25.1.3 Members of generic classes
25.1.4 Static fields in generic classes
Non-identical twins
25.1.5 Static constructors in generic classes
25.1.6 Accessing protected members
25.1.7 Overloading in generic classes
Clarifications
25.1.8 Parameter array methods and type parameters
25.1.9 Overriding and generic classes
25.1.10 Operators in generic classes
No operators on constructed type
Ignored ambiguity
25.1.11 Nested types in generic classes
Thinking generically: containers
25.2 Generic struct declarations
Infinite chains of constructed types
25.3 Generic interface declarations
25.3.1 Uniqueness of implemented interfaces
25.3.2 Explicit interface member implementations
25.4 Generic delegate declarations
Generic function types
25.5 Constructed types
25.5.1 Type arguments
25.5.2 Open and closed types
25.5.3 Base classes and interfaces of a constructed type
25.5.4 Members of a constructed type
25.5.5 Accessibility of a constructed type
25.5.6 Conversions
25.5.7 Using alias directives
Aliases do not take type parameters
25.6 Generic methods
25.6.1 Generic method signatures
25.6.2 Virtual generic methods
25.6.3 Calling generic methods
Polymorphic recursion
25.6.4 Inference of type arguments
Specification bug
Parameter arrays
Limited inference
25.6.5 Using a generic method with a delegate
From generic method to delegate
25.6.6 No generic properties, events, indexers, operators, constructors, or finalizers
Rationale: no generic constructors, operators, properties, or indexers
25.7 Constraints
No nullable constraint
Using constraints to simulate Java wildcard types
Ineffective base class?
No “numeric” constraints
25.7.1 Satisfying constraints
25.7.2 Member lookup on type parameters
25.7.3 Type parameters and boxing
No cast, no box
Inherited constraints
25.7.4 Conversions involving type parameters
Thinking generically: algorithms
Chapter 26: Iterators
Growing pains
Coroutines allowed?
26.1 Iterator blocks
26.1.1 Enumerator interfaces
26.1.2 Enumerable interfaces
26.1.3 Yield type
26.1.4 This access
How many iterators does it take to enumerate?
Enumerating a data structure: iterators, handwritten enumerator, or visitor style?
26.2 Enumerator objects
Iterators, finally, lock and using
Obscure iterator and finally/lock/using interaction
26.2.1 The MoveNext method
Implicit yield break at end of iterator block
26.2.2 The Current property
26.2.3 The Dispose method
26.3 Enumerable objects
26.3.1 The GetEnumerator method
26.4 Implementation example
Anecdote: iterator blocks, generic parameters, and a bug
Chapter 27: Unsafe code
27.1 Unsafe contexts
27.2 Pointer types
Missing grammar rule
Volatile pointers
A confusing C# vs. C/C++ syntax difference
27.3 Fixed and moveable variables
27.4 Pointer conversions
27.5 Pointers in expressions
27.5.1 Pointer indirection
27.5.2 Pointer member access
27.5.3 Pointer element access
27.5.4 The address-of operator
No pointer-to-volatile
27.5.5 Pointer increment and decrement
27.5.6 Pointer arithmetic
27.5.7 Pointer comparison
27.5.8 The sizeof operator
27.6 The fixed statement
27.7 Stack allocation
The programmer does not always come first
27.8 Dynamic memory allocation
A: Grammar
A.1 Lexical grammar
A.1.1 Line terminators
A.1.2 White space
A.1.3 Comments
A.1.4 Tokens
A.1.5 Unicode escape sequences
A.1.6 Identifiers
A.1.7 Keywords
A.1.8 Literals
A.1.9 Operators and punctuators
A.1.10 Pre-processing directives
A.2 Syntactic grammar
A.2.1 Basic concepts
A.2.2 Types
A.2.3 Variables
A.2.4 Expressions
A.2.5 Statements
A.2.6 Classes
A.2.7 Structs
A.2.8 Arrays
A.2.9 Interfaces
A.2.10 Enums
A.2.11 Delegates
A.2.12 Attributes
A.2.13 Generics
A.3 Grammar extensions for unsafe code
B: Portability issues
B.1 Undefined behavior
B.2 Implementation-defined behavior
B.3 Unspecified behavior
B.4 Other Issues
C: Naming Guidelines
Naming guideline summary
D: Standard Library
E: Documentation Comments
E.1 Introduction
E.2 Recommended tags
E.2.1
E.2.2
E.2.3
E.2.4
E.2.5
E.2.6
E.2.7
E.2.8
E.2.9
E.2.10
E.2.11
E.2.12
E.2.13
E.2.14

E.2.15
E.2.16
E.2.17
E.3 Processing the documentation file
E.3.1 ID string format
E.3.2 ID string examples
E.4 An example
E.4.1 C# source code
E.4.2 Resulting XML
F: Bibliography
Index