C# in Depth, 4th Ed, Video Edition

Table of contents

1. Part 1. C# in context
2. Chapter 1. Survival of the sharpest
   1. An evolving language
   2. Ever more concise code
   3. Balancing efficiency and complexity
   4. An evolving platform
   5. An evolving book
3. Part 2. C# 2–5
4. Chapter 2. C# 2
   1. Generics
   2. Generics save the day
   3. What can be generic?
   4. Type constraints
   5. The default and typeof operators
   6. Nullable value types
   7. CLR and framework support: The Nullable struct
      1. Language support Part 1
      2. Language support Part 2
      3. Simplified delegate creation
      4. Iterators
      5. The importance of being lazy
      6. Implementation sketch
      7. Minor features
      8. Namespace aliases
      9. Fixed-size buffers
   8. Chapter 3. C# 3: LINQ and everything that comes with it
      1. Automatically implemented properties
      2. Implicitly typed local variables (var)
      3. Object and collection initializers
      4. Collection initializers
      5. Anonymous types
      6. The compiler-generated type
      7. Lambda expressions
      8. Capturing variables
      9. Expression trees
      10. Extension methods
      11. Query expressions
      12. The end result: LINQ
   9. Chapter 4. C# 4: Improving interoperability
      1. Dynamic typing
      2. Introduction to dynamic typing
      3. Dynamic behavior beyond reflection
      4. A brief look behind the scenes
      5. Limitations and surprises in dynamic typing
      6. Usage suggestions
      7. Optional parameters and named arguments
      8. Impact on versioning
      9. COM interoperability improvements
      10. Generic variance
      11. Restrictions on using variance
   10. Chapter 5. Writing asynchronous code
       1. Introducing asynchronous functions
       2. First encounters of the asynchronous kind
       3. Thinking about asynchrony
       4. Synchronization contexts
       5. Async method declarations
       6. Await expressions
       7. Wrapping of return values
       8. Asynchronous method flow
       9. The use of awaitable pattern members
       10. Method completion
       11. Asynchronous anonymous functions
       12. Custom task types in C# 7
       13. Async main methods in C# 7.1
       14. Usage tips
       15. Allow cancellation wherever possible
   11. Chapter 6. Async implementation
       1. Structure of the generated code
       2. The stub method: Preparation and taking the first step
       3. The MoveNext() method (high level)
       4. A simple MoveNext() implementation
       5. How control flow affects MoveNext()
       6. Execution contexts and flow
   12. Chapter 7. C# 5 bonus features
       1. Capturing variables in foreach loops
       2. Caller information attributes
       3. Corner cases of caller information attributes
       4. Using caller information attributes with old versions of .NET
   13. Part 3. C# 6
   14. Chapter 8. Super-sleek properties and expression-bodied members
       1. A brief history of properties
       2. Upgrades to automatically implemented properties
       3. Expression-bodied members
       4. Restrictions on expression-bodied members in C# 6
   15. Chapter 9. Stringy features
       1. A recap on string formatting in .NET
       2. Localization
       3. Introducing interpolated string literals
       4. Localization using FormattableString
       5. Other uses for FormattableString
       6. Uses, guidelines, and limitations
       7. Hard limitations of interpolated string literals
       8. Accessing identifiers with nameof
       9. Tricks and traps when using nameof
   16. Chapter 10. A smörgåsbord of features for concise code
       1. Using static directives
       2. Object and collection initializer enhancements
       3. Using extension methods in collection initializers
       4. The null conditional operator
       5. Indexers and the null conditional operator
       6. Exception filters
       7. Retrying operations
   17. Part 4. C# 7 and beyond
   18. Chapter 11. Composition using tuples
       1. Introduction to tuples
       2. Tuple literals and tuple types
       3. Tuples as bags of variables
       4. Tuple types and conversions
       5. Conversions from tuple literals to tuple types
       6. Conversions between tuple types
       7. Tuples in the CLR
       8. Regular equality and ordering comparisons
       9. Alternatives to tuples
       10. Uses and recommendations
   19. Chapter 12. Deconstruction and pattern matching
       1. Deconstruction of tuples
       2. Deconstruction assignments to existing variables and properties
       3. Deconstruction of nontuple types
       4. Introduction to pattern matching
       5. Patterns available in C# 7.0
       6. Using patterns with the is operator
       7. Using patterns with switch statements
       8. Evaluation order of pattern-based switch statements
       9. Thoughts on usage
   20. Chapter 13. Improving efficiency with more pass by reference
       1. Recap: What do you know about ref?
       2. Ref locals and ref returns
       3. Ref returns
       4. in parameters (C# 7.2)
       5. Overloading with in parameters
       6. Declaring structs as readonly (C# 7.2)
       7. Extension methods with ref or in parameters (C# 7.2)
       8. Ref-like structs (C# 7.2)
       9. Span and stackalloc
       10. Chapter 14. Concise code in C# 7
           1. Local methods
           2. Local method implementations
           3. Usage guidelines
           4. Out variables
           5. Improvements to numeric literals
           6. Nontrailing named arguments (C# 7.2)
           7. Minor improvements in C# 7.3
       11. Chapter 15. C# 8 and beyond
           1. Nullable reference types
           2. Nullable reference types at compile time and execution time
           3. Experiences of nullable reference type migration
           4. Future improvements
           5. Switch expressions
           6. Recursive pattern matching
           7. Indexes and ranges
           8. More async integration
           9. Features not yet in preview
           10. Even more features in brief