C# in Depth, 4th Edition

Copyright
Brief Table of Contents
Table of Contents
Praise for the Third Edition
Praise for the Second Edition
Praise for the First Edition
Foreword
Preface
Acknowledgments
About this book
About the author
About the cover illustration
Part 1. C# in context
    Chapter 1. Survival of the sharpest
        1.1. An evolving language
        1.2. An evolving platform
        1.3. An evolving community
        1.4. An evolving book
        Summary
Part 2. C# 2–5
    Chapter 2. C# 2
        2.1. Generics
        2.2. Nullable value types
        2.3. Simplified delegate creation
        2.4. Iterators
        2.5. Minor features
        Summary
    Chapter 3. C# 3: LINQ and everything that comes with it
        3.1. Automatically implemented properties
        3.2. Implicit typing
        3.3. Object and collection initializers
        3.4. Anonymous types
        3.5. Lambda expressions
        3.6. Extension methods
        3.7. Query expressions
        3.8. The end result: LINQ
        Summary
    Chapter 4. C# 4: Improving interoperability
        4.1. Dynamic typing
        4.2. Optional parameters and named arguments
        4.3. COM interoperability improvements
        4.4. Generic variance
        Summary
    Chapter 5. Writing asynchronous code
        5.1. Introducing asynchronous functions
        5.2. Thinking about asynchrony
        5.3. Async method declarations
        5.4. Await expressions
        5.5. Wrapping of return values
        5.6. Asynchronous method flow
        5.7. Asynchronous anonymous functions
        5.8. Custom task types in C# 7
        5.9. Async main methods in C# 7.1
        5.10. Usage tips
        Summary
    Chapter 6. Async implementation
        6.1. Structure of the generated code
        6.2. A simple MoveNext() implementation
        6.3. How control flow affects MoveNext()
        6.4. Execution contexts and flow
        6.5. Custom task types revisited
        Summary
    Chapter 7. C# 5 bonus features
        7.1. Capturing variables in foreach loops
        7.2. Caller information attributes
        Summary
Part 3. C# 6
    Chapter 8. Super-sleek properties and expression-bodied members
        8.1. A brief history of properties
        8.2. Upgrades to automatically implemented properties
        8.3. Expression-bodied members
        Summary
    Chapter 9. Stringy features
        9.1. A recap on string formatting in .NET
        9.2. Introducing interpolated string literals
        9.3. Localization using FormattableString
        9.4. Uses, guidelines, and limitations
        9.5. Accessing identifiers with nameof
        Summary
    Chapter 10. A smörgåsbord of features for concise code
        10.1. Using static directives
        10.2. Object and collection initializer enhancements
        10.3. The null conditional operator
        10.4. Exception filters
        Summary
Part 4. C# 7 and beyond
    Chapter 11. Composition using tuples
        11.1. Introduction to tuples
        11.2. Tuple literals and tuple types
        11.3. Tuple types and conversions
        11.4. Tuples in the CLR
        11.5. Alternatives to tuples
        11.6. Uses and recommendations
        Summary
    Chapter 12. Deconstruction and pattern matching
        12.1. Deconstruction of tuples
        12.2. Deconstruction of nontuple types
        12.3. Introduction to pattern matching
        12.4. Patterns available in C# 7.0
        12.5. Using patterns with the is operator
        12.6. Using patterns with switch statements
        12.7. Thoughts on usage
        Summary
    Chapter 13. Improving efficiency with more pass by reference
        13.1. Recap: What do you know about ref?
        13.2. Ref locals and ref returns
        13.3. in parameters (C# 7.2)
        13.4. Declaring structs as readonly (C# 7.2)
        13.5. Extension methods with ref or in parameters (C# 7.2)
        13.6. Ref-like structs (C# 7.2)
        Summary
    Chapter 14. Concise code in C# 7
        14.1. Local methods
        14.2. Out variables
        14.3. Improvements to numeric literals
        14.4. Throw expressions
        14.5. Default literals (C# 7.1)
        14.6. Nontrailing named arguments (C# 7.2)
        14.7. Private protected access (C# 7.2)
        14.8. Minor improvements in C# 7.3
        Summary
    Chapter 15. C# 8 and beyond
        15.1. Nullable reference types
        15.2. Switch expressions
        15.3. Recursive pattern matching
        15.4. Indexes and ranges
        15.5. More async integration
        15.6. Features not yet in preview
        15.7. Getting involved
        Conclusion
Language features by version
Index
List of Figures
List of Tables
List of Listings