book

C# 3.0 in a Nutshell, 3rd Edition

Name: C# 3.0 in a Nutshell, 3rd Edition
ISBN: 9780596527570

by Joseph Albahari, Ben Albahari

September 2007

Intermediate to advanced

858 pages

21h 2m

English

O'Reilly Media, Inc.

Read now

Unlock full access

A Note Regarding Supplemental Files
Preface
Intended AudienceHow This Book Is OrganizedWhat You Need to Use This BookConventions Used in This BookUsing Code ExamplesWe’d Like to Hear from YouSafari® Books OnlineAcknowledgmentsJoseph AlbahariBen Albahari
1. Introducing C# and the .NET Framework
1.1. Object Orientation1.2. Type Safety1.3. Memory Management1.4. Platform Support1.5. C#’s Relationship with the CLR1.6. The CLR and .NET Framework1.7. What’s New in C# 3.0
2. C# Language Basics
2.1. A First C# Program2.1.1. Compilation2.2. Syntax2.2.1. Identifiers and Keywords2.2.1.1. Avoiding conflicts2.2.1.2. Contextual keywords2.2.2. Literals, Punctuators, and Operators2.2.3. Comments2.3. Type Basics2.3.1. Predefined Type Examples2.3.2. Custom Type Examples2.3.2.1. Members of a type2.3.2.2. Symmetry of predefined types and custom types2.3.2.3. Constructors and instantiation2.3.2.4. Instance versus static members2.3.2.5. The public keyword2.3.3. Conversions2.3.4. Value Types Versus Reference Types2.3.4.1. Value types2.3.4.2. Reference types2.3.4.3. Null2.3.4.4. Storage overhead2.3.5. Predefined Type Taxonomy2.4. Numeric Types2.4.1. Numeric Literals2.4.1.1. Numeric literal type inference2.4.1.2. Numeric suffixes2.4.2. Numeric Conversions2.4.2.1. Integral to integral conversions2.4.2.2. Floating-point to floating-point conversions2.4.2.3. Floating-point to integral conversions2.4.2.4. Decimal conversions2.4.3. Arithmetic Operators2.4.4. Increment and Decrement Operators2.4.5. Specialized Integral Operations2.4.5.1. Integral division2.4.5.2. Integral overflow2.4.5.3. Integral arithmetic overflow check operators2.4.5.4. Overflow checking for constant expressions2.4.5.5. Bitwise operators2.4.6. Eight- and 16-Bit Integrals2.4.7. Special Float and Double Values2.4.8. double Versus decimal2.4.9. Real Number Rounding Errors2.5. Boolean Type and Operators2.5.1. Bool Conversions2.5.2. Equality and Comparison Operators2.5.3. Conditional Operators2.6. Strings and Characters2.6.1. Char conversions2.6.2. String Type2.6.2.1. String concatenation2.6.2.2. String comparisons2.7. Arrays2.7.1. Default Element Initialization2.7.1.1. Value types versus reference types2.7.2. Multidimensional Arrays2.7.2.1. Rectangular arrays2.7.2.2. Jagged arrays2.7.3. Simplified Array Initialization Expressions2.7.4. Bounds Checking2.8. Variables and Parameters2.8.1. The Stack and the Heap2.8.1.1. Stack2.8.1.2. Heap2.8.2. Definite Assignment2.8.3. Default Values2.8.4. Parameters2.8.4.1. Passing arguments by value2.8.4.2. The ref modifier2.8.4.3. The out modifier2.8.4.4. Implications of passing by reference2.8.4.5. The params modifier2.8.5. var—Implicitly Typed Local Variables (C# 3.0)2.9. Expressions and Operators2.9.1. Primary Expressions2.9.2. Void Expressions2.9.3. Assignment Expressions2.9.4. Operator Precedence and Associativity2.9.4.1. Precedence2.9.4.2. Left-associative operators2.9.4.3. Right-associative operators2.9.5. Operator Table2.10. Statements2.10.1. Declaration Statements2.10.1.1. Local variables2.10.2. Expression Statements2.10.3. Selection Statements2.10.3.1. The if statement2.10.3.2. The else clause2.10.3.3. Changing the flow of execution with braces2.10.3.4. The switch statement2.10.4. Iteration Statements2.10.4.1. while and do-while loops2.10.4.2. for loops2.10.4.3. foreach loops2.10.5. Jump Statements2.10.5.1. The break statement2.10.5.2. The continue statement2.10.5.3. The goto statement2.10.5.4. The return statement2.10.5.5. The throw statement2.10.6. Miscellaneous Statements2.11. Namespaces2.11.1. The namespace Keyword2.11.2. Fully Qualified Names2.11.3. The using Directive2.11.4. The Global Namespace2.11.5. Rules Within a Namespace2.11.5.1. Name scoping2.11.5.2. Name hiding2.11.5.3. Repeated namespaces2.11.5.4. Nested using directive2.11.6. Aliasing Types and Namespaces2.11.7. Advanced Namespace Features2.11.7.1. Extern2.11.7.2. Namespace alias qualifiers
3. Creating Types in C#
3.1. Classes3.1.1. Fields3.1.1.1. The readonly modifier3.1.1.2. Field initialization3.1.1.3. Declaring multiple fields together3.1.2. Methods3.1.2.1. Overloading methods3.1.2.2. Pass-by-value versus pass-by-reference3.1.3. Instance Constructors3.1.3.1. Overloading constructors3.1.3.2. Implicit parameterless constructors3.1.3.3. Constructor and field initialization order3.1.3.4. Nonpublic constructors3.1.4. Object Initializers (C# 3.0)3.1.5. The this Reference3.1.6. Properties3.1.6.1. Read-only and calculated properties3.1.6.2. Automatic properties (C# 3.0)3.1.6.3. get and set accessibility3.1.6.4. CLR property implementation3.1.7. Indexers3.1.7.1. Implementing an indexer3.1.7.2. CLR indexer implementation3.1.8. Constants3.1.9. Static Constructors3.1.9.1. Static field initialization order3.1.9.2. Nondeterminism of static constructors3.1.10. Static Classes3.1.11. Finalizers3.1.12. Partial Types and Methods3.1.12.1. Partial methods (C# 3.0)3.2. Inheritance3.2.1. Polymorphism3.2.2. Casting3.2.2.1. Upcasting3.2.2.2. Downcasting3.2.2.3. The as operator3.2.2.4. The is operator3.2.3. Virtual Function Members3.2.4. Abstract Classes and Abstract Members3.2.5. Hiding Inherited Members3.2.5.1. new versus virtual3.2.6. Sealing Functions and Classes3.2.7. The base Keyword3.2.8. Constructors and Inheritance3.2.8.1. Implicit calling of the parameterless base class constructor3.2.8.2. Constructor and field initialization order3.2.9. Overloading and Resolution3.3. The object Type3.3.1. Boxing and Unboxing3.3.1.1. Copying semantics of boxing and unboxing3.3.2. Static and Dynamic Type Checking3.3.3. The GetType Method and typeof Operator3.3.4. The ToString Method3.3.5. Object Member Listing3.4. Structs3.4.1. Struct Construction Semantics3.5. Access Modifiers3.5.1. Examples3.5.2. Accessibility Capping3.5.3. Restrictions on Access Modifiers3.6. Interfaces3.6.1. Extending an Interface3.6.2. Explicit Interface Implementation3.6.3. Implementing Interface Members Virtually3.6.4. Reimplementing an Interface in a Subclass3.6.4.1. Alternatives to interface reimplementation3.6.5. Interfaces and Boxing3.6.6. Writing a Class Versus an Interface3.7. Enums3.7.1. Enum Conversions3.7.2. Flags Enumerations3.7.3. Enum Operators3.7.4. Type-Safety Issues3.8. Nested Types3.9. Generics3.9.1. Generic Types3.9.2. Why Generics Exist3.9.3. Generic Methods3.9.4. Declaring Generic Parameters3.9.5. typeof and Generics3.9.6. The default Generic Value3.9.7. Generic Constraints3.9.8. Generics and Covariance3.9.8.. A comparison of generic types and array types3.9.9. Subclassing Generic Types3.9.10. Self-Referencing Generic Declarations3.9.11. Static Data3.9.12. C# Generics Versus C++ Templates
4. Advanced C#
4.1. Delegates4.1.1. Writing Plug-in Methods with Delegates4.1.2. Multicast Delegates4.1.2.1. Multicast delegate example4.1.3. Instance Method Targets4.1.4. Generic Delegate Types4.1.5. Delegates Versus Interfaces4.1.6. Delegate Compatibility4.1.6.1. Type compatibility4.1.6.2. Parameter compatibility4.1.6.3. Return type compatibility4.2. Events4.2.1. Standard Event Pattern4.2.2. Event Accessors4.2.3. Event Modifiers4.3. Lambda Expressions (C# 3.0)4.3.1. Explicitly Specifying Lambda Parameter Types4.3.2. Generic Lambda Expressions and the Func Delegates4.3.3. Outer Variables4.4. Anonymous Methods4.5. try Statements and Exceptions4.5.1. The catch Clause4.5.2. The finally Block4.5.2.1. The using statement4.5.3. Throwing Exceptions4.5.3.1. Rethrowing an exception4.5.4. Key Properties of System.Exception4.5.5. Common Exception Types4.5.6. Common Patterns4.5.6.1. The try method pattern4.5.6.2. The atomicity pattern4.5.6.3. Alternatives to exceptions4.6. Enumeration and Iterators4.6.1. Enumeration4.6.2. Iterators4.6.3. Iterator Semantics4.6.4. Composing Sequences4.6.5. Collection Initializers4.7. Nullable Types4.7.1. Null Basics4.7.1.1. Nullable<T> struct4.7.1.2. Implicit and explicit nullable conversions4.7.1.3. Boxing and unboxing nullable values4.7.2. Lifted Operators4.7.2.1. Equality operators (== !=)4.7.2.2. Relational operators (< <= >= >)4.7.2.3. All other operators (+ − * / % & | ^ << >> + ++ − -- ! ∼)4.7.2.4. Mixing nullable and nonnullable operators4.7.3. bool?4.7.4. Null Coalescing Operator4.7.5. Scenarios for Nullable Types4.7.6. Alternatives to Nullable Types4.8. Operator Overloading4.8.1. Overview4.8.2. Operator Functions4.8.3. Overloading Equality and Comparison Operators4.8.4. Custom Implicit and Explicit Conversions4.8.5. Overloading true and false4.9. Extension Methods (C# 3.0)4.9.1. Extension Method Chaining4.9.2. Ambiguity and Resolution4.9.2.1. Namespaces4.9.2.2. Extension methods versus instance methods4.9.2.3. Extension methods versus extension methods4.9.3. Extension Methods on Interfaces4.10. Anonymous Types (C# 3.0)4.11. Attributes4.11.1. Attribute Classes4.11.2. Named and Positional Parameters4.11.3. Attribute Targets4.11.4. Specifying Multiple Attributes4.12. Unsafe Code and Pointers4.12.1. Pointer Basics4.12.2. Unsafe Code4.12.3. The fixed Statement4.12.4. The Pointer-to-Member Operator4.12.5. Arrays4.12.5.1. The stackalloc keyword4.12.5.2. Fixed-size buffers4.12.6. void*4.12.7. Pointers to Unmanaged Code4.13. Preprocessor Directives4.13.1. Conditional Attributes4.13.2. Pragma Warning4.14. XML Documentation4.14.1. Predefined XML Tags4.14.2. User-Defined Tags4.14.3. Type or Member Cross-References
5. Framework Overview
5.1. The CLR and Core Framework5.1.1. System Types5.1.2. Text Processing5.1.3. Collections5.1.4. Queries5.1.5. XML5.1.6. Streams and I/O5.1.7. Networking5.1.8. Serialization5.1.9. Assemblies, Reflection, and Attributes5.1.10. Security5.1.11. Threading and Asynchronous Methods5.1.12. Application Domains5.1.13. Native Interoperability5.1.14. Diagnostics5.2. Applied Technologies5.2.1. User Interface Technologies5.2.1.1. ASP.NET5.2.1.2. Windows Presentation Foundation (WPF)5.2.1.3. Windows Forms5.2.2. Backend Technologies5.2.2.1. ADO.NET5.2.2.2. Windows Workflow5.2.2.3. COM+ and MSMQ5.2.3. Distributed System Technologies5.2.3.1. Windows Communication Foundation (WCF)5.2.3.2. Remoting and Web Services5.2.3.3. CardSpace
6. Framework Fundamentals
6.1. String and Text Handling6.1.1. char6.1.2. String6.1.2.1. Constructing strings6.1.2.2. Null and empty strings6.1.2.3. Accessing characters within a string6.1.2.4. Searching within strings6.1.2.5. Manipulating strings6.1.2.6. Splitting and joining strings6.1.2.7. String.Format and composite format strings6.1.3. Comparing Strings6.1.3.1. Ordinal versus culture comparison6.1.3.2. Equality comparison6.1.3.3. Order comparison6.1.4. StringBuilder6.1.5. Text Encodings and Unicode6.1.5.1. Obtaining an Encoding object6.1.5.2. Encoding for file and stream I/O6.1.5.3. Encoding to byte arrays6.1.5.4. UTF-16 and strings6.2. Dates and Times6.2.1. TimeSpan6.2.2. DateTime and DateTimeOffset6.2.2.1. Choosing between DateTime and DateTimeOffset6.2.2.2. Constructing a DateTime6.2.2.3. Constructing a DateTimeOffset6.2.2.4. The current DateTime/DateTimeOffset6.2.2.5. Working with dates and times6.2.2.6. Formatting and parsing6.2.2.7. Null DateTime and DateTimeOffset values6.3. Dates and Time Zones6.3.1. DateTime and Time Zones6.3.2. DateTimeOffset and Time Zones6.3.3. TimeZone and TimeZoneInfo6.3.3.1. TimeZone6.3.3.2. TimeZoneInfo6.3.4. Daylight Saving and DateTime6.4. Formatting and Parsing6.4.1. ToString and Parse6.4.2. Format Providers6.4.2.1. Format providers and CultureInfo6.4.2.2. Using NumberFormatInfo or DateTimeFormatInfo6.4.2.3. Composite formatting6.4.2.4. Parsing with format providers6.4.2.5. IFormatProvider and ICustomFormatter6.5. Standard Format Strings and Parsing Flags6.5.1. Numeric Format Strings6.5.2. NumberStyles6.5.3. DateTime Format Strings6.5.3.1. Parsing and misparsing DateTimes6.5.4. DateTimeStyles6.5.5. Enum Format Strings6.6. Other Conversion Mechanisms6.6.1. Convert6.6.1.1. Rounding real to integral conversions6.6.1.2. Parsing numbers in base 2, 8, and 166.6.1.3. Dynamic conversions6.6.1.4. Base 64 conversions6.6.2. XmlConvert6.6.3. Type Converters6.6.4. BitConverter6.7. Working with Numbers6.7.1. Conversions6.7.2. Math6.7.3. Random6.8. Enums6.8.1. Enum Conversions6.8.1.1. enum to integral conversions6.8.1.2. Integral to enum conversions6.8.1.3. String conversions6.8.2. Enumerating Enum Values6.8.3. How Enums Work6.9. The Guid Struct6.10. Equality Comparison6.10.1. Referential Versus Value Equality6.10.2. Standard Equality Protocols6.10.2.1. == and !=6.10.2.2. The virtual Object.Equals method6.10.2.3. The static object.Equals method6.10.2.4. The static object.ReferenceEquals method6.10.2.5. The IEquatable<T> interface6.10.2.6. When Equals and == are not equal6.10.3. Equality and Custom Types6.10.3.1. How to override equality semantics6.10.3.2. Overriding GetHashCode6.10.3.3. Overriding Equals6.10.3.4. Overloading == and !=6.10.3.5. Implementing IEquatable<T>6.10.3.6. An example: The Area struct6.10.3.7. Pluggable equality comparers6.11. Order Comparison6.11.1. IComparable6.11.1.1. IComparable versus Equals6.11.2. < and >6.11.3. Implementing the IComparable Interfaces6.12. Utility Classes6.12.1. Console6.12.2. Environment6.12.3. Process
7. Collections
7.1. Enumeration7.1.1. IEnumerable and IEnumerator7.1.2. IEnumerable<T> and IEnumerator<T>7.1.3. Implementing the Enumeration Interfaces7.1.4. IDictionaryEnumerator7.2. The ICollection and IList Interfaces7.2.1. ICollection and ICollection<T>7.2.2. IList and IList<T>7.3. The Array Class7.3.1. Construction and Indexing7.3.2. Enumeration7.3.3. Length and Rank7.3.4. Searching7.3.5. Sorting7.3.6. Reversing Elements7.3.7. Copying, Converting, and Resizing7.4. Lists, Queues, Stacks, and Sets7.4.1. List<T> and ArrayList7.4.2. LinkedList<T>7.4.3. Queue and Queue<T>7.4.4. Stack and Stack<T>7.4.5. BitArray7.4.6. HashSet<T>7.5. Dictionaries7.5.1. IDictionary and IDictionary<TKey,TValue>7.5.2. Dictionary<TKey,TValue> and Hashtable7.5.3. OrderedDictionary7.5.4. ListDictionary and HybridDictionary7.5.5. Sorted Dictionaries7.6. Customizable Collections and Proxies7.6.1. Collection<T> and CollectionBase7.6.2. KeyedCollection<TKey,TItem> and DictionaryBase7.6.3. ReadOnlyCollection<T>7.7. Plugging in Equality and Order7.7.1. IEqualityComparer and EqualityComparer7.7.2. IComparer and Comparer7.7.3. StringComparer
8. LINQ Queries
8.1. Getting Started8.2. Lambda Queries8.2.1. Chaining Query Operators8.2.1.1. Why extension methods are important8.2.2. Composing Lambda Expressions8.2.2.1. Lambda expressions and Func signatures8.2.2.2. Lambda expressions and element typing8.2.3. Natural Ordering8.2.4. Other Operators8.3. Comprehension Queries8.3.1. Iteration Variables8.3.2. Comprehension Syntax Versus SQL Syntax8.3.3. Comprehension Syntax Versus Lambda Syntax8.3.4. Mixed Syntax Queries8.4. Deferred Execution8.4.1. Reevaluation8.4.2. Outer Variables8.4.3. How Deferred Execution Works8.4.4. Chaining Decorators8.4.5. How Queries Are Executed8.5. Subqueries8.5.1. Subqueries and Deferred Execution8.6. Composition Strategies8.6.1. Progressive Query Building8.6.2. The into Keyword8.6.2.1. Scoping rules8.6.3. Wrapping Queries8.7. Projection Strategies8.7.1. Object Initializers8.7.2. Anonymous Types8.7.3. The let Keyword8.8. Interpreted Queries8.8.1. How Interpreted Queries Work8.8.1.1. Execution8.8.2. Combining Interpreted and Local Queries8.8.3. AsEnumerable8.9. LINQ to SQL8.9.1. LINQ to SQL Entity Classes8.9.2. DataContext8.9.3. Automatic Entity Generation8.9.4. Associations8.9.5. Deferred Execution with LINQ to SQL8.9.6. DataLoadOptions8.9.6.1. Specifying a filter in advance8.9.6.2. Eager loading8.9.7. Updates8.10. Building Query Expressions8.10.1. Delegates Versus Expression Trees8.10.1.1. Compiling expression trees8.10.1.2. AsQueryable8.10.2. Expression Trees8.10.2.1. The Expression DOM

9. LINQ Operators
9.1. Overview9.1.1. Collection → Collection9.1.1.1. Filtering9.1.1.2. Projecting9.1.1.3. Joining9.1.1.4. Ordering9.1.1.5. Grouping9.1.1.6. Set operators9.1.1.7. Conversion methods: Import9.1.1.8. Conversion methods: Export9.1.2. Collection → Noncollection9.1.2.1. Element operators9.1.2.2. Aggregation methods9.1.2.3. Quantifiers9.1.3. Noncollection → Collection9.1.3.1. Generation methods9.2. Filtering9.2.1. Where9.2.1.1. Comprehension syntax9.2.1.2. Enumerable.Where implementation9.2.1.3. Overview9.2.1.4. Indexed filtering9.2.1.5. Where in LINQ to SQL9.2.2. Take and Skip9.2.3. TakeWhile and SkipWhile9.2.4. Distinct9.3. Projecting9.3.1. Select9.3.1.1. Comprehension syntax9.3.1.2. Enumerable implementation9.3.1.3. Overview9.3.1.4. Indexed projection9.3.1.5. Select subqueries and object hierarchies9.3.1.6. Subqueries and joins in LINQ to SQL9.3.1.7. Projecting into concrete types9.3.2. SelectMany9.3.2.1. Comprehension syntax9.3.2.2. Enumerable implementation9.3.2.3. Overview9.3.2.4. Outer iteration variables9.3.2.5. Thinking in comprehension syntax9.3.2.6. Joining with SelectMany9.3.2.7. SelectMany in LINQ to SQL9.3.2.8. Outer joins with SelectMany9.4. Joining9.4.1. Join and GroupJoin9.4.1.1. Join arguments9.4.1.2. GroupJoin arguments9.4.1.3. Comprehension syntax9.4.1.4. Overview9.4.1.5. Join9.4.1.6. Joining on multiple keys9.4.1.7. Joining in lambda syntax9.4.1.8. GroupJoin9.4.1.9. Flat outer joins9.4.1.10. Joining with lookups9.4.1.11. Enumerable implementations9.5. Ordering9.5.1. OrderBy, OrderByDescending, ThenBy, and ThenByDescending9.5.1.1. OrderBy and OrderByDescending arguments9.5.1.2. ThenBy and ThenByDescending arguments9.5.1.3. Comprehension syntax9.5.1.4. Overview9.5.1.5. Comparers and collations9.5.1.6. IOrderedEnumerable and IOrderedQueryable9.6. Grouping9.6.1. GroupBy9.6.1.1. Comprehension syntax9.6.1.2. Overview9.6.1.3. GroupBy in LINQ to SQL9.6.1.4. Grouping by multiple keys9.6.1.5. Custom equality comparers9.7. Set Operators9.7.1. Concat and Union9.7.2. Intersect and Except9.8. Conversion Methods9.8.1. OfType and Cast9.8.2. ToArray, ToList, ToDictionary, and ToLookup9.8.3. AsEnumerable and AsQueryable9.9. Element Operators9.9.1. First, Last, and Single9.9.2. ElementAt9.9.3. DefaultIfEmpty9.10. Aggregation Methods9.10.1. Count and LongCount9.10.2. Min and Max9.10.3. Sum and Average9.10.4. Aggregate9.11. Quantifiers9.11.1. Contains and Any9.11.2. All and SequenceEqual9.12. Generation Methods9.12.1. Empty9.12.2. Range and Repeat
10. LINQ to XML
10.1. Architectural Overview10.1.1. What Is a DOM?10.1.2. The LINQ to XML DOM10.2. X-DOM Overview10.2.1. Loading and Parsing10.2.2. Saving and Serializing10.3. Instantiating an X-DOM10.3.1. Functional Construction10.3.2. Specifying Content10.3.3. Automatic Deep Cloning10.4. Navigating and Querying10.4.1. Child Node Navigation10.4.1.1. FirstNode, LastNode, and Nodes10.4.1.2. Retrieving elements10.4.1.3. Retrieving a single element10.4.1.4. Recursive functions10.4.2. Parent Navigation10.4.3. Peer Node Navigation10.4.4. Attribute Navigation10.5. Updating an X-DOM10.5.1. Simple Value Updates10.5.2. Updating Child Nodes and Attributes10.5.3. Updating Through the Parent10.5.3.1. Removing a sequence of nodes or attributes10.6. Working with Values10.6.1. Setting Values10.6.2.. Getting Values10.6.3. Values and Mixed Content Nodes10.6.4. Automatic XText Concatenation10.7. Documents and Declarations10.7.1. XDocument10.7.2. XML Declarations10.7.2.1. Writing a declaration to a string10.8. Names and Namespaces10.8.1. Namespaces in XML10.8.1.1. Prefixes10.8.1.2. Attributes10.8.2. Specifying Namespaces in the X-DOM10.8.3. The X-DOM and Default Namespaces10.8.4. Prefixes10.9. Annotations10.10. Projecting into an X-DOM10.10.1. Eliminating Empty Elements10.10.2. Streaming a Projection10.10.3. Transforming an X-DOM10.10.3.1. Advanced transformations
11. Other XML Technologies
11.1. XmlReader11.1.1. Reading Nodes11.1.2. Reading Elements11.1.2.1. Optional elements11.1.2.2. Random element order11.1.2.3. Empty elements11.1.2.4. Other ReadXXX methods11.1.3. Reading Attributes11.1.3.1. Attribute nodes11.1.4. Namespaces and Prefixes11.2. XmlWriter11.2.1. Writing Attributes11.2.2. Writing Other Node Types11.2.3. Namespaces and Prefixes11.3. Patterns for Using XmlReader/XmlWriter11.3.1. Working with Hierarchical Data11.3.2. Mixing XmlReader/XmlWriter with an X-DOM11.3.2.1. Using XmlReader with XElement11.3.2.2. Using XmlWriter with XElement11.4. XmlDocument11.4.1. Loading and Saving an XmlDocument11.4.2. Traversing an XmlDocument11.4.3. InnerText and InnerXml11.4.4. Creating and Manipulating Nodes11.4.5. Namespaces11.5. XPath11.5.1. Common XPath Operators11.5.2. XPathNavigator11.5.3. Querying with Namespaces11.5.4. XPathDocument11.6. XSD and Schema Validation11.6.1. Performing Schema Validation11.6.1.1. Validating with an XmlReader11.6.1.2. Validating an X-DOM or XmlDocument11.7. XSLT
12. Disposal and Garbage Collection
12.1. IDisposable, Dispose, and Close12.1.1. Standard Disposal Semantics12.1.1.1. Close and Stop12.1.2. When to Dispose12.1.3. Opt-in Disposal12.2. Garbage Collection and Finalizers12.3. Calling Dispose from a Finalizer12.4. How the Garbage Collector Works12.4.1. Optimization Techniques12.4.2. Forcing Garbage Collection12.5. Alternatives to Garbage Collection
13. Streams and I/O
13.1. Stream Architecture13.2. Using Streams13.2.1. Reading and Writing13.2.2. Seeking13.2.3. Closing and Flushing13.2.4. Timeouts13.2.5. Thread Safety13.2.6. Backing Store Streams13.2.7. FileStream13.2.7.1. Constructing a FileStream13.2.7.2. Specifying a filename13.2.7.3. Specifying a FileMode13.2.7.4. Advanced FileStream features13.2.8. MemoryStream13.2.9. PipeStream13.2.9.1. Named pipes13.2.9.2. Anonymous pipes13.2.10. BufferedStream13.3. Stream Adapters13.3.1. Text Adapters13.3.1.1. StreamReader and StreamWriter13.3.1.2. Character encodings13.3.1.3. StringReader and StringWriter13.3.2. Binary Adapters13.3.3. Closing and Disposing Stream Adapters13.4. File and Directory Operations13.4.1. The File Class13.4.1.1. Compression and encryption attributes13.4.1.2. File security13.4.2. The Directory Class13.4.3. FileInfo and DirectoryInfo13.4.4. Path13.4.5. Special Folders13.4.6. Querying Volume Information13.4.7. Catching Filesystem Events13.5. Compression13.5.1. Compressing in Memory13.6. Isolated Storage13.6.1. Isolation Types13.6.2. Reading and Writing Isolated Storage13.6.3. Store Location13.6.4. Enumerating Isolated Storage
14. Networking
14.1. Network Architecture14.2. Addresses and Ports14.3. URIs14.4. Request/Response Architecture14.4.1. WebClient14.4.2. WebRequest and WebResponse14.4.3. Proxies14.4.4. Authentication14.4.4.1. CredentialCache14.4.5. Concurrency14.4.6. Exception Handling14.5. HTTP-Specific Support14.5.1. Headers14.5.2. Query Strings14.5.3. Uploading Form Data14.5.4. Cookies14.5.5. Forms Authentication14.5.6. SSL14.6. Writing an HTTP Server14.7. Using FTP14.8. Using DNS14.9. Sending Mail with SmtpClient14.10. Using TCP14.10.1. Concurrency14.11. Receiving POP3 Mail with TCP
15. Serialization
15.1. Serialization Concepts15.1.1. Serialization Engines15.1.1.1. Why three engines?15.1.1.2. The data contract serializer15.1.1.3. The binary serializer15.1.1.4. XmlSerializer15.1.1.5. IXmlSerializable15.1.2. Formatters15.1.3. Explicit Versus Implicit Serialization15.2. The Data Contract Serializer15.2.1. DataContractSerializer Versus NetDataContractSerializer15.2.2. Using the Serializers15.2.2.1. Specifying a binary formatter15.2.3. Serializing Subclasses15.2.4. Object References15.2.4.1. Preserving object references15.2.5. Version Tolerance15.2.5.1. Required members15.2.6. Member Ordering15.2.7. Null and Empty Values15.3. Data Contracts and Collections15.3.1. Subclassed Collection Elements15.3.2. Customizing Collection and Element Names15.4. Extending Data Contracts15.4.1. Serialization and Deserialization Hooks15.4.2. Interoperating with [Serializable]15.4.3. Interoperating with IXmlSerializable15.5. The Binary Serializer15.5.1. Getting Started15.6. Binary Serialization Attributes15.6.1. [NonSerialized]15.6.2. [OnDeserializing] and [OnDeserialized]15.6.3. [OnSerializing] and [OnSerialized]15.6.4. [OptionalField] and Versioning15.7. Binary Serialization with ISerializable15.7.1. Subclassing Serializable Classes15.8. XML Serialization15. Getting Started with Attribute-Based Serialization15.8.1.1. Attributes, names, and namespaces15.8.1.2. XML element order15.8.2. Subclasses and Child Objects15.8.2.1. Subclassing the root type15.8.2.2. Serializing child objects15.8.2.3. Subclassing child objects15.8.3. Serializing Collections15.8.3.1. Working with subclassed collection elements15.8.4. IXmlSerializable
16. Assemblies
16.1. What’s in an Assembly16.1.1. The Assembly Manifest16.1.1.1. Specifying assembly attributes16.1.2. The Application Manifest16.1.2.1. Deploying an application manifest16.1.3. Modules16.1.4. The Assembly Class16.2. Signing an Assembly16.2.1. How to Sign an Assembly16.2.2. Delay Signing16.3. Assembly Names16.3.1. Fully Qualified Names16.3.2. The AssemblyName Class16.4. The Global Assembly Cache16.4.1. How to Install Assemblies to the GAC16.4.2. GAC and Versioning16.5. Resources and Satellite Assemblies16.5.1. Directly Embedding Resources16.5.2. .resources Files16.5.3. .resx Files16.5.3.1. Creating a .resx file at the command line16.5.3.2. Reading .resources files16.5.3.3. Creating a pack URI resource in Visual Studio16.5.4. Satellite Assemblies16.5.4.1. Building satellite assemblies16.5.4.2. Testing satellite assemblies16.5.4.3. Visual Studio designer support16.5.5. Cultures and Subcultures16.6. Resolving and Loading Assemblies16.6.1. Assembly and Type Resolution Rules16.6.2. AssemblyResolve16.6.3. Loading Assemblies16.6.3.1. Loading from a filename16.7. Deploying Assemblies Outside the Base Folder16.8. Packing a Single-File Executable16.8.1. Selective Patching16.9. Working with Unreferenced Assemblies
17. Reflection and Metadata
17.1. Reflecting and Activating Types17.1.1. Obtaining a Type17.1.1.1. Obtaining array types17.1.1.2. Obtaining nested types17.1.2. Type Names17.1.2.1. Nested type names17.1.2.2. Generic type names17.1.2.3. Array and pointer type names17.1.2.4. ref and out parameter type names17.1.3. Base Types and Interfaces17.1.4. Instantiating Types17.1.5. Generic Types17.2. Reflecting and Invoking Members17.2.1. Member Types17.2.2. C# Members Versus CLR Members17.2.3. Generic Type Members17.2.4. Dynamically Invoking a Member17.2.5. Method Parameters17.2.6. Using Delegates for Performance17.2.7. Accessing Nonpublic Members17.2.7.1. The BindingFlags enum17.2.8. Generic Methods17.2.9. Anonymously Calling Members of a Generic Type17.3. Reflecting Assemblies17.3.1. Loading an Assembly into a Reflection-Only Context17.3.2. Modules17.4. Working with Attributes17.4.1. Attribute Basics17.4.2. The AttributeUsage Attribute17.4.3. Defining Your Own Attribute17.4.4. Retrieving Attributes at Runtime17.4.5. Retrieving Attributes in the Reflection-Only Context17.5. Dynamic Code Generation17.5.1. Generating IL with DynamicMethod17.5.2. The Evaluation Stack17.5.3. Passing Arguments to a Dynamic Method17.5.4. Generating Local Variables17.5.5. Branching17.5.6. Instantiating Objects and Calling Instance Methods17.5.7. Exception Handling17.6. Emitting Assemblies and Types17.6.1. Saving Emitted Assemblies17.6.2. The Reflection.Emit Object Model17.7. Emitting Type Members17.7.1. Emitting Methods17.7.1.1. Generating instance methods17.7.1.2. HideBySig17.7.2. Emitting Fields and Properties17.7.3. Emitting Constructors17.7.3.1. Calling base constructors17.7.4. Attaching Attributes17.8. Emitting Generic Methods and Types17.8.1. Defining Generic Methods17.8.2. Defining Generic Types17.9. Awkward Emission Targets17.9.1. Uncreated Closed Generics17.9.2. Circular Dependencies17.10. Parsing IL17.10.1. Writing a Disassembler
18. Security
18.1. Permissions18.1.1. CodeAccessPermission and PrincipalPermission18.1.1.1. IPermission18.1.2. PermissionSet18.1.3. Declarative Versus Imperative Security18.2. Code Access Security18.2.1. How the CLR Allocates Permissions18.3. Running in a Sandbox18.3.1. Optional Permissions18.3.1.1. SecurityAction.RequestOptional18.4. Sandboxing Another Assembly18.4.1. Link Demands and Partially Trusted Callers18.4.2. Making Assertions18.5. Operating System Security18.5.1. Running in a Standard User Account18.5.2. Administrative Elevation and Virtualization18.6. Identity and Role Security18.6.1. Assigning Users and Roles18.7. Cryptography Overview18.8. Windows Data Protection18.9. Hashing18.10. Symmetric Encryption18.10.1. Encrypting in Memory18.10.2. Chaining Encryption Streams18.10.3. Disposing Encryption Objects18.10.4. Key Management18.11. Public Key Encryption and Signing18.11.1. The RSA Class18.11.2. Digital Signing
19. Threading
19.1. Threading’s Uses and Misuses19.2. Getting Started19.2.1. Passing Data to a Thread19.2.2. Sharing Data Between Threads19.2.3. Thread Pooling19.2.3.1. Optimizing the pool19.2.4. Foreground and Background Threads19.2.5. Thread Priority19.2.6. Exception Handling19.3. Asynchronous Delegates19.4. Synchronization19.4.1. Blocking19.4.2. Blocking Versus Spinning19.4.2.1. SpinWait19.5. Locking19.5.1. Choosing the Synchronization Object19.5.2. Nested Locking19.5.3. When to Lock19.5.4. Locking and Atomicity19.5.5. Performance, Races, and Deadlocks19.5.6. Mutex19.5.7. Semaphore19.6. Thread Safety19.6.1. Thread Safety and .NET Framework Types19.6.1.1. Locking around thread-safe objects19.6.1.2. Static methods19.6.2. Thread Safety in Application Servers19.6.3. Thread Safety in Rich Client Applications19.7. Nonblocking Synchronization19.7.1. Atomicity and Interlocked19.7.2. Memory Barriers and Volatility19.8. Signaling with Event Wait Handles19.8.1. Creating and Disposing Wait Handles19.8.2. Two-Way Signaling19.8.3. Creating a Cross-Process EventWaitHandle19.8.4. Pooling Wait Handles19.8.5. WaitAny, WaitAll, and SignalAndWait19.9. Signaling with Wait and Pulse19.9.1. How to Use Wait and Pulse19.9.2. Producer/Consumer Queue19.9.3. Wait Timeouts19.9.4. Two-Way Signaling19.9.5. Simulating Wait Handles19.10. Interrupt and Abort19.10.1. Interrupt19.10.2. Abort19.10.3. Safe Cancellation19.11. Local Storage19.12. BackgroundWorker19.12.1. Subclassing BackgroundWorker19.13. ReaderWriterLockSlim19.13.1. Upgradeable Locks and Recursion19.13.1.1. Lock recursion19.14. Timers19.14.1. Multithreaded Timers19.14.2. Single-Threaded Timers
20. Asynchronous Methods
20.1. Why Asynchronous Methods Exist20.2. Asynchronous Method Signatures20.3. Asynchronous Methods Versus Asynchronous Delegates20.4. Using Asynchronous Methods20.5. Writing Asynchronous Methods20.6. Fake Asynchronous Methods20.7. Alternatives to Asynchronous Methods20.8. Asynchronous Events
21. Application Domains
21.1. Application Domain Architecture21.2. Creating and Destroying Application Domains21.3. Using Multiple Application Domains21.4. Using DoCallBack21.5. Domains and Threads21.6. Sharing Data Between Domains21.6.1. Sharing Data Via Slots21.6.2. Intra-Process Remoting21.6.3. Isolating Types and Assemblies21.6.3.1. Type discovery
22. Integrating with Native DLLs
22.1. Calling into DLLs22.2. Marshaling Common Types22.3. Marshaling Classes and Structs22.4. In and Out Marshaling22.5. Callbacks from Unmanaged Code22.6. Simulating a C Union22.7. Shared Memory22.8. Mapping a Struct to Unmanaged Memory22.8.1. fixed and fixed open_curly...close_curly22.9. Interop Attribute Reference22.9.1. The DllImport Attribute22.9.2. The StructLayout Attribute22.9.3. The FieldOffset Attribute22.9.4. The MarshalAs Attribute22.9.4.1. UnmanagedType members
23. Diagnostics
23.1. Conditional Compilation23.1.1. Conditional Compilation Versus Static Variable Flags23.1.2. The Conditional Attribute23.1.2.1. Alternatives to the Conditional attribute23.2. Debug and Trace Classes23.2.1. TraceListener23.2.2. Flushing and Closing Listeners23.3. Debugger Integration23.3.1. Attaching and Breaking23.3.2. Debugger Attributes23.4. Processes and Process Threads23.4.1. Examining Running Processes23.4.2. Examining Threads in a Process23.5. StackTrace and StackFrame23.6. Windows Event Logs23.6.1. Writing to the Event Log23.6.2. Reading the Event Log23.6.3. Monitoring the Event Log23.7. Performance Counters23.7.1. Enumerating the Available Counters23.7.2. Reading Performance Counter Data23.7.3. Creating Counters and Writing Performance Data23.8. The Stopwatch Class
24. Regular Expressions
24.1. Regular Expression Basics24.1.1. Compiled Regular Expressions24.1.2. RegexOptions24.1.3. Character Escapes24.1.4. Character Sets24.2. Quantifiers24.2.1. Greedy Versus Lazy Quantifiers24.3. Zero-Width Assertions24.3.1. Lookahead and Lookbehind24.3.2. Anchors24.3.3. Word Boundaries24.4. Groups24.4.1. Named Groups24.5. Replacing and Splitting Text24.5.1. MatchEvaluator Delegate24.5.2. Splitting Text24.6. Cookbook Regular Expressions24.6.1. Recipes24.6.1.1. Matching U.S. Social Security number/phone number24.6.1.2. Extracting “name = value” pairs (one per line)24.6.1.3. Strong password validation24.6.1.4. Lines of at least 80 characters24.6.1.5. Parsing dates/times (N/N/N H:M:S AM/PM)24.6.1.6. Matching Roman numerals24.6.1.7. Removing repeated words24.6.1.8. Word count24.6.1.9. Matching a Guid24.6.1.10. Parsing an XML tag24.6.1.11. Splitting a camel-cased word24.6.1.12. Obtaining a legal filename24.6.1.13. Escaping Unicode characters for HTML24.7. Regular Expressions Language Reference
A. C# Keywords
B. Namespace-to-Assembly Reference
About the Authors
Colophon
Copyright

Overview

This is a concise yet thorough reference to C# 3.0 programming as implemented in Microsoft's Visual Studio 2008. C# 3.0 in a Nutshell gets right to the point, covering the essentials of language syntax and usage as well as the parts of the .NET base class libraries you need to build working applications. But unlike earlier editions, this book is now organized entirely around concepts and use cases, providing greater depth and readability.

C# 3.0 introduces the most significant enhancements yet to the programming language, and C# 3.0 in a Nutshell delves deep into the subject while assuming minimal prior knowledge of C#-making it accessible to anyone with a reasonable background in programming. In addition to the language, the book covers the .NET CLR and the core Framework assemblies, along with the unified querying syntax called Language Integrated Query (LINQ), which bridges the traditional divide between programs and their data sources.

Free of clutter and long introductions, this book provides a map of C# 3.0 knowledge in a succinct and unified style:

Opening chapters concentrate purely on C#, starting with the basics of syntax, types and variables, and finishing with advanced topics such as unsafe code and preprocessor directives

Later chapters cover the core .NET 3.5 Framework, including such topics as LINQ, XML, collections, I/O and networking, memory management, reflection, attributes, security, threading, application domains and native interoperability

Designed as a handbook for daily use, C# 3.0 in a Nutshell is an ideal companion to any of the vast array of books that focus on an applied technology such as WPF, ASP.NET, or WCF. The areas of the language and .NET Framework that such books omit, this one covers in detail.

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: 9780596527570Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills