C# 9.0 in a Nutshell: The Definitive Reference
- Length: 1000 pages
- Edition: 1
- Language: English
- Publisher: O'Reilly Media
- Publication Date: 2021-03-30
- ISBN-10: 1098100964
- ISBN-13: 9781098100964
- Sales Rank: #457160 (See Top 100 Books)
When you have questions about C# 9.0 or .NET 5, this bestselling guide has the answers you need. C# is a language of unusual flexibility and breadth, but with its continual growth there’s so much more to learn. In the tradition of O’Reilly’s Nutshell guides, this thoroughly updated edition is simply the best one-volume reference to the C# language available today.
Organized around concepts and use cases, C# 9.0 in a Nutshell provides intermediate and advanced programmers with a concise map of C# and .NET that also plumbs significant depths.
- Get up to speed on C#, from syntax and variables to advanced topics such as pointers, records, closures, and patterns
- Dig deep into LINQ with three chapters dedicated to the topic
- Explore concurrency and asynchrony, advanced threading, and parallel programming
- Work with .NET features, including regular expressions, networking, spans, reflection, and cryptography
Preface Intended Audience How This Book Is Organized What You Need to Use This Book Conventions Used in This Book Using Code Examples We’d Like to Hear from You O’Reilly Online Learning Acknowledgments 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 5 Xamarin UWP .NET Framework Legacy and Niche Runtimes A Brief History of C# 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 Native-Sized Integers (C# 9) 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 String concatenation String interpolation String comparisons 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 (C# 9) 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 The using Directive using static Rules Within a Namespace Name scoping Name hiding Repeated namespaces Nested using directives Aliasing Types and Namespaces 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 (C# 9) 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 (C# 9) CLR property implementation Indexers Implementing an indexer CLR indexer implementation Using indices and ranges with indexers Static Constructors Static constructors and field initialization order Static Classes Finalizers Partial Types and Methods Partial methods Extended partial methods (C# 9) 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 (C# 9) 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 Constructor and field initialization order 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 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 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 Types Capturing Outer Variables Static lambdas (C# 9) 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 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 operators 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 Anonymous Types Tuples Naming Tuple Elements Type erasure ValueTuple.Create Deconstructing Tuples Equality Comparison The System.Tuple classes Records (C# 9) Background Defining a Record Parameter lists Nondestructive Mutation Property Validation Calculated Fields and Lazy Evaluation Primary Constructors Records and Equality Comparison Patterns var Pattern Constant Pattern Relational Patterns (C# 9) Pattern Combinators (C# 9) Tuple and Positional Patterns Property Patterns Attributes Attribute Classes Named and Positional Attribute Parameters Applying Attributes to Assemblies and Backing Fields Specifying Multiple Attributes Caller Info Attributes 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 Overloading Equality and Comparison Operators Custom Implicit and Explicit Conversions Overloading true and false Unsafe Code and Pointers Pointer Basics Unsafe Code The fixed Statement The Pointer-to-Member Operator The stackalloc Keyword Fixed-Size Buffers void* Function Pointers (C# 9) [SkipLocalsInit] (C# 9) Preprocessor Directives Conditional Attributes Pragma Warning XML Documentation Standard XML Documentation Tags User-Defined Tags Type or Member Cross-References 5. .NET Overview .NET Standard .NET Standard 2.0 .NET Standard 2.1 Older .NET Standards .NET Framework and .NET 5 Compatibility Runtime and C# Language Versions Reference Assemblies 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 Xamarin and Xamarin Forms 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 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 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 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 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 and Skip TakeWhile and SkipWhile Distinct 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, and 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 Set Operators Concat and Union Intersect and Except Conversion Methods OfType and Cast ToArray, ToList, ToDictionary, ToHashSet, and ToLookup AsEnumerable and AsQueryable Element Operators First, Last, and Single ElementAt 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 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 Diagnostics 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 File and Directory Operations The File Class Compression and encryption attributes File security The Directory Class FileInfo and DirectoryInfo Path Special Folders Querying Volume Information Catching Filesystem Events File I/O in UWP Working with Directories Working with Files Obtaining Directories and Files “Isolated” storage Application folder KnownFolders Removable devices Downloads folder User-selected files and folders 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 Client-Side Classes WebClient WebRequest and WebResponse 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 with HttpClient Exception Handling Working with HTTP Headers Query Strings Uploading Form Data Cookies Writing an HTTP Server Using FTP Using DNS Sending Mail with SmtpClient Using TCP Concurrency with TCP Receiving POP3 Mail with TCP TCP in UWP 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 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 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 Numeric Type Unification 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 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 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 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 (C# 9) 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
Donate to keep this site alive
How to download source code?
1. Go to: https://www.oreilly.com/
2. Search the book title: C# 9.0 in a Nutshell: The Definitive Reference
, sometime you may not get the results, please search the main title
3. Click the book title in the search results
3. Publisher resources
section, click Download Example Code
.
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.