C# in Depth, 3rd Ed, Video Edition

C# in Depth, 3rd Ed, Video Edition

by Jon Skeet
Released September 2013
Publisher(s): Manning Publications
ISBN: None

Explore a preview version of C# in Depth, 3rd Ed, Video Edition right now.

O’Reilly members get unlimited access to live online training experiences, plus books, videos, and digital content from 200+ publishers.

Start your free trial

Video description

"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

Table of contents

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

Product information

  • Title: C# in Depth, 3rd Ed, Video Edition
  • Author(s): Jon Skeet
  • Release date: September 2013
  • Publisher(s): Manning Publications
  • ISBN: None