O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

C# in Depth, 3rd Ed, Video Edition

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