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