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

Product information

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