Front Cover -- 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

13.1.3 Implicit enumeration conversions.