C# 12 in a Nutshell: The Definitive Reference 9781098147440
Ebook available on November 16, 2023 When you have questions about C# 12 or .NET 8, this best-selling guide has the ans
217 125
English Pages 1083 Year 2023
Table of contents :
Preface
Intended Audience
How This Book Is Organized
What You Need to Use This Book
Conventions Used in This Book
Using Code Examples
How to Contact Us
Acknowledgments
Joseph Albahari
1. Introducing C# and .NET
Object Orientation
Type Safety
Memory Management
Platform Support
CLRs, BCLs, and Runtimes
Common Language Runtime
Base Class Library
Runtimes
.NET 8
Windows Desktop and WinUI 3
MAUI
.NET Framework
Niche Runtimes
A Brief History of C#
What’s New in C# 12
Collection expressions
Primary constructors in classes and structs
Default lambda parameters
Alias any type
Other new features
What’s New in C# 11
Raw string literals
UTF-8 strings
List patterns
Required members
Static virtual/abstract interface members
Generic math
Other new features
What’s New in C# 10
File-scoped namespaces
The global using directive
Nondestructive mutation for anonymous types
New deconstruction syntax
Field initializers and parameterless constructors in structs
Record structs
Lambda expression enhancements
Nested property patterns
CallerArgumentExpression
Other new features
What’s New in C# 9.0
Top-level statements
Init-only setters
Records
Pattern-matching improvements
Target-typed new expressions
Interop improvements
Other new features
What’s New in C# 8.0
Indices and ranges
Null-coalescing assignment
Using declarations
Read-only members
Static local methods
Default interface members
Switch expressions
Tuple, positional, and property patterns
Nullable reference types
Asynchronous streams
What’s New in C# 7.x
C# 7.3
C# 7.2
C# 7.1
Numeric literal improvements
Out variables and discards
Type patterns and pattern variables
Local methods
More expression-bodied members
Deconstructors
Tuples
throw expressions
What’s New in C# 6.0
What’s New in C# 5.0
What’s New in C# 4.0
What’s New in C# 3.0
What’s New in C# 2.0
2. C# Language Basics
A First C# Program
Compilation
Syntax
Identifiers and Keywords
Contextual keywords
Literals, Punctuators, and Operators
Comments
Type Basics
Predefined Type Examples
Custom Types
Members of a type
Symmetry of predefined types and custom types
Constructors and instantiation
Instance versus static members
The public keyword
Defining namespaces
Defining a Main method
Types and Conversions
Value Types Versus Reference Types
Value types
Reference types
Null
Storage overhead
Predefined Type Taxonomy
Numeric Types
Numeric Literals
Numeric literal type inference
Numeric suffixes
Numeric Conversions
Converting between integral types
Converting between floating-point types
Converting between floating-point and integral types
Decimal conversions
Arithmetic Operators
Increment and Decrement Operators
Specialized Operations on Integral Types
Division
Overflow
Overflow check operators
Overflow checking for constant expressions
Bitwise operators
8- and 16-Bit Integral Types
Special Float and Double Values
double Versus decimal
Real Number Rounding Errors
Boolean Type and Operators
bool Conversions
Equality and Comparison Operators
Conditional Operators
Conditional operator (ternary operator)
Strings and Characters
Char Conversions
String Type
Raw string literals (C# 11)
String concatenation
String interpolation
String comparisons
UTF-8 Strings
Arrays
Default Element Initialization
Value types versus reference types
Indices and Ranges
Indices
Ranges
Multidimensional Arrays
Rectangular arrays
Jagged arrays
Simplified Array Initialization Expressions
Bounds Checking
Variables and Parameters
The Stack and the Heap
Stack
Heap
Definite Assignment
Default Values
Parameters
Passing arguments by value
The ref modifier
The out modifier
Out variables and discards
Implications of passing by reference
The in modifier
The params modifier
Optional parameters
Named arguments
Ref Locals
Ref Returns
var—Implicitly Typed Local Variables
Target-Typed new Expressions
Expressions and Operators
Primary Expressions
Void Expressions
Assignment Expressions
Operator Precedence and Associativity
Precedence
Left-associative operators
Right-associative operators
Operator Table
Null Operators
Null-Coalescing Operator
Null-Coalescing Assignment Operator
Null-Conditional Operator
Statements
Declaration Statements
Local variables
Expression Statements
Selection Statements
The if statement
The else clause
Changing the flow of execution with braces
The switch statement
Switching on types
Switch expressions
Iteration Statements
while and do-while loops
for loops
foreach loops
Jump Statements
The break statement
The continue statement
The goto statement
The return statement
The throw statement
Miscellaneous Statements
Namespaces
File-Scoped Namespaces
The using Directive
The global using Directive
Implicit global usings
using static
Rules Within a Namespace
Name scoping
Name hiding
Repeated namespaces
Nested using directives
Aliasing Types and Namespaces
Alias any type (C# 12)
Advanced Namespace Features
Extern
Namespace alias qualifiers
3. Creating Types in C#
Classes
Fields
The readonly modifier
Field initialization
Declaring multiple fields together
Constants
Methods
Expression-bodied methods
Local methods
Static local methods
Local methods and top-level statements
Overloading methods
Instance Constructors
Overloading constructors
Implicit parameterless constructors
Constructor and field initialization order
Nonpublic constructors
Deconstructors
Object Initializers
The this Reference
Properties
Read-only and calculated properties
Expression-bodied properties
Automatic properties
Property initializers
get and set accessibility
Init-only setters
CLR property implementation
Indexers
Implementing an indexer
CLR indexer implementation
Using indices and ranges with indexers
Primary Constructors (C# 12)
Primary constructor semantics
Primary constructors and field/property initializers
Masking primary constructor parameters
Validating primary constructor parameters
Static Constructors
Static constructors and field initialization order
Static Classes
Finalizers
Partial Types and Methods
Partial methods
Extended partial methods
The nameof operator
Inheritance
Polymorphism
Casting and Reference Conversions
Upcasting
Downcasting
The as operator
The is operator
Introducing a pattern variable
Virtual Function Members
Covariant return types
Abstract Classes and Abstract Members
Hiding Inherited Members
new versus override
Sealing Functions and Classes
The base Keyword
Constructors and Inheritance
Implicit calling of the parameterless base-class constructor
Required members (C# 11)
Constructor and field initialization order
Inheritance with primary constructors
Overloading and Resolution
The object Type
Boxing and Unboxing
Copying semantics of boxing and unboxing
Static and Runtime Type Checking
The GetType Method and typeof Operator
The ToString Method
Object Member Listing
Structs
Struct Construction Semantics
The default constructor
Read-Only Structs and Functions
Ref Structs
Access Modifiers
Examples
Friend Assemblies
Accessibility Capping
Restrictions on Access Modifiers
Interfaces
Extending an Interface
Explicit Interface Implementation
Implementing Interface Members Virtually
Reimplementing an Interface in a Subclass
Alternatives to interface reimplementation
Interfaces and Boxing
Default Interface Members
Static Interface Members
Static nonvirtual interface members
Static virtual/abstract interface members
Enums
Enum Conversions
Flags Enums
Enum Operators
Type-Safety Issues
Nested Types
Generics
Generic Types
Why Generics Exist
Generic Methods
Declaring Type Parameters
typeof and Unbound Generic Types
The default Generic Value
Generic Constraints
Subclassing Generic Types
Self-Referencing Generic Declarations
Static Data
Type Parameters and Conversions
Covariance
Variance is not automatic
Arrays
Declaring a covariant type parameter
Contravariance
C# Generics Versus C++ Templates
4. Advanced C#
Delegates
Writing Plug-in Methods with Delegates
Instance and Static Method Targets
Multicast Delegates
Multicast delegate example
Generic Delegate Types
The Func and Action Delegates
Delegates Versus Interfaces
Delegate Compatibility
Type compatibility
Parameter compatibility
Return type compatibility
Generic delegate type parameter variance
Events
Standard Event Pattern
Event Accessors
Event Modifiers
Lambda Expressions
Explicitly Specifying Lambda Parameter and Return Types
Default Lambda Parameters (C# 12)
Capturing Outer Variables
Static lambdas
Capturing iteration variables
Lambda Expressions Versus Local Methods
Anonymous Methods
try Statements and Exceptions
The catch Clause
Exception filters
The finally Block
The using statement
using declarations
Throwing Exceptions
throw expressions
Rethrowing an exception
Key Properties of System.Exception
Common Exception Types
The TryXXX Method Pattern
Alternatives to Exceptions
Enumeration and Iterators
Enumeration
Collection Initializers and Collection Expressions
Iterators
Iterator Semantics
yield break
Iterators and try/catch/finally blocks
Composing Sequences
Nullable Value Types
Nullable Struct
Implicit and Explicit Nullable Conversions
Boxing and Unboxing Nullable Values
Operator Lifting
Equality operators (== and !=)
Relational operators ()
All other operators (+, −, *, /, %, &, |, ^, , +, ++, --, !, ~)
Mixing nullable and non-nullable types
bool? with & and | Operators
Nullable Value Types and Null Operators
Scenarios for Nullable Value Types
Alternatives to Nullable Value Types
Nullable Reference Types
The Null-Forgiving Operator
Separating the Annotation and Warning Contexts
Treating Nullable Warnings as Errors
Extension Methods
Extension Method Chaining
Ambiguity and Resolution
Namespaces
Extension methods versus instance methods
Extension methods versus extension methods
Demoting an extension method
Anonymous Types
Tuples
Naming Tuple Elements
Type erasure
Aliasing Tuples (C# 12)
ValueTuple.Create
Deconstructing Tuples
Equality Comparison
The System.Tuple classes
Records
Background
Defining a Record
Parameter lists
Nondestructive Mutation
Property Validation
Calculated Fields and Lazy Evaluation
Primary Constructors
Records and Equality Comparison
Patterns
Constant Pattern
Relational Patterns
Pattern Combinators
var Pattern
Tuple and Positional Patterns
Property Patterns
List Patterns
Attributes
Attribute Classes
Named and Positional Attribute Parameters
Applying Attributes to Assemblies and Backing Fields
Applying Attributes to Lambda Expressions
Specifying Multiple Attributes
Caller Info Attributes
CallerArgumentExpression
Dynamic Binding
Static Binding Versus Dynamic Binding
Custom Binding
Language Binding
RuntimeBinderException
Runtime Representation of Dynamic
Dynamic Conversions
var Versus dynamic
Dynamic Expressions
Dynamic Calls Without Dynamic Receivers
Static Types in Dynamic Expressions
Uncallable Functions
Operator Overloading
Operator Functions
Checked operators
Overloading Equality and Comparison Operators
Custom Implicit and Explicit Conversions
Overloading true and false
Static Polymorphism
Polymorphic Operators
Generic Math
Unsafe Code and Pointers
Pointer Basics
Unsafe Code
The fixed Statement
The Pointer-to-Member Operator
The stackalloc Keyword
Fixed-Size Buffers
void*
Native-Sized Integers
Runtime handling when targeting .NET 7+
Runtime handling when targeting .NET 6 or below
Function Pointers
[SkipLocalsInit]
Preprocessor Directives
Conditional Attributes
Pragma Warning
XML Documentation
Standard XML Documentation Tags
User-Defined Tags
Type or Member Cross-References
5. .NET Overview
Runtime Targets and TFMs
.NET Standard
.NET Standard 2.0
Other .NET Standards
.NET Framework and .NET 8 Compatibility
Reference Assemblies
Runtime and C# Language Versions
The CLR and BCL
System Types
Text Processing
Collections
Querying
XML and JSON
Diagnostics
Concurrency and Asynchrony
Streams and Input/Output
Networking
Assemblies, Reflection, and Attributes
Dynamic Programming
Cryptography
Advanced Threading
Parallel Programming
Span and Memory
Native and COM Interoperability
Regular Expressions
Serialization
The Roslyn Compiler
Application Layers
ASP.NET Core
Windows Desktop
WPF
Windows Forms
UWP and WinUI 3
MAUI
6. .NET Fundamentals
String and Text Handling
Char
String
Constructing strings
Null and empty strings
Accessing characters within a string
Searching within strings
Manipulating strings
Splitting and joining strings
String.Format and composite format strings
Comparing Strings
Ordinal versus culture comparison
String equality comparison
String order comparison
StringBuilder
Text Encodings and Unicode
Obtaining an Encoding object
Encoding for file and stream I/O
Encoding to byte arrays
UTF-16 and surrogate pairs
Dates and Times
TimeSpan
DateTime and DateTimeOffset
Choosing between DateTime and DateTimeOffset
Constructing a DateTime
Constructing a DateTimeOffset
The current DateTime/DateTimeOffset
Working with dates and times
Formatting and parsing datetimes
Null DateTime and DateTimeOffset values
DateOnly and TimeOnly
Dates and Time Zones
DateTime and Time Zones
DateTimeOffset and Time Zones
TimeZoneInfo
TimeZone
TimeZoneInfo
Daylight Saving Time and DateTime
Formatting and Parsing
ToString and Parse
Format Providers
Format providers and CultureInfo
Using NumberFormatInfo or DateTimeFormatInfo
Composite formatting
Parsing with format providers
IFormatProvider and ICustomFormatter
Standard Format Strings and Parsing Flags
Numeric Format Strings
NumberStyles
Date/Time Format Strings
Parsing and misparsing DateTimes
DateTimeStyles
Enum Format Strings
Other Conversion Mechanisms
Convert
Rounding real to integral conversions
Parsing numbers in base 2, 8, and 16
Dynamic conversions
Base-64 conversions
XmlConvert
Type Converters
BitConverter
Globalization
Globalization Checklist
Testing
Working with Numbers
Conversions
Math
BigInteger
Half
Complex
Random
BitOperations
Enums
Enum Conversions
Enum to integral conversions
Integral to enum conversions
String conversions
Enumerating Enum Values
How Enums Work
The Guid Struct
Equality Comparison
Value Versus Referential Equality
Standard Equality Protocols
== and !=
The virtual Object.Equals method
The static object.Equals method
The static object.ReferenceEquals method
The IEquatable interface
When Equals and == are not equal
Equality and Custom Types
Changing the meaning of equality
Speeding up equality comparisons with structs
How to override equality semantics
Overriding GetHashCode
Overriding Equals
Overloading == and !=
Implementing IEquatable
An example: the Area struct
Pluggable equality comparers
Order Comparison
IComparable
IComparable versus Equals
< and >
Implementing the IComparable Interfaces
Utility Classes
Console
Environment
Process
Redirecting output and error streams
UseShellExecute
AppContext
7. Collections
Enumeration
IEnumerable and IEnumerator
IEnumerable and IEnumerator
IEnumerable and IDisposable
Implementing the Enumeration Interfaces
The ICollection and IList Interfaces
ICollection and ICollection
IList and IList
IReadOnlyCollection and IReadOnlyList
The Array Class
Construction and Indexing
Enumeration
Length and Rank
Searching
Sorting
Reversing Elements
Copying
Converting and Resizing
Lists, Queues, Stacks, and Sets
List and ArrayList
LinkedList
Queue and Queue
Stack and Stack
BitArray
HashSet and SortedSet
Dictionaries
IDictionary
IDictionary
Dictionary and Hashtable
OrderedDictionary
ListDictionary and HybridDictionary
Sorted Dictionaries
Customizable Collections and Proxies
Collection and CollectionBase
CollectionBase
KeyedCollection and DictionaryBase
DictionaryBase
ReadOnlyCollection
Immutable Collections
Creating Immutable Collections
Manipulating Immutable Collections
Builders
Immutable Collections and Performance
Frozen Collections
Plugging in Equality and Order
IEqualityComparer and EqualityComparer
EqualityComparer.Default
ReferenceEqualityComparer.Instance (.NET 5+)
IComparer and Comparer
StringComparer
IStructuralEquatable and IStructuralComparable
8. LINQ Queries
Getting Started
Fluent Syntax
Chaining Query Operators
Why extension methods are important
Composing Lambda Expressions
Lambda expressions and Func signatures
Lambda expressions and element typing
Natural Ordering
Other Operators
Query Expressions
Range Variables
Query Syntax Versus SQL Syntax
Query Syntax Versus Fluent Syntax
Mixed-Syntax Queries
Deferred Execution
Reevaluation
Captured Variables
How Deferred Execution Works
Chaining Decorators
How Queries Are Executed
Subqueries
Subqueries and Deferred Execution
Composition Strategies
Progressive Query Building
The into Keyword
Scoping rules
Wrapping Queries
Projection Strategies
Object Initializers
Anonymous Types
The let Keyword
Interpreted Queries
How Interpreted Queries Work
Execution
Combining Interpreted and Local Queries
AsEnumerable
EF Core
EF Core Entity Classes
DbContext
Configuring the connection
Configuring the model
Creating the database
Using DbContext
Object Tracking
Change Tracking
Navigation Properties
Adding and removing entities from navigation collections
Loading navigation properties
Lazy loading
Deferred Execution
Building Query Expressions
Delegates Versus Expression Trees
Compiling expression trees
AsQueryable
Expression Trees
The Expression DOM
9. LINQ Operators
Overview
Sequence→Sequence
Filtering
Projecting
Joining
Ordering
Grouping
Set operators
Conversion methods: Import
Conversion methods: Export
Sequence→Element or Value
Element operators
Aggregation methods
Quantifiers
Void→Sequence
Generation methods
Filtering
Where
Query syntax
Enumerable.Where implementation
Overview
Indexed filtering
SQL LIKE comparisons in EF Core
< and > string comparisons in EF Core
WHERE x IN (…, …, …) in EF Core
Take, TakeLast, Skip, SkipLast
TakeWhile and SkipWhile
Distinct and DistinctBy
Projecting
Select
Query syntax
Enumerable implementation
Overview
Indexed projection
Select subqueries and object hierarchies
Subqueries and joins in EF Core
Projecting into concrete types
SelectMany
Query syntax
Enumerable implementation
Overview
Multiple range variables
Thinking in query syntax
Joining with SelectMany
SelectMany in EF Core
Outer joins with SelectMany
Joining
Join and GroupJoin
Join arguments
GroupJoin arguments
Query syntax
Overview
Join
Joining on multiple keys
Joining in fluent syntax
GroupJoin
Flat outer joins
Joining with lookups
Enumerable implementations
The Zip Operator
Ordering
OrderBy, OrderByDescending, ThenBy, ThenByDescending
OrderBy and OrderByDescending arguments
ThenBy and ThenByDescending arguments
Query syntax
Overview
Comparers and collations
IOrderedEnumerable and IOrderedQueryable
Grouping
GroupBy
Query syntax
Overview
GroupBy in EF Core
Grouping by multiple keys
Custom equality comparers
Chunk
Set Operators
Concat, Union, UnionBy
Intersect, Intersect By, Except, and ExceptBy
Conversion Methods
OfType and Cast
ToArray, ToList, ToDictionary, ToHashSet, ToLookup
AsEnumerable and AsQueryable
Element Operators
First, Last, and Single
ElementAt
MinBy and MaxBy
DefaultIfEmpty
Aggregation Methods
Count and LongCount
Min and Max
Sum and Average
Aggregate
Unseeded aggregations
Traps with unseeded aggregations
Quantifiers
Contains and Any
All and SequenceEqual
Generation Methods
Empty
Range and Repeat
10. LINQ to XML
Architectural Overview
What Is a DOM?
The LINQ to XML DOM
X-DOM Overview
Loading and Parsing
Saving and Serializing
Instantiating an X-DOM
Functional Construction
Specifying Content
Automatic Deep Cloning
Navigating and Querying
Child Node Navigation
FirstNode, LastNode, and Nodes
Retrieving elements
Retrieving a single element
Retrieving descendants
Parent Navigation
Peer Node Navigation
Attribute Navigation
Updating an X-DOM
Simple Value Updates
Updating Child Nodes and Attributes
Updating Through the Parent
Removing a sequence of nodes or attributes
Working with Values
Setting Values
Getting Values
Values and Mixed Content Nodes
Automatic XText Concatenation
Documents and Declarations
XDocument
XML Declarations
Writing a declaration to a string
Names and Namespaces
Namespaces in XML
Prefixes
Attributes
Specifying Namespaces in the X-DOM
The X-DOM and Default Namespaces
Prefixes
Annotations
Projecting into an X-DOM
Eliminating Empty Elements
Streaming a Projection
11. Other XML and JSON Technologies
XmlReader
Reading Nodes
Reading Elements
Optional elements
Random element order
Empty elements
Other ReadXXX methods
Reading Attributes
Attribute nodes
Namespaces and Prefixes
XmlWriter
Writing Attributes
Writing Other Node Types
Namespaces and Prefixes
Patterns for Using XmlReader/XmlWriter
Working with Hierarchical Data
Mixing XmlReader/XmlWriter with an X-DOM
Using XmlReader with XElement
Using XmlWriter with XElement
Working with JSON
Utf8JsonReader
JsonReaderOptions
Utf8JsonWriter
JsonDocument
Reading simple values
Reading JSON arrays
Reading JSON objects
JsonDocument and LINQ
Making updates with a JSON writer
JsonNode
Reading simple values
Reading JSON arrays
Reading JSON objects
Fluent traversal and LINQ
Making updates with JsonNode
Constructing a JsonNode DOM programmatically
12. Disposal and Garbage Collection
IDisposable, Dispose, and Close
Standard Disposal Semantics
Close and Stop
When to Dispose
Clearing Fields in Disposal
Anonymous Disposal
Automatic Garbage Collection
Roots
Finalizers
Calling Dispose from a Finalizer
Resurrection
GC.ReRegisterForFinalize
How the GC Works
Optimization Techniques
Generational collection
The Large Object Heap
Workstation versus server collection
Background collection
GC notifications
Forcing Garbage Collection
Tuning Garbage Collection at Runtime
Memory Pressure
Array Pooling
Managed Memory Leaks
Timers
Diagnosing Memory Leaks
Weak References
Weak References and Caching
Weak References and Events
13. Diagnostics
Conditional Compilation
Conditional Compilation Versus Static Variable Flags
The Conditional Attribute
Alternatives to the Conditional attribute
Debug and Trace Classes
Fail and Assert
TraceListener
Flushing and Closing Listeners
Debugger Integration
Attaching and Breaking
Debugger Attributes
Processes and Process Threads
Examining Running Processes
Examining Threads in a Process
StackTrace and StackFrame
Windows Event Logs
Writing to the Event Log
Reading the Event Log
Monitoring the Event Log
Performance Counters
Enumerating the Available Counters
Reading Performance Counter Data
Creating Counters and Writing Performance Data
The Stopwatch Class
Cross-Platform Diagnostic Tools
dotnet-counters
dotnet-trace
Custom trace events
dotnet-dump
14. Concurrency and Asynchrony
Introduction
Threading
Creating a Thread
Join and Sleep
Blocking
I/O-bound versus compute-bound
Blocking versus spinning
Local Versus Shared State
Locking and Thread Safety
Passing Data to a Thread
Lambda expressions and captured variables
Exception Handling
Centralized exception handling
Foreground Versus Background Threads
Thread Priority
Signaling
Threading in Rich Client Applications
Synchronization Contexts
The Thread Pool
Entering the thread pool
Hygiene in the thread pool
Tasks
Starting a Task
Wait
Long-running tasks
Returning Values
Exceptions
Exceptions and autonomous tasks
Continuations
TaskCompletionSource
Task.Delay
Principles of Asynchrony
Synchronous Versus Asynchronous Operations
What Is Asynchronous Programming?
Asynchronous Programming and Continuations
Why Language Support Is Important
Asynchronous Functions in C#
Awaiting
Capturing local state
Awaiting in a UI
Comparison to coarse-grained concurrency
Writing Asynchronous Functions
Returning Task
Asynchronous call graph execution
Parallelism
Asynchronous Lambda Expressions
Asynchronous Streams
Querying IAsyncEnumerable
IAsyncEnumerable in ASP.Net Core
Asynchronous Methods in WinRT
Asynchrony and Synchronization Contexts
Exception posting
OperationStarted and OperationCompleted
Optimizations
Completing synchronously
ValueTask
Precautions when using ValueTask
Avoiding excessive bouncing
Asynchronous Patterns
Cancellation
Progress Reporting
IProgress and Progress
The Task-Based Asynchronous Pattern
Task Combinators
WhenAny
WhenAll
Custom combinators
Asynchronous Locking
Obsolete Patterns
Asynchronous Programming Model
Event-Based Asynchronous Pattern
BackgroundWorker
15. Streams and I/O
Stream Architecture
Using Streams
Reading and Writing
Seeking
Closing and Flushing
Timeouts
Thread Safety
Backing Store Streams
FileStream
Constructing a FileStream
Specifying a filename
Specifying a FileMode
Advanced FileStream features
MemoryStream
PipeStream
Named pipes
Anonymous pipes
BufferedStream
Stream Adapters
Text Adapters
StreamReader and StreamWriter
Character encodings
StringReader and StringWriter
Binary Adapters
Closing and Disposing Stream Adapters
Compression Streams
Compressing in Memory
Unix gzip File Compression
Working with ZIP Files
Working with Tar Files
File and Directory Operations
The File Class
Compression and encryption attributes
Windows file security
Unix file security
The Directory Class
FileInfo and DirectoryInfo
Path
Special Folders
Querying Volume Information
Catching Filesystem Events
OS Security
Running in a Standard User Account
Administrative Elevation and Virtualization
Memory-Mapped Files
Memory-Mapped Files and Random File I/O
Memory-Mapped Files and Shared Memory (Windows)
Cross-Platform Interprocess Shared Memory
Working with View Accessors
16. Networking
Network Architecture
Addresses and Ports
URIs
HttpClient
GetAsync and Response Messages
SendAsync and Request Messages
Uploading Data and HttpContent
HttpMessageHandler
Unit testing and mocking
Chaining handlers with DelegatingHandler
Proxies
Authentication
CredentialCache
Authenticating via headers
Headers
Query Strings
Uploading Form Data
Cookies
Writing an HTTP Server
Using DNS
Sending Mail with SmtpClient
Using TCP
Concurrency with TCP
Receiving POP3 Mail with TCP
17. Assemblies
What’s in an Assembly
The Assembly Manifest
Specifying assembly attributes
The Application Manifest (Windows)
Deploying an application manifest
Modules
The Assembly Class
Strong Names and Assembly Signing
How to Strongly Name an Assembly
Assembly Names
Fully Qualified Names
The AssemblyName Class
Assembly Informational and File Versions
Authenticode Signing
How to Sign with Authenticode
Obtaining and installing a certificate
Signing with signtool.exe
Time stamping
Verifying that a program has been signed
Resources and Satellite Assemblies
Directly Embedding Resources
.resources Files
.resx Files
Reading .resources files
Creating a pack URI resource in Visual Studio
Satellite Assemblies
Building satellite assemblies
Testing satellite assemblies
Visual Studio designer support
Cultures and Subcultures
Loading, Resolving, and Isolating Assemblies
Assembly Load Contexts
Loading assemblies
LoadFromAssemblyName
Resolving assemblies
The Default ALC
Default probing
The “Current” ALC
Assembly.Load and Contextual ALCs
EnterContextualReflection
Loading and Resolving Unmanaged Libraries
AssemblyDependencyResolver
Unloading ALCs
The Legacy Loading Methods
LoadFrom
LoadFile and Load(byte[])
Writing a Plug-In System
Plugin.Common
Capitalizer (plug-in)
Plugin.Host
Adding dependencies
18. Reflection and Metadata
Reflecting and Activating Types
Obtaining a Type
TypeInfo
Obtaining array types
Obtaining nested types
Type Names
Nested type names
Generic type names
Array and pointer type names
ref and out parameter type names
Base Types and Interfaces
Instantiating Types
Generic Types
Reflecting and Invoking Members
Member Types
C# Members Versus CLR Members
Init-only properties
NullabilityInfoContext
Generic Type Members
Dynamically Invoking a Member
Method Parameters
Dealing with ref and out parameters
Retrieving and invoking generic methods
Using Delegates for Performance
Accessing Nonpublic Members
The BindingFlags enum
Generic Methods
Anonymously Calling Members of a Generic Interface
Calling Static Virtual/Abstract Interface Members
Reflecting Assemblies
Modules
Working with Attributes
Attribute Basics
The AttributeUsage Attribute
Defining Your Own Attribute
Retrieving Attributes at Runtime
Dynamic Code Generation
Generating IL with DynamicMethod
The Evaluation Stack
Passing Arguments to a Dynamic Method
Generating Local Variables
Branching
Instantiating Objects and Calling Instance Methods
Exception Handling
Emitting Assemblies and Types
The Reflection.Emit Object Model
Emitting Type Members
Emitting Methods
Generating instance methods
Overriding methods
HideBySig
Emitting Fields and Properties
Emitting Constructors
Calling base constructors
Attaching Attributes
Emitting Generic Methods and Types
Defining Generic Methods
Defining Generic Types
Awkward Emission Targets
Uncreated Closed Generics
Circular Dependencies
Parsing IL
Writing a Disassembler
19. Dynamic Programming
The Dynamic Language Runtime
Dynamic Member Overload Resolution
Simplifying the Visitor Pattern
Variations
Anonymously Calling Members of a Generic Type
Implementing Dynamic Objects
DynamicObject
ExpandoObject
Interoperating with Dynamic Languages
Passing State Between C# and a Script
20. Cryptography
Overview
Windows Data Protection
Hashing
Hash Algorithms in .NET
Hashing Passwords
Symmetric Encryption
Encrypting in Memory
Chaining Encryption Streams
Disposing Encryption Objects
Key Management
Public-Key Encryption and Signing
The RSA Class
Digital Signing
21. Advanced Threading
Synchronization Overview
Exclusive Locking
The lock Statement
Monitor.Enter and Monitor.Exit
The lockTaken overloads
TryEnter
Choosing the Synchronization Object
When to Lock
Locking and Atomicity
Nested Locking
Deadlocks
Performance
Mutex
Locking and Thread Safety
Thread Safety and .NET Types
Locking around thread-safe objects
Static members
Read-only thread safety
Thread Safety in Application Servers
Immutable Objects
Nonexclusive Locking
Semaphore
Asynchronous semaphores and locks
Writing an EnterAsync extension method
Parallel.ForEachAsync
Reader/Writer Locks
Upgradeable locks
Lock recursion
Signaling with Event Wait Handles
AutoResetEvent
Two-way signaling
ManualResetEvent
CountdownEvent
Creating a Cross-Process EventWaitHandle
Wait Handles and Continuations
WaitAny, WaitAll, and SignalAndWait
Alternatives to WaitAll and SignalAndWait
The Barrier Class
Lazy Initialization
Lazy
LazyInitializer
Thread-Local Storage
[ThreadStatic]
ThreadLocal
ThreadLocal and instance fields
GetData and SetData
AsyncLocal
Timers
PeriodicTimer
Multithreaded Timers
Single-Threaded Timers
22. Parallel Programming
Why PFX?
PFX Concepts
PFX Components
When to Use PFX
PLINQ
Parallel Execution Ballistics
PLINQ and Ordering
PLINQ Limitations
Example: Parallel Spellchecker
Using ThreadLocal
Functional Purity
Setting the Degree of Parallelism
Changing the degree of parallelism
Cancellation
Optimizing PLINQ
Output-side optimization
Input-side optimization
Optimizing custom aggregations
The Parallel Class
Parallel.Invoke
Parallel.For and Parallel.ForEach
Outer versus inner loops
Indexed Parallel.ForEach
ParallelLoopState: breaking early out of loops
Optimization with local values
Task Parallelism
Creating and Starting Tasks
Specifying a state object
TaskCreationOptions
Child tasks
Waiting on Multiple Tasks
Canceling Tasks
Continuations
Continuations and Task
Continuations and exceptions
Continuations and child tasks
Conditional continuations
Continuations with multiple antecedents
Multiple continuations on a single antecedent
Task Schedulers
TaskFactory
Creating your own task factories
Working with AggregateException
Flatten and Handle
Flatten
Handle
Concurrent Collections
IProducerConsumerCollection
ConcurrentBag
BlockingCollection
Writing a Producer/Consumer Queue
Using Tasks
23. Span and Memory
Spans and Slicing
CopyTo and TryCopyTo
Searching in Spans
Working with Text
Memory
Forward-Only Enumerators
Working with Stack-Allocated and Unmanaged Memory
24. Native and COM Interoperability
Calling into Native DLLs
Type and Parameter Marshaling
Marshaling Common Types
Marshaling Classes and Structs
In and Out Marshaling
Calling Conventions
Callbacks from Unmanaged Code
Callbacks with Function Pointers
UnmanagedCallersOnly
Nondefault calling conventions
Callbacks with Delegates
Simulating a C Union
Shared Memory
Mapping a Struct to Unmanaged Memory
fixed and fixed {...}
COM Interoperability
The Purpose of COM
The Basics of the COM Type System
IUnknown and IDispatch
Calling a COM Component from C#
Optional Parameters and Named Arguments
Implicit ref Parameters
Indexers
Dynamic Binding
Embedding Interop Types
Type Equivalence
Exposing C# Objects to COM
Enabling Registry-Free COM
25. Regular Expressions
Regular Expression Basics
Compiled Regular Expressions
RegexOptions
Character Escapes
Character Sets
Quantifiers
Greedy Versus Lazy Quantifiers
Zero-Width Assertions
Lookahead and Lookbehind
Anchors
Word Boundaries
Groups
Named Groups
Replacing and Splitting Text
MatchEvaluator Delegate
Splitting Text
Cookbook Regular Expressions
Recipes
Matching US Social Security number/phone number
Extracting “name = value” pairs (one per line)
Strong password validation
Lines of at least 80 characters
Parsing dates/times (N/N/N H:M:S AM/PM)
Matching Roman numerals
Removing repeated words
Word count
Matching a GUID
Parsing an XML/HTML tag
Splitting a camel-cased word
Obtaining a legal filename
Escaping Unicode characters for HTML
Unescaping characters in an HTTP query string
Parsing Google search terms from a web stats log
Regular Expressions Language Reference
Index
![C# 12 in a Nutshell: The Definitive Reference [1 ed.]
1098147448, 9781098147440](https://dokumen.pub/img/200x200/c-12-in-a-nutshell-the-definitive-reference-1nbsped-1098147448-9781098147440.jpg)
![C# 9.0 in a Nutshell: The Definitive Reference [1 ed.]
1098100964, 9781098100964](https://dokumen.pub/img/200x200/c-90-in-a-nutshell-the-definitive-reference-1nbsped-1098100964-9781098100964.jpg)
![C# 8.0 in a Nutshell: The Definitive Reference [1 ed.]
1492051136, 9781492051138](https://dokumen.pub/img/200x200/c-80-in-a-nutshell-the-definitive-reference-1nbsped-1492051136-9781492051138.jpg)
![C# 3.0 in a Nutshell: A Desktop Quick Reference [Third Edition]
0596527578](https://dokumen.pub/img/200x200/c-30-in-a-nutshell-a-desktop-quick-reference-third-edition-0596527578.jpg)