book

Accelerated C# 2010

Name: Accelerated C# 2010
Author: Trey Nash
ISBN: 9781430225379

by Trey Nash

January 2010

Intermediate to advanced

655 pages

18h 30m

English

Apress

Read now

Unlock full access

Copyright
About the Author
About the Technical Reviewer
Acknowledgments
Preface
About This Book
1. C# Preview
1.1. Differences Between C# and C++1.1.1. C#1.1.2. C++1.1.3. CLR Garbage Collection1.2. Example of a C# Program1.3. Overview of Features Added in C# 2.01.4. Overview of Features Added in C# 3.01.5. Overview of New C# 4.0 Features1.6. Summary
2. C# and the CLR
2.1. The JIT Compiler in the CLR2.2. Assemblies and the Assembly Loader2.2.1. Minimizing the Working Set of the Application2.2.2. Naming Assemblies2.2.3. Loading Assemblies2.3. Metadata2.4. Cross-Language Compatibility2.5. Summary
3. C# Syntax Overview
3.1. C# Is a Strongly Typed Language3.2. Expressions3.3. Statements and Expressions3.4. Types and Variables3.4.1. Value Types3.4.1.1. Enumerations3.4.1.2. Flags Enumerations3.4.2. Reference Types3.4.3. Default Variable Initialization3.4.4. Implicitly Typed Local Variables3.4.5. Type Conversion3.4.5.1. Array Covariance3.4.5.2. Boxing Conversion3.4.6. as and is Operators3.4.7. Generics3.5. Namespaces3.5.1. Defining Namespaces3.5.2. Using Namespaces3.6. Control Flow3.6.1. if-else, while, do-while, and for3.6.2. switch3.6.3. foreach3.6.4. break, continue, goto, return, and throw3.7. Summary
4. Classes, Structs, and Objects
4.1. Class Definitions4.1.1. Fields4.1.2. Constructors4.1.3. Methods4.1.3.1. Static Methods4.1.3.2. Instance Methods4.1.4. Properties4.1.4.1. Declaring Properties4.1.4.2. Accessors4.1.4.3. Read-Only and Write-Only Properties4.1.4.4. Auto-Implemented Properties4.1.5. Encapsulation4.1.6. Accessibility4.1.7. Interfaces4.1.8. Inheritance4.1.8.1. Accessibility of Members4.1.8.2. Implicit Conversion and a Taste of Polymorphism4.1.8.3. Member Hiding4.1.8.4. The base Keyword4.1.9. sealed Classes4.1.10. abstract Classes4.1.11. Nested Classes4.1.12. Indexers4.1.13. partial Classes4.1.14. partial Methods4.1.15. Static Classes4.1.16. Reserved Member Names4.1.16.1. Reserved Names for Properties4.1.16.2. Reserved Names for Indexers4.1.16.3. Reserved Names for Destructors4.1.16.4. Reserved Names for Events4.2. Value Type Definitions4.2.1. Constructors4.2.2. The Meaning of this4.2.3. Finalizers4.2.4. Interfaces4.3. Anonymous Types4.4. Object Initializers4.5. Boxing and Unboxing4.5.1. When Boxing Occurs4.5.2. Efficiency and Confusion4.6. System.Object4.6.1. Equality and What It Means4.6.2. The IComparable Interface4.7. Creating Objects4.7.1. The new Keyword4.7.1.1. Using new with Value Types4.7.1.2. Using new with Class Types4.7.2. Field Initialization4.7.3. Static (Class) Constructors4.7.4. Instance Constructor and Creation Ordering4.8. Destroying Objects4.8.1. Finalizers4.8.2. Deterministic Destruction4.8.3. Exception Handling4.9. Disposable Objects4.9.1. The IDisposable Interface4.9.2. The using Keyword4.10. Method Parameter Types4.10.1. Value Arguments4.10.2. ref Arguments4.10.3. out Parameters4.10.4. param Arrays4.10.5. Method Overloading4.10.6. Optional Arguments4.10.7. Named Arguments4.11. Inheritance and Virtual Methods4.11.1. Virtual and Abstract Methods4.11.2. override and new Methods4.11.3. sealed Methods4.11.4. A Final Few Words on C# Virtual Methods4.12. Inheritance, Containment, and Delegation4.12.1. Choosing Between Interface and Class Inheritance4.12.2. Delegation and Composition vs. Inheritance4.13. Summary
5. Interfaces and Contracts
5.1. Interfaces Define Types5.2. Defining Interfaces5.2.1. What Can Be in an Interface?5.2.2. Interface Inheritance and Member Hiding5.3. Implementing Interfaces5.3.1. Implicit Interface Implementation5.3.2. Explicit Interface Implementation5.3.3. Overriding Interface Implementations in Derived Classes5.3.4. Beware of Side Effects of Value Types Implementing Interfaces5.4. Interface Member Matching Rules5.5. Explicit Interface Implementation with Value Types5.6. Versioning Considerations5.7. Contracts5.7.1. Contracts Implemented with Classes5.7.2. Interface Contracts5.8. Choosing Between Interfaces and Classes5.9. Summary

6. Overloading Operators
6.1. Just Because You Can Doesn't Mean You Should6.2. Types and Formats of Overloaded Operators6.3. Operators Shouldn't Mutate Their Operands6.4. Does Parameter Order Matter?6.5. Overloading the Addition Operator6.6. Operators That Can Be Overloaded6.6.1. Comparison Operators6.6.2. Conversion Operators6.6.3. Boolean Operators6.7. Summary
7. Exception Handling and Exception Safety
7.1. How the CLR Treats Exceptions7.2. Mechanics of Handling Exceptions in C#7.2.1. Throwing Exceptions7.2.2. Changes with Unhandled Exceptions Starting with .NET 2.07.2.3. Syntax Overview of the try, catch, and finally Statements7.2.4. Rethrowing Exceptions and Translating Exceptions7.2.5. Exceptions Thrown in finally Blocks7.2.6. Exceptions Thrown in Finalizers7.2.7. Exceptions Thrown in Static Constructors7.3. Who Should Handle Exceptions?7.4. Avoid Using Exceptions to Control Flow7.5. Achieving Exception Neutrality7.5.1. Basic Structure of Exception-Neutral Code7.5.2. Constrained Execution Regions7.5.3. Critical Finalizers and SafeHandle7.6. Creating Custom Exception Classes7.7. Working with Allocated Resources and Exceptions7.8. Providing Rollback Behavior7.9. Summary
8. Working with Strings
8.1. String Overview8.2. String Literals8.3. Format Specifiers and Globalization8.3.1. Object.ToString, IFormattable, and CultureInfo8.3.2. Creating and Registering Custom CultureInfo Types8.3.3. Format Strings8.3.4. Console.WriteLine and String.Format8.3.5. Examples of String Formatting in Custom Types8.3.6. ICustomFormatter8.3.7. Comparing Strings8.4. Working with Strings from Outside Sources8.5. StringBuilder8.6. Searching Strings with Regular Expressions8.6.1. Searching with Regular Expressions8.6.2. Searching and Grouping8.6.3. Replacing Text with Regex8.6.4. Regex Creation Options8.7. Summary
9. Arrays, Collection Types, and Iterators
9.1. Introduction to Arrays9.1.1. Implicitly Typed Arrays9.1.2. Type Convertibility and Covariance9.1.3. Sortability and Searchability9.1.4. Synchronization9.1.5. Vectors vs. Arrays9.2. Multidimensional Rectangular Arrays9.3. Multidimensional Jagged Arrays9.4. Collection Types9.4.1. Comparing ICollection<T> with ICollection9.4.2. Collection Synchronization9.4.3. Lists9.4.4. Dictionaries9.4.5. Sets9.4.6. System.Collections.ObjectModel9.4.7. Efficiency9.5. IEnumerable<T>, IEnumerator<T>, IEnumerable, and IEnumerator9.5.1. Types That Produce Collections9.6. Iterators9.6.1. Forward, Reverse, and Bidirectional Iterators9.7. Collection Initializers9.8. Summary
10. Delegates, Anonymous Functions, and Events
10.1. Overview of Delegates10.2. Delegate Creation and Use10.2.1. Single Delegate10.2.2. Delegate Chaining10.2.3. Iterating Through Delegate Chains10.2.4. Unbound (Open Instance) Delegates10.3. Events10.4. Anonymous Methods10.4.1. Captured Variables and Closures10.4.2. Beware the Captured Variable Surprise10.4.3. Anonymous Methods as Delegate Parameter Binders10.5. The Strategy Pattern10.6. Summary
11. Generics
11.1. Difference Between Generics and C++ Templates11.2. Efficiency and Type Safety of Generics11.3. Generic Type Definitions and Constructed Types11.3.1. Generic Classes and Structs11.3.2. Generic Interfaces11.3.3. Generic Methods11.3.4. Generic Delegates11.3.5. Generic Type Conversion11.3.6. Default Value Expression11.3.7. Nullable Types11.3.8. Constructed Types Control Accessibility11.3.9. Generics and Inheritance11.4. Constraints11.4.1. Constraints on Nonclass Types11.5. Co- and Contravariance11.5.1. Covariance11.5.2. Contravariance11.5.3. Invariance11.5.4. Variance and Delegates11.6. Generic System Collections11.7. Generic System Interfaces11.8. Select Problems and Solutions11.8.1. Conversion and Operators within Generic Types11.8.2. Creating Constructed Types Dynamically11.9. Summary
12. Threading in C#
12.1. Threading in C# and .NET12.1.1. Starting Threads12.1.1.1. Passing Data to New Threads12.1.1.2. Using ParameterizedThreadStart12.1.2. The IOU Pattern and Asynchronous Method Calls12.1.3. States of a Thread12.1.4. Terminating Threads12.1.5. Halting Threads and Waking Sleeping Threads12.1.6. Waiting for a Thread to Exit12.1.7. Foreground and Background Threads12.1.8. Thread-Local Storage12.1.9. How Unmanaged Threads and COM Apartments Fit In12.2. Synchronizing Work Between Threads12.2.1. Lightweight Synchronization with the Interlocked Class12.2.2. SpinLock Class12.2.3. Monitor Class12.2.3.1. Beware of Boxing12.2.3.2. Pulse and Wait12.2.4. Locking Objects12.2.4.1. ReaderWriterLock12.2.4.2. ReaderWriterLockSlim12.2.4.3. Mutex12.2.5. Semaphore12.2.6. Events12.2.7. Win32 Synchronization Objects and WaitHandle12.3. Using ThreadPool12.3.1. Asynchronous Method Calls12.3.2. Timers12.4. Concurrent Programming12.4.1. Task Class12.4.2. Parallel Class12.4.3. Easy Entry to the Thread Pool12.5. Thread-Safe Collection Classes12.6. Summary
13. In Search of C# Canonical Forms
13.1. Reference Type Canonical Forms13.1.1. Default to sealed Classes13.1.2. Use the Non-Virtual Interface (NVI) Pattern13.1.3. Is the Object Cloneable?13.1.4. Is the Object Disposable?13.1.5. Does the Object Need a Finalizer?13.1.6. What Does Equality Mean for This Object?13.1.6.1. Reference Types and Identity Equality13.1.6.2. Value Equality13.1.6.3. Overriding Object.Equals for Reference Types13.1.7. If You Override Equals, Override GetHashCode Too13.1.8. Does the Object Support Ordering?13.1.9. Is the Object Formattable?13.1.10. Is the Object Convertible?13.1.11. Prefer Type Safety at All Times13.1.12. Using Immutable Reference Types13.2. Value Type Canonical Forms13.2.1. Override Equals for Better Performance13.2.2. Do Values of This Type Support Any Interfaces?13.2.3. Implement Type-Safe Forms of Interface Members and Derived Methods13.3. Summary13.3.1. Checklist for Reference Types13.3.2. Checklist for Value Types
14. Extension Methods
14.1. Introduction to Extension Methods14.1.1. How Does the Compiler Find Extension Methods?14.1.2. Under the Covers14.1.3. Code Readability versus Code Understandability14.2. Recommendations for Use14.2.1. Consider Extension Methods Over Inheritance14.2.2. Isolate Extension Methods in Separate Namespace14.2.3. Changing a Type's Contract Can Break Extension Methods14.3. Transforms14.4. Operation Chaining14.5. Custom Iterators14.5.1. Borrowing from Functional Programming14.6. The Visitor Pattern14.7. Summary
15. Lambda Expressions
15.1. Introduction to Lambda Expressions15.1.1. Lambda Expressions and Closures15.1.1.1. Closures in C# 1.015.1.1.2. Closures in C# 2.015.1.2. Lambda Statements15.2. Expression Trees15.2.1. Operating on Expressions15.2.2. Functions as Data15.3. Useful Applications of Lambda Expressions15.3.1. Iterators and Generators Revisited15.3.2. More on Closures (Variable Capture) and Memoization15.3.3. Currying15.3.4. Anonymous Recursion15.4. Summary
16. LINQ: Language Integrated Query
16.1. A Bridge to Data16.1.1. Query Expressions16.1.2. Extension Methods and Lambda Expressions Revisited16.2. Standard Query Operators16.3. C# Query Keywords16.3.1. The from Clause and Range Variables16.3.2. The join Clause16.3.3. The where Clause and Filters16.3.4. The orderby Clause16.3.5. The select Clause and Projection16.3.6. The let Clause16.3.7. The group Clause16.3.8. The into Clause and Continuations16.4. The Virtues of Being Lazy16.4.1. C# Iterators Foster Laziness16.4.2. Subverting Laziness16.4.3. Executing Queries Immediately16.4.4. Expression Trees Revisited16.5. Techniques from Functional Programming16.5.1. Custom Standard Query Operators and Lazy Evaluation16.5.2. Replacing foreach Statements16.6. Summary
17. Dynamic Types
17.1. What does dynamic Mean?17.2. How Does dynamic Work?17.2.1. The Great Unification17.2.2. Call Sites17.2.3. Objects with Custom Dynamic Behavior17.2.4. Efficiency17.2.5. Boxing with Dynamic17.3. Dynamic Conversions17.3.1. Implicit Dynamic Expressions Conversion17.4. Dynamic Overload Resolution17.5. Dynamic Inheritance17.5.1. You Cannot Derive from dynamic17.5.2. You Cannot Implement dynamic Interfaces17.5.3. You Can Derive From Dynamic Base Types17.6. Duck Typing in C#17.7. Limitations of dynamic Types17.8. ExpandoObject: Creating Objects Dynamically17.9. Summary

Content preview from Accelerated C# 2010

About the Author

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781430225379Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Accelerated C# 2010

by Trey Nash

About the Author

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.