Programming C# 12 Ian Griffiths

Spis treści książki

• Preface
  • Who This Book Is For
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Introducing C#
  • Why C#?
    • Managed Code and the CLR
    • C# Prefers Generality to Specialization
  • C# Standards and Implementations
    • Many .NETs
    • Release Cycles and Long Term Support
    • Targeting Multiple .NET Runtimes
  • Visual Studio, Visual Studio Code, and JetBrains Rider
  • Anatomy of a Simple Program
    • Writing a Unit Test
    • Namespaces
      • Namespaces and component names
      • Resolving ambiguity
      • Nested namespaces
    • Classes
    • Unit Tests
  • Summary
• 2. Basic Coding in C#
  • Local Variables
    • Scope
    • Variable Name Ambiguity
    • Local Variable Instances
  • Statements and Expressions
    • Statements
    • Expressions
  • Comments and Whitespace
  • Preprocessing Directives
    • Compilation Symbols
    • #error and #warning
    • #line
    • #pragma
    • #nullable
    • #region and #endregion
  • Fundamental Data Types
    • Numeric Types
      • Numeric conversions
      • Checked contexts
      • BigInteger, Int128, UInt128, and Half
    • Booleans
    • Strings and Characters
      • Immutability of strings
      • String manipulation methods
      • Formatting data in strings
      • Verbatim string literals
      • Raw string literals
      • UTF-8 string literals
    • Tuples
    • Tuple Deconstruction
    • Dynamic
    • Object
  • Operators
  • Flow Control
    • Boolean Decisions with if Statements
    • Multiple Choice with switch Statements
    • Loops: while and do
    • C-Style for Loops
    • Collection Iteration with foreach Loops
  • Patterns
    • Combining and Negating Patterns
    • Relational Patterns
    • Getting More Specific with when
    • Patterns in Expressions
  • Summary
• 3. Types
  • Classes
    • Initialization Inputs
    • Static Members
    • Static Classes
  • Records
  • References and Nulls
  • Banishing Null with Non-Nullable References
  • Structs
    • When to Write a Value Type
    • Guaranteeing Immutability
    • Record Structs
  • Class, Structs, Records, or Tuples?
  • Members
    • Accessibility
    • Fields
    • Constructors
      • Default constructors and zero-argument constructors
      • Chaining constructors
      • Static constructors
    • Deconstructors
    • Methods
      • Passing arguments by reference
      • Reference variables and return values
      • Optional arguments
      • Overloading
      • Variable argument count with the params keyword
      • Local functions
      • Expression-bodied methods
      • Extension methods
    • Properties
      • Initializer syntax
      • Init-only properties
      • Required properties
      • Calculated properties
      • Properties and mutable value types
      • Indexers
    • Operators
    • Events
    • Nested Types
  • Interfaces
    • Default Interface Implementation
    • Static Virtual Members
  • Enums
  • Other Types
  • Anonymous Types
  • Partial Types and Methods
  • Summary
• 4. Generics
  • Generic Types
  • Constraints
    • Type Constraints
    • Reference Type Constraints
    • Value Type Constraints
    • Value Types All the Way Down with Unmanaged Constraints
    • Not Null Constraints
    • Other Special Type Constraints
    • Multiple Constraints
  • Zero-Like Values
  • Generic Methods
  • Type Inference
  • Generic Math
  • Generic Math Interfaces
    • Numeric Category Interfaces
    • Operator Interfaces
    • Function Interfaces
    • Parsing and Formatting
  • Generics and Tuples
  • Summary
• 5. Collections
  • Arrays
    • Array Initialization
    • Searching and Sorting
    • Multidimensional Arrays
      • Jagged arrays
      • Rectangular arrays
    • Copying and Resizing
  • List<T>
  • List and Sequence Interfaces
  • Implementing Lists and Sequences
    • Implementing IEnumerable<T> with Iterators
    • Collection<T>
    • ReadOnlyCollection<T>
  • Addressing Elements with Index and Range Syntax
    • System.Index
    • System.Range
    • Supporting Index and Range in Your Own Types
  • Dictionaries
  • Sorted Dictionaries
  • Sets
  • Queues and Stacks
  • Linked Lists
  • Concurrent Collections
  • Immutable Collections
  • Frozen Collections
  • Summary
• 6. Inheritance
  • Inheritance and Conversions
  • Interface Inheritance
  • Generics
  • Covariance and Contravariance
  • System.Object
  • The Ubiquitous Methods of System.Object
  • Accessibility and Inheritance
  • Virtual Methods
    • Abstract Methods
    • Inheritance and Library Versioning
    • Static Virtual Methods
    • Default Constraints
  • Sealed Methods and Classes
  • Accessing Base Members
  • Inheritance and Construction
    • Primary Constructors
    • Mandatory Properties
    • Field Initialization
  • Record Types
  • Records, Inheritance, and the with Keyword
  • Special Base Types
  • Summary
• 7. Object Lifetime
  • Garbage Collection
    • Determining Reachability
    • Accidentally Defeating the Garbage Collector
    • Weak References
    • Reclaiming Memory
    • Lightening the Load with Inline Arrays
    • Garbage Collector Modes
    • Temporarily Suspending Garbage Collections
    • Accidentally Defeating Compaction
    • Forcing Garbage Collections
  • Destructors and Finalization
  • IDisposable
  • Optional Disposal
  • Boxing
  • Boxing Nullable<T>
  • Summary
• 8. Exceptions
  • Exception Sources
    • Exceptions from APIs
    • Failures Detected by the Runtime
  • Handling Exceptions
    • Exception Objects
    • Multiple catch Blocks
    • Exception Filters
    • Nested try Blocks
    • finally Blocks
  • Throwing Exceptions
    • Rethrowing Exceptions
    • Failing Fast
  • Exception Types
  • Custom Exceptions
  • Unhandled Exceptions
  • Summary
• 9. Delegates, Lambdas, and Events
  • Delegate Types
    • Creating a Delegate
    • Multicast Delegates
    • Invoking a Delegate
    • Common Delegate Types
    • Type Compatibility
    • Behind the Syntax
  • Anonymous Functions
    • Lambdas and Default Arguments
    • Captured Variables
    • Lambdas and Expression Trees
  • Events
    • Standard Event Delegate Pattern
    • Custom Add and Remove Methods
    • Events and the Garbage Collector
    • Events Versus Delegates
  • Delegates Versus Interfaces
  • Summary
• 10. LINQ
  • Query Expressions
  • How Query Expressions Expand
  • Deferred Evaluation
  • LINQ, Generics, and IQueryable<T>
  • Standard LINQ Operators
    • Filtering
    • Select
      • Data shaping and anonymous types
      • Projection and mapping
    • SelectMany
    • Ordering
    • Containment Tests
    • Specific Items and Subranges
    • Whole-Sequence, Order-Preserving Operations
    • Aggregation
    • Grouping
    • Conversion
  • Sequence Generation
  • Other LINQ Implementations
    • Entity Framework Core
    • Parallel LINQ (PLINQ)
    • LINQ to XML
    • IAsyncEnumerable<T>
    • Reactive Extensions
  • Summary
• 11. Rx: Reactive Extensions
  • Fundamental Interfaces
    • IObserver<T>
    • IObservable<T>
      • Implementing cold sources
      • Implementing hot sources
  • Publishing and Subscribing with Delegates
    • Creating an Observable Source with Delegates
    • Subscribing to an Observable Source with Delegates
  • Sequence Builders
    • Empty
    • Never
    • Return
    • Throw
    • Range
    • Repeat
    • Generate
  • LINQ Queries
    • Grouping Operators
    • Join Operators
    • SelectMany Operator
    • Aggregation and Other Single-Value Operators
    • Concat Operator
  • Rx Query Operators
    • Merge
    • Windowing Operators
      • Window versus Buffer
      • Demarcating windows with observables
    • The Scan Operator
    • The Amb Operator
    • DistinctUntilChanged
  • Schedulers
    • Specifying Schedulers
      • ObserveOn
      • SubscribeOn
      • Passing schedulers explicitly
    • Built-in Schedulers
  • Subjects
    • Subject<T>
    • BehaviorSubject<T>
    • ReplaySubject<T>
    • AsyncSubject<T>
  • Adaptation
    • IEnumerable<T> and IAsyncEnumerable<T>
    • .NET Events
    • Asynchronous APIs
  • Timed Sequences
    • Timed Sources
    • Timed Operators
    • Timed Windowing Operators
  • ReaqtorRx as a Service
  • Summary
• 12. Assemblies and Deployment
  • Anatomy of an Assembly
    • .NET Metadata
    • Resources
    • Multifile Assemblies
    • Other PE Features
      • Win32-style resources
      • Console versus GUI
  • Type Identity
  • Deployment
    • Framework-Dependent
    • Self-Contained
    • Trimming
    • Ahead-of-Time (AOT) Compilation
      • ReadyToRun
      • Native AOT
  • Loading Assemblies
    • Assembly Resolution
    • Explicit Loading
    • Isolation and Plug-ins with AssemblyLoadContext
  • Assembly Names
    • Strong Names
    • Version
    • Version Numbers and Assembly Loading
    • Culture
  • Protection
  • Target Frameworks and .NET Standard
  • Summary
• 13. Reflection
  • Reflection Types
    • Assembly
    • Module
    • MemberInfo
    • Type and TypeInfo
    • Generic Types
    • MethodBase, ConstructorInfo, and MethodInfo
    • ParameterInfo
    • FieldInfo
    • PropertyInfo
    • EventInfo
  • Reflection Contexts
  • Summary
• 14. Attributes
  • Applying Attributes
    • Attribute Targets
    • Compiler-Handled Attributes
      • Names and versions
      • Description and related resources
      • Caller information attributes
    • CLR-Handled Attributes
      • InternalsVisibleToAttribute
      • JIT compilation
      • STAThread and MTAThread
    • Debugging Attributes
    • Build-Time Attributes
      • JSON serialization without reflection
      • Regular expression source generation
      • Interop
  • Defining and Consuming Attributes
    • Attribute Types
    • Retrieving Attributes
    • Metadata-Only Load
  • Generic Attribute Types
  • Summary
• 15. Files and Streams
  • The Stream Class
    • Position and Seeking
    • Flushing
    • Copying
    • Length
    • Disposal
    • Asynchronous Operation
    • Concrete Stream Types
    • One Type, Many Behaviors
  • Text-Oriented Types
    • TextReader and TextWriter
    • Concrete Reader and Writer Types
      • StreamReader and StreamWriter
      • StringReader and StringWriter
    • Encoding
      • Code page encodings
      • Using encodings directly
  • Files and Directories
    • FileStream Class
    • File Class
    • Directory Class
    • Path Class
  • Serialization
    • BinaryReader, BinaryWriter, and BinaryPrimitives
    • CLR Serialization
    • JSON
      • JsonSerializer
      • JSON DOM
  • Summary
• 16. Multithreading
  • Threads
    • Threads, Variables, and Shared State
    • Thread-Local Storage
    • The Thread Class
    • The Thread Pool
      • Launching thread pool work with Task
      • Thread creation heuristics
    • Thread Affinity and SynchronizationContext
    • ExecutionContext
  • Synchronization
    • Monitors and the lock Keyword
      • How the lock keyword expands
      • Waiting and notification
      • Timeouts
    • Other Synchronization Primitives
    • Interlocked
    • Lazy Initialization
      • Lazy<T>
      • LazyInitializer
    • Other Class Library Concurrency Support
  • Tasks
    • The Task and Task<T> Classes
      • ValueTask and ValueTask<T>
      • Task creation options
      • Task status
      • Retrieving the result
    • Continuations
    • Schedulers
    • Error Handling
    • Custom Threadless Tasks
    • Parent/Child Relationships
    • Composite Tasks
  • Other Asynchronous Patterns
  • Cancellation
  • Parallelism
    • The Parallel Class
    • Parallel LINQ
    • TPL Dataflow
  • Summary
• 17. Asynchronous Language Features
  • Asynchronous Keywords: async and await
    • Execution and Synchronization Contexts
    • Multiple Operations and Loops
      • Consuming and producing asynchronous sequences
      • Asynchronous disposal
    • Returning a Task
    • Applying async to Nested Methods
  • The await Pattern
  • Error Handling
    • Validating Arguments
    • Singular and Multiple Exceptions
    • Concurrent Operations and Missed Exceptions
  • Summary
• 18. Memory Efficiency
  • (Dont) Copy That
  • Representing Sequential Elements with Span<T>
    • Utility Methods
    • Collection Expressions and Spans
    • Pattern Matching
    • Stack Only
  • Using ref with Fields
  • Representing Sequential Elements with Memory<T>
  • ReadOnlySequence<T>
  • Processing Data Streams with Pipelines
  • Processing JSON in ASP.NET Core
  • Summary
• Index

pokaż cały spis treści

ukryj recenzje