Programming C# 8.0. Build Cloud, Web, and Desktop Applications (ebook)(audiobook)(audiobook)

Kup polskie wydanie:

Spis treści

• 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#?
  • C#s Defining Features
    • Managed Code and the CLR
    • Prefer Generality to Specialization
  • C# Standards and Implementations
    • Many Microsoft .NETs (Temporarily)
    • Targeting Multiple .NET Versions with .NET Standard
  • Visual Studio and Visual Studio Code
  • Anatomy of a Simple Program
    • Adding a Project to an Existing Solution
    • Referencing One Project from Another
    • Referencing External Libraries
    • Writing a Unit Test
    • Namespaces
      • Nested namespaces
    • Classes
    • Program Entry Point
    • 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
    • Booleans
    • Strings and Characters
      • Immutability of strings
      • Formatting data in strings
      • Verbatim string literals
    • Tuples
      • 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
    • Getting More Specific with when
    • Patterns in Expressions
  • Summary
• 3. Types
  • Classes
    • Static Members
    • Static Classes
    • Reference Types
      • Banishing null with non-nullable references
  • Structs
    • When to Write a Value Type
    • Guaranteeing Immutability
  • Members
    • 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
      • Variable argument count with the params keyword
      • Local functions
      • Expression-bodied methods
      • Extension methods
    • Properties
      • Properties and mutable value types
    • Indexers
    • Initializer Syntax
    • Operators
    • Events
    • Nested Types
  • Interfaces
    • Default Interface Implementation
  • 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
  • Generics and Tuples
  • Inside Generics
  • 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
    • ImmutableArray<T>
  • 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
  • Sealed Methods and Classes
  • Accessing Base Members
  • Inheritance and Construction
  • Special Base Types
  • Summary
• 7. Object Lifetime
  • Garbage Collection
    • Determining Reachability
    • Accidentally Defeating the Garbage Collector
    • Weak References
    • Reclaiming Memory
    • 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
    • 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
    • Supporting Query Expressions
  • 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
    • Aggregation
    • Set Operations
    • Whole-Sequence, Order-Preserving Operations
    • Grouping
    • Joins
    • Conversion
  • Sequence Generation
  • Other LINQ Implementations
    • Entity Framework
    • Parallel LINQ (PLINQ)
    • LINQ to XML
    • Reactive Extensions
    • Tx (LINQ to Logs and Traces)
  • Summary
• 11. 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
      • 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 Operations
    • Interval
    • Timer
    • Timestamp
    • TimeInterval
    • Throttle
    • Sample
    • Timeout
    • Windowing Operators
    • Delay
    • DelaySubscription
  • Summary
• 12. Assemblies
  • Anatomy of an Assembly
    • .NET Metadata
    • Resources
    • Multifile Assemblies
    • Other PE Features
      • Win32-style resources
      • Console versus GUI
  • Type Identity
  • Loading Assemblies
    • Assembly Resolution
    • Explicit Loading
    • Isolation and Plugins with AssemblyLoadContext
  • Assembly Names
    • Strong Names
    • Version
      • Version numbers and assembly loading
    • Culture
  • Protection
  • 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
      • Serialization attributes
      • JIT compilation
      • STAThread and MTAThread
      • Interop
  • Defining and Consuming Attributes
    • Attribute Types
    • Retrieving Attributes
      • Reflection-only load
  • 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
    • FileInfo, DirectoryInfo, and FileSystemInfo
    • Known Folders
  • Serialization
    • BinaryReader, BinaryWriter, and BinaryPrimitives
    • CLR Serialization
    • JSON.NET
      • JsonSerializer and JsonConvert
      • LINQ to JSON
  • 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
      • I/O completion threads
    • Thread Affinity and SynchronizationContext
      • ExecutionContext
  • Synchronization
    • Monitors and the lock Keyword
      • How the lock keyword expands
      • Waiting and notification
      • Timeouts
    • SpinLock
    • Reader/Writer Locks
    • Event Objects
    • Barrier
    • CountdownEvent
    • Semaphores
    • Mutex
    • 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
      • Continuation options
    • 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
    • Stack Only
  • 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