C# 12 in a Nutshell

Kup polskie wydanie:

Spis treści książki

• 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#
    • Whats New in C# 12
      • Collection expressions
      • Primary constructors in classes and structs
      • Default lambda parameters
      • Alias any type
      • Other new features
    • Whats New in C# 11
      • Raw string literals
      • UTF-8 strings
      • List patterns
      • Required members
      • Static virtual/abstract interface members
      • Generic math
      • Other new features
    • Whats 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
    • Whats New in C# 9.0
      • Top-level statements
      • Init-only setters
      • Records
      • Pattern-matching improvements
      • Target-typed new expressions
      • Interop improvements
      • Other new features
    • Whats 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
    • Whats 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
    • Whats New in C# 6.0
    • Whats New in C# 5.0
    • Whats New in C# 4.0
    • Whats New in C# 3.0
    • Whats 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
    • varImplicitly 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<T> 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<T> and Memory<T>
    • 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<T> 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<T>
      • 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<T> and IEnumerator<T>
      • IEnumerable<T> and IDisposable
    • Implementing the Enumeration Interfaces
  • The ICollection and IList Interfaces
    • ICollection<T> and ICollection
    • IList<T> and IList
    • IReadOnlyCollection<T> and IReadOnlyList<T>
  • The Array Class
    • Construction and Indexing
    • Enumeration
    • Length and Rank
    • Searching
    • Sorting
    • Reversing Elements
    • Copying
    • Converting and Resizing
  • Lists, Queues, Stacks, and Sets
    • List<T> and ArrayList
    • LinkedList<T>
    • Queue<T> and Queue
    • Stack<T> and Stack
    • BitArray
    • HashSet<T> and SortedSet<T>
  • Dictionaries
    • IDictionary<TKey,TValue>
    • IDictionary
    • Dictionary<TKey,TValue> and Hashtable
    • OrderedDictionary
    • ListDictionary and HybridDictionary
    • Sorted Dictionaries
  • Customizable Collections and Proxies
    • Collection<T> and CollectionBase
      • CollectionBase
    • KeyedCollection<TKey,TItem> and DictionaryBase
      • DictionaryBase
    • ReadOnlyCollection<T>
  • Immutable Collections
    • Creating Immutable Collections
    • Manipulating Immutable Collections
    • Builders
    • Immutable Collections and Performance
  • Frozen Collections
  • Plugging in Equality and Order
    • IEqualityComparer and EqualityComparer
      • EqualityComparer<T>.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
    • SequenceSequence
      • Filtering
      • Projecting
      • Joining
      • Ordering
      • Grouping
      • Set operators
      • Conversion methods: Import
      • Conversion methods: Export
    • SequenceElement or Value
      • Element operators
      • Aggregation methods
      • Quantifiers
    • VoidSequence
      • 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<TResult>
      • Asynchronous call graph execution
      • Parallelism
    • Asynchronous Lambda Expressions
    • Asynchronous Streams
      • Querying IAsyncEnumerable<T>
      • IAsyncEnumerable<T> in ASP.Net Core
    • Asynchronous Methods in WinRT
    • Asynchrony and Synchronization Contexts
      • Exception posting
      • OperationStarted and OperationCompleted
    • Optimizations
      • Completing synchronously
      • ValueTask<T>
      • Precautions when using ValueTask<T>
      • Avoiding excessive bouncing
  • Asynchronous Patterns
    • Cancellation
    • Progress Reporting
      • IProgress<T> and Progress<T>
    • 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
  • Whats 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<T>
    • LazyInitializer
  • Thread-Local Storage
    • [ThreadStatic]
    • ThreadLocal<T>
      • ThreadLocal<T> and instance fields
    • GetData and SetData
    • AsyncLocal<T>
  • 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<T>
    • 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<TResult>
      • 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<T>
    • ConcurrentBag<T>
  • BlockingCollection<T>
    • Writing a Producer/Consumer Queue
      • Using Tasks
• 23. Span<T> and Memory<T>
  • Spans and Slicing
    • CopyTo and TryCopyTo
    • Searching in Spans
    • Working with Text
  • Memory<T>
  • 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

pokaż cały spis treści

ukryj recenzje