by Jon Skeet | Released September 2013 | ISBN: None

"The definitive what, how, and why of C#." Eric Lippert, Coverity If you're a .NET developer, you'll use C# whether you're building an advanced enterprise application or just slamming out a quick app. In C# 5 you can do amazing things with generics, lambda expressions, dynamic typing, LINQ, iterator blocks, and other features. But first you have to learn it in depth. C# in Depth, Third Edition has been thoroughly revised to cover the features of C# 5, including the subtleties of writing maintainable asynchronous code. You'll see the power of C# in action, learning how to work with high-value features that you'll be glad to have in your toolkit. And you'll learn to avoid hidden pitfalls of C# programming with the help of crystal clear explanations of "behind the scenes" issues. Inside: Updated for C# 5 The async/await feature How C# works and why This book/course assumes you've digested your first C# book and are hungry for more! Jon Skeet is a Senior Software Engineer at Google, and a highly visible participant of newsgroups, user groups, international conferences, and the Stack Overflow Q&A site. Jon spends much of his day coding in Java, but his heart belongs to C#. The best source for learning C# language features. Andy Kirsch, Venga Took my C# knowledge to the next level. Dustin Laine, Code Harvest A must-have book that every .NET developer should read at least once. Dror Helper, Better Place Easily the best C# reference I've found. Jon Parish, Datasif NARRATED BY EZRA SIMELOFF AND JON SKEET Show and hide more

1. PART 1 PREPARING FOR THE JOURNEY
   • Chapter 1. The changing face of C# development 00:09:18
   • Chapter 1. Sorting and filtering 00:08:55
   • Chapter 1. Handling an absence of data 00:10:19
   • Chapter 1. COM and dynamic typing 00:07:21
   • Chapter 1. Dissecting the .NET platform 00:08:09
   • Chapter 1. Didactic code isn’t production code 00:05:23
   • Chapter 2. Core foundations: building on C# 1 00:04:25
   • Chapter 2. A recipe for simple delegates 00:12:29
   • Chapter 2. Combining and removing delegates 00:10:02
   • Chapter 2. Type system characteristics 00:11:20
   • Chapter 2. When is C# 1’s type system not rich enough? 00:08:58
   • Chapter 2. Value types and reference types 00:08:46
   • Chapter 2. Dispelling myths 00:07:06
   • Chapter 2. Boxing and unboxing 00:05:13
   • Chapter 2. Beyond C# 1: new features on a solid base 00:06:52
   • Chapter 2. Features related to the type system 00:07:39
   • Chapter 2. Features related to value types 00:03:54
2. PART 2 C# 2: SOLVING THE ISSUES OF C# 1
   • Chapter 3. Parameterized typing with generics 00:07:54
   • Chapter 3. Simple generics for everyday use 00:04:42
   • Chapter 3. Generic types and type parameters 00:08:38
   • Chapter 3. Generic methods and reading generic declarations 00:09:18
   • Chapter 3. Beyond the basics 00:08:56
   • Chapter 3. Type constraints 00:06:26
   • Chapter 3. Type inference for type arguments of generic methods 00:04:34
   • Chapter 3. Implementing generics 00:09:25
   • Chapter 3. The generic comparison interfaces 00:06:01
   • Chapter 3. Advanced generics 00:05:22
   • Chapter 3. How the JIT compiler handles generics 00:05:34
   • Chapter 3. Generic iteration 00:06:10
   • Chapter 3. Reflection and generics 00:10:48
   • Chapter 3. Limitations of generics in C# and other languages 00:05:30
   • Chapter 3. Lack of generic variance 00:09:44
   • Chapter 3. Lack of operator constraints or a “numeric” constraint 00:06:39
   • Chapter 3. Comparison with C++ templates 00:05:02
   • Chapter 3. Comparison with Java generics 00:06:36
   • Chapter 4. Saying nothing with nullable types 00:06:36
   • Chapter 4. Patterns for representing null values in C# 1 00:06:43
   • Chapter 4. System.Nullable<T> and System.Nullable 00:07:23
   • Chapter 4. Boxing Nullable<T> and unboxing 00:07:02
   • Chapter 4. C# 2’s syntactic sugar for nullable types 00:09:30
   • Chapter 4. Nullable conversions and operators 00:09:55
   • Chapter 4. Nullable logic 00:06:52
   • Chapter 4. The null coalescing operator 00:07:10
   • Chapter 4. Novel uses of nullable types 00:06:44
   • Chapter 4. Painless comparisons with the null coalescing operator 00:08:24
   • Chapter 5. Fast-tracked delegates 00:07:24
   • Chapter 5. Method group conversions 00:09:06
   • Chapter 5. Covariance of delegate return types 00:05:03
   • Chapter 5. Inline delegate actions with anonymous methods 00:07:33
   • Chapter 5. Returning values from anonymous methods 00:07:00
   • Chapter 5. Capturing variables in anonymous methods 00:07:40
   • Chapter 5. What’s the point of captured variables? 00:05:50
   • Chapter 5. Local variable instantiations 00:09:02
   • Chapter 5. Captured variable guidelines and summary 00:06:05
   • Chapter 6. Implementing iterators the easy way 00:09:46
   • Chapter 6. C# 2: Simple iterators with yield statements 00:08:56
   • Chapter 6. Advanced iterator execution flow 00:10:34
   • Chapter 6. Real-life iterator examples 00:03:45
   • Chapter 6. Iterating over lines in a file 00:07:19
   • Chapter 6. Filtering items lazily using an iterator block and a predicate 00:04:54
   • Chapter 6. Pseudo-synchronous code with the Concurrency and Coordination Runtime 00:09:56
   • Chapter 7. Concluding C# 2: the final features 00:05:40
   • Chapter 7. Creating a type with multiple files 00:09:10
   • Chapter 7. Partial methods—C# 3 only! 00:05:06
   • Chapter 7. Static classes 00:09:03
   • Chapter 7. Namespace aliases 00:10:09
   • Chapter 7. Pragma directives 00:08:40
   • Chapter 7. Exposing internal members to selected assemblies 00:07:44
3. PART 3 C# 3: REVOLUTIONIZING DATA ACCESS
   • Chapter 8. Cutting fluff with a smart compiler 00:09:25
   • Chapter 8. Implicit typing of local variables 00:06:56
   • Chapter 8. Pros and cons of implicit typing 00:07:17
   • Chapter 8. Simplified initialization 00:07:00
   • Chapter 8. Setting properties on embedded objects 00:09:38
   • Chapter 8. Uses of initialization features 00:07:15
   • Chapter 8. Anonymous types 00:08:59
   • Chapter 8. Projection initializers 00:07:05
   • Chapter 9. Lambda expressions and expression trees 00:06:35
   • Chapter 9. Preliminaries: Introducing the Func<...> delegate types 00:10:46
   • Chapter 9. Simple examples using List<T> and events 00:05:30
   • Chapter 9. Expression trees 00:07:29
   • Chapter 9. Converting C# lambda expressions to expression trees 00:06:38
   • Chapter 9. Expression trees at the heart of LINQ 00:09:05
   • Chapter 9. Changes to type inference and overload resolution 00:07:09
   • Chapter 9. Two-phase type inference 00:09:09
   • Chapter 9. Picking the right overloaded method 00:08:19
   • Chapter 10. Extension methods 00:08:36
   • Chapter 10. Extension method syntax 00:05:33
   • Chapter 10. Extension method discovery 00:09:17
   • Chapter 10. Extension methods in .NET 3.5 00:10:02
   • Chapter 10. Interlude: haven’t we seen the Where method before? 00:07:05
   • Chapter 10. Business examples involving chaining 00:04:10
   • Chapter 10. Usage ideas and guidelines 00:08:14
   • Chapter 11. Query expressions and LINQ to Objects 00:08:16
   • Chapter 11. Fundamental concepts in LINQ 00:09:25
   • Chapter 11. Simple beginnings: selecting elements 00:10:38
   • Chapter 11. Range variables and nontrivial projections 00:09:27
   • Chapter 11. Filtering and ordering a sequence 00:08:41
   • Chapter 11. Let clauses and transparent identifiers 00:05:48
   • Chapter 11. Joins 00:09:54
   • Chapter 11. Group joins with join...into clauses 00:09:06
   • Chapter 11. Groupings and continuations 00:11:16
   • Chapter 11. Choosing between query expressions and dot notation 00:10:33
   • Chapter 12. LINQ beyond collections 00:09:51
   • Chapter 12. Initial queries 00:09:48
   • Chapter 12. Translations using IQueryable and IQueryProvider 00:09:11
   • Chapter 12. Gluing expressions together: the Queryable extension methods 00:08:27
   • Chapter 12. LINQ-friendly APIs and LINQ to XML 00:06:17
   • Chapter 12. Declarative construction 00:10:04
   • Chapter 12. Flattened query operators 00:05:35
   • Chapter 12. Replacing LINQ to Objects with Parallel LINQ 00:05:16
   • Chapter 12. Introducing ParallelEnumerable, ParallelQuery, and AsParallel 00:06:50
   • Chapter 12. Inverting the query model with LINQ to Rx 00:09:01
   • Chapter 12. Querying observables 00:08:42
   • Chapter 12. Extending LINQ to Objects 00:06:30
   • Chapter 12. Sample extension: selecting a random element 00:06:49
4. PART 4 C# 4: PLAYING NICELY WITH OTHERS
   • Chapter 13. Minor changes to simplify code 00:08:39
   • Chapter 13. Optional parameters 00:07:05
   • Chapter 13. Named arguments 00:09:33
   • Chapter 13. Putting the two together 00:11:15
   • Chapter 13. Improvements for COM interoperability 00:07:04
   • Chapter 13. Calling named indexers 00:09:42
   • Chapter 13. Generic variance for interfaces and delegates 00:05:06
   • Chapter 13. Using variance in interfaces 00:09:49
   • Chapter 13. Complex situations 00:08:29
   • Chapter 13. Restrictions and notes 00:07:12
   • Chapter 13. Teeny tiny changes to locking and field-like events 00:08:10
   • Chapter 14. Dynamic binding in a static language 00:08:56
   • Chapter 14. When is dynamic typing useful, and why? 00:07:28
   • Chapter 14. The five-minute guide to dynamic 00:05:39
   • Chapter 14. Examples of dynamic typing 00:06:36
   • Chapter 14. Dynamic languages such as IronPython 00:12:23
   • Chapter 14. Dynamic typing in purely managed code 00:07:43
   • Chapter 14. Duck typing 00:05:43
   • Chapter 14. Looking behind the scenes 00:05:01
   • Chapter 14. DLR core concepts 00:08:48
   • Chapter 14. How the C# compiler handles dynamic 00:10:05
   • Chapter 14. The C# compiler gets even smarter 00:05:44
   • Chapter 14. Restrictions on dynamic code 00:07:23
   • Chapter 14. Implementing dynamic behavior 00:08:40
   • Chapter 14. Using DynamicObject 00:06:44
   • Chapter 14. Overriding TryXXX methods 00:06:12
   • Chapter 14. Implementing IDynamicMetaObjectProvider 00:11:18
5. PART 5 C# 5: ASYNCHRONY MADE SIMPLE
   • Chapter 15. Asynchrony with async/await 00:08:54
   • Chapter 15. First encounters of the asynchronous kind 00:06:43
   • Chapter 15. Thinking about asynchrony 00:09:01
   • Chapter 15. Syntax and semantics 00:06:54
   • Chapter 15. The awaitable pattern 00:06:47
   • Chapter 15. The flow of await expressions 00:11:06
   • Chapter 15. Returning from an async method 00:09:46
   • Chapter 15. Exceptions 00:10:28
   • Chapter 15. Asynchronous anonymous functions 00:04:54
   • Chapter 15. Implementation details: compiler transformation 00:07:55
   • Chapter 15. Structure of the skeleton method 00:07:58
   • Chapter 15. One entry point to rule them all 00:07:06
   • Chapter 15. Keeping track of a stack 00:05:20
   • Chapter 15. Using async/await effectively 00:10:40
   • Chapter 15. Composing async operations 00:07:52
   • Chapter 15. Unit testing asynchronous code 00:07:43
   • Chapter 15. The awaitable pattern redux 00:10:10
   • Chapter 16. C# 5 bonus features and closing thoughts 00:08:50
   • Chapter 16. Logging 00:07:48
Show and hide more



9781617291340VE.c.in.depth.OR.part1.rar

9781617291340VE.c.in.depth.OR.part2.rar