C# in Depth, 4th Video Edition

C# in Depth, 4th Video Edition
C# in Depth, 4th Video Edition
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 17h 17m | 3.51 GB

C# in Depth, Fourth Edition is your key to unlocking the powerful new features added to the language in C# 5, 6, and 7. Following the expert guidance of C# legend Jon Skeet, you’ll master asynchronous functions, expression-bodied members, interpolated strings, tuples, and much more.

The powerful, flexible C# programming language is the foundation of .NET development. Even after two decades of success, it’s still getting better! Exciting new features in C# 6 and 7 make it easier than ever to take on big data applications, cloud-centric web development, and cross-platform software using .NET Core. There’s never been a better time to learn C# in depth.

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.

Inside:

  • Comprehensive coverage of C# 6 and 7
  • Greatest hits of C# 2–5
  • Extended pass-by-reference functionality
  • String interpolation
  • Composition with tuples
  • Decomposition and pattern matching
Table of Contents

1 Part 1. C# in context
2 An evolving language
3 Ever more concise code
4 Balancing efficiency and complexity
5 An evolving platform
6 An evolving book
7 Part 2. C# 2–5
8 Generics
9 Generics save the day
10 What can be generic
11 Type constraints
12 The default and typeof operators
13 Nullable value types
14 CLR and framework support – The Nullable T struct
15 Language support Part 1
16 Language support Part 2
17 Simplified delegate creation
18 Iterators
19 The importance of being lazy
20 Implementation sketch
21 Minor features
22 Namespace aliases
23 Fixed-size buffers
24 Automatically implemented properties
25 Implicitly typed local variables (var)
26 Object and collection initializers
27 Collection initializers
28 Anonymous types
29 The compiler-generated type
30 Lambda expressions
31 Capturing variables
32 Expression trees
33 Extension methods
34 Query expressions
35 The end result – LINQ
36 Dynamic typing
37 Introduction to dynamic typing
38 Dynamic behavior beyond reflection
39 A brief look behind the scenes
40 Limitations and surprises in dynamic typing
41 Usage suggestions
42 Optional parameters and named arguments
43 Impact on versioning
44 COM interoperability improvements
45 Generic variance
46 Restrictions on using variance
47 Introducing asynchronous functions
48 First encounters of the asynchronous kind
49 Thinking about asynchrony
50 Synchronization contexts
51 Async method declarations
52 Await expressions
53 Wrapping of return values
54 Asynchronous method flow
55 The use of awaitable pattern members
56 Method completion
57 Asynchronous anonymous functions
58 Custom task types in C# 7
59 Async main methods in C# 7.1
60 Usage tips
61 Allow cancellation wherever possible
62 Structure of the generated code
63 The stub method – Preparation and taking the first step
64 The MoveNext() method (high level)
65 A simple MoveNext() implementation
66 How control flow affects MoveNext()
67 Execution contexts and flow
68 Capturing variables in foreach loops
69 Caller information attributes
70 Corner cases of caller information attributes
71 Using caller information attributes with old versions of .NET
72 Part 3. C# 6
73 A brief history of properties
74 Upgrades to automatically implemented properties
75 Expression-bodied members
76 Restrictions on expression-bodied members in C# 6
77 A recap on string formatting in .NET
78 Localization
79 Introducing interpolated string literals
80 Localization using FormattableString
81 Other uses for FormattableString
82 Uses, guidelines, and limitations
83 Hard limitations of interpolated string literals
84 Accessing identifiers with nameof
85 Tricks and traps when using nameof
86 Using static directives
87 Object and collection initializer enhancements
88 Using extension methods in collection initializers
89 The null conditional operator
90 Indexers and the null conditional operator
91 Exception filters
92 Retrying operations
93 Part 4. C# 7 and beyond
94 Introduction to tuples
95 Tuple literals and tuple types
96 Tuples as bags of variables
97 Tuple types and conversions
98 Conversions from tuple literals to tuple types
99 Conversions between tuple types
100 Tuples in the CLR
101 Regular equality and ordering comparisons
102 Alternatives to tuples
103 Uses and recommendations
104 Deconstruction of tuples
105 Deconstruction assignments to existing variables and properties
106 Deconstruction of nontuple types
107 Introduction to pattern matching
108 Patterns available in C# 7.0
109 Using patterns with the is operator
110 Using patterns with switch statements
111 Evaluation order of pattern-based switch statements
112 Thoughts on usage
113 Recap – What do you know about ref
114 Ref locals and ref returns
115 Ref returns
116 in parameters (C# 7.2)
117 Overloading with in parameters
118 Declaring structs as readonly (C# 7.2)
119 Extension methods with ref or in parameters (C# 7.2)
120 Ref-like structs (C# 7.2)
121 Span T and stackalloc
122 Local methods
123 Local method implementations
124 Usage guidelines
125 Out variables
126 Improvements to numeric literals
127 Nontrailing named arguments (C# 7.2)
128 Minor improvements in C# 7.3
129 Nullable reference types
130 Nullable reference types at compile time and execution time
131 Experiences of nullable reference type migration
132 Future improvements
133 Switch expressions
134 Recursive pattern matching
135 Indexes and ranges
136 More async integration
137 Features not yet in preview
138 Even more features in brief