Cover image for C# in Depth, Fourth Edition

C# in Depth, Fourth Edition

Author Jonathan Skeet
Release Date: 2019/04/01
ISBN: 9781617294532
Topic:
0%
40
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Book Description

C# in Depth, Fourth Edition is a revised edition of the bestseller written by C# legend Jon Skeet. This authoritative and engaging guide is your key to unlocking this powerful language, including the new features of C# 6 and 7. In it, Jon introduces expression-bodied members, interpolated strings, pattern matching, and more. Real-world examples drive it all home. By the end of this awesome book, you'll be writing C# code with skill, style, and confidence.

Table of Contents

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