Programming C# 8.0 by Griffiths, Ian -- Read -- Imperial Library of Trantor

Index

Preface

Who This Book Is For Conventions Used in This Book Using Code Examples O’Reilly 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

(Don’t) 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

← Prev
Back
Next →

← Prev
Back
Next →