book

C# 8.0 in a Nutshell

by Joseph Albahari, Eric Johannsen

May 2020

Intermediate to advanced

1099 pages

27h 13m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
Intended AudienceHow This Book Is OrganizedWhat You Need to Use This BookConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningWe’d Like to Hear from YouAcknowledgmentsJoseph AlbahariEric Johannsen
1. Introducing C# and .NET Core
Object OrientationType SafetyMemory ManagementPlatform SupportC# and the Common Language RuntimeFrameworks and Base Class LibrariesLegacy and Niche FrameworksWindows RuntimeA Brief History of C#What’s New in C# 8.0What’s New in C# 7.xWhat’s New in C# 6.0What’s New in C# 5.0What’s New in C# 4.0What’s New in C# 3.0What’s New in C# 2.0
2. C# Language Basics
A First C# ProgramCompilationSyntaxIdentifiers and KeywordsLiterals, Punctuators, and OperatorsCommentsType BasicsPredefined Type ExamplesCustom Type ExamplesConversionsValue Types versus Reference TypesPredefined Type TaxonomyNumeric TypesNumeric LiteralsNumeric ConversionsArithmetic OperatorsIncrement and Decrement OperatorsSpecialized Operations on Integral Types8- and 16-Bit Integral TypesSpecial Float and Double Valuesdouble Versus decimalReal-Number Rounding ErrorsBoolean Type and Operatorsbool ConversionsEquality and Comparison OperatorsConditional OperatorsStrings and Characterschar ConversionsString TypeArraysDefault Element InitializationIndices and Ranges (C# 8)Multidimensional ArraysSimplified Array Initialization ExpressionsBounds CheckingVariables and ParametersThe Stack and the HeapDefinite AssignmentDefault ValuesParametersRef LocalsRef Returnsvar—Implicitly Typed Local VariablesExpressions and OperatorsPrimary ExpressionsVoid ExpressionsAssignment ExpressionsOperator Precedence and AssociativityOperator TableNull OperatorsNull-Coalescing OperatorNull-Coalescing Assignment Operator (C# 8)Null-Conditional OperatorStatementsDeclaration StatementsExpression StatementsSelection StatementsIteration StatementsJump StatementsMiscellaneous StatementsNamespacesThe using Directiveusing staticRules Within a NamespaceAliasing Types and NamespacesAdvanced Namespace Features
3. Creating Types in C#
ClassesFieldsConstantsMethodsInstance ConstructorsDeconstructorsObject InitializersThe this ReferencePropertiesIndexersStatic ConstructorsStatic ClassesFinalizersPartial Types and MethodsThe nameof operatorInheritancePolymorphismCasting and Reference ConversionsVirtual Function MembersAbstract Classes and Abstract MembersHiding Inherited MembersSealing Functions and ClassesThe base KeywordConstructors and InheritanceOverloading and ResolutionThe object TypeBoxing and UnboxingStatic and Runtime Type CheckingThe GetType Method and typeof OperatorThe ToString MethodObject Member ListingStructsStruct Construction SemanticsRead-only Structs and FunctionsRef StructsAccess ModifiersExamplesFriend AssembliesAccessibility CappingRestrictions on Access ModifiersInterfacesExtending an InterfaceExplicit Interface ImplementationImplementing Interface Members VirtuallyReimplementing an Interface in a SubclassInterfaces and BoxingDefault Interface Members (C# 8)EnumsEnum ConversionsFlags EnumsEnum OperatorsType-Safety IssuesNested TypesGenericsGeneric TypesWhy Generics ExistGeneric MethodsDeclaring Type Parameterstypeof and Unbound Generic TypesThe default Generic ValueGeneric ConstraintsSubclassing Generic TypesSelf-Referencing Generic DeclarationsStatic DataType Parameters and ConversionsCovarianceContravarianceC# Generics Versus C++ Templates
4. Advanced C#
DelegatesWriting Plug-in Methods with DelegatesMulticast DelegatesInstance Versus Static Method TargetsGeneric Delegate TypesThe Func and Action DelegatesDelegates Versus InterfacesDelegate CompatibilityEventsStandard Event PatternEvent AccessorsEvent ModifiersLambda ExpressionsExplicitly Specifying Lambda Parameter TypesCapturing Outer VariablesLambda Expressions Versus Local MethodsAnonymous Methodstry Statements and ExceptionsThe catch ClauseThe finally BlockThrowing ExceptionsKey Properties of System.ExceptionCommon Exception TypesThe Try XXX Method PatternAlternatives to ExceptionsEnumeration and IteratorsEnumerationCollection InitializersIteratorsIterator SemanticsComposing SequencesNullable Value TypesNullable<T> StructImplicit and Explicit Nullable ConversionsBoxing and Unboxing Nullable ValuesOperator Liftingbool? with & and | OperatorsNullable Value Types & Null OperatorsScenarios for Nullable Value TypesAlternatives to Nullable Value TypesNullable Reference Types (C# 8)The Null-Forgiving OperatorSeparating the Annotation and Warning ContextsTreating Nullable Warnings as ErrorsExtension MethodsExtension Method ChainingAmbiguity and ResolutionAnonymous TypesTuplesNaming Tuple ElementsValueTuple.CreateDeconstructing TuplesEquality ComparisonThe System.Tuple classesPatternsProperty Patterns (C# 8)Tuple Patterns (C# 8)Positional Patterns (C# 8)var PatternConstant PatternAttributesAttribute ClassesNamed and Positional Attribute ParametersApplying Attributes to Assemblies and Backing FieldsSpecifying Multiple AttributesCaller Info AttributesDynamic BindingStatic Binding versus Dynamic BindingCustom BindingLanguage BindingRuntimeBinderExceptionRuntime Representation of dynamicDynamic Conversionsvar Versus dynamicDynamic ExpressionsDynamic Calls Without Dynamic ReceiversStatic Types in Dynamic ExpressionsUncallable FunctionsOperator OverloadingOperator FunctionsOverloading Equality and Comparison OperatorsCustom Implicit and Explicit ConversionsOverloading true and falseUnsafe Code and PointersPointer BasicsUnsafe CodeThe fixed StatementThe Pointer-to-Member OperatorThe stackalloc KeywordFixed-Size Buffersvoid*Pointers to Unmanaged CodePreprocessor DirectivesConditional Attributespragma warningXML DocumentationStandard XML Documentation TagsUser-Defined TagsType or Member Cross-References
5. Framework Overview
.NET Standard.NET Standard 2.0.NET Standard 2.1Older .NET Standards.NET Framework and .NET Core CompatibilityFramework and C# Language VersionsReference AssembliesThe CLR and BCLSystem TypesText ProcessingCollectionsQueryingXML and JSONDiagnosticsConcurrency and AsynchronyStreams and I/ONetworkingSerializationAssemblies, Reflection, and AttributesDynamic ProgrammingCryptographyAdvanced ThreadingParallel ProgrammingSpan<T> and Memory<T>Native and COM InteroperabilityRegular ExpressionsThe Roslyn CompilerApplication FrameworksASP.NET CoreWindows DesktopUWPXamarin
6. Framework Fundamentals
String and Text HandlingcharstringComparing StringsStringBuilderText Encodings and UnicodeDates and TimesTimeSpanDateTime and DateTimeOffsetDates and Time ZonesDateTime and Time ZonesDateTimeOffset and Time ZonesTimeZone and TimeZoneInfoDaylight Saving Time and DateTimeFormatting and ParsingToString and ParseFormat ProvidersStandard Format Strings and Parsing FlagsNumeric Format StringsNumberStylesDate/Time Format StringsDateTimeStylesEnum Format StringsOther Conversion MechanismsConvertXmlConvertType ConvertersBitConverterGlobalizationGlobalization ChecklistTestingWorking with NumbersConversionsMathBigIntegerComplexRandomEnumsEnum ConversionsEnumerating Enum ValuesHow Enums WorkThe Guid StructEquality ComparisonValue Versus Referential EqualityStandard Equality ProtocolsEquality and Custom TypesOrder ComparisonIComparable< and >Implementing the IComparable InterfacesUtility ClassesConsoleEnvironmentProcessAppContext
7. Collections
EnumerationIEnumerable and IEnumeratorIEnumerable<T> and IEnumerator<T>Implementing the Enumeration InterfacesThe ICollection and IList InterfacesICollection<T> and ICollectionIList<T> and IListIReadOnlyCollection<T> and IReadOnlyList<T>The Array ClassConstruction and IndexingEnumerationLength and RankSearchingSortingReversing ElementsCopyingConverting and ResizingLists, Queues, Stacks, and SetsList<T> and ArrayListLinkedList<T>Queue<T> and QueueStack<T> and StackBitArrayHashSet<T> and SortedSet<T>DictionariesIDictionary<TKey,TValue>IDictionaryDictionary<TKey,TValue> and HashtableOrderedDictionaryListDictionary and HybridDictionarySorted DictionariesCustomizable Collections and ProxiesCollection<T> and CollectionBaseKeyedCollection<TKey,TItem> and DictionaryBaseReadOnlyCollection<T>Immutable CollectionsCreating Immutable CollectionsManipulating Immutable CollectionsBuildersImmutable Collections and PerformancePlugging in Equality and OrderIEqualityComparer and EqualityComparerIComparer and ComparerStringComparerIStructuralEquatable and IStructuralComparable
8. LINQ Queries
Getting StartedFluent SyntaxChaining Query OperatorsComposing Lambda ExpressionsNatural OrderingOther OperatorsQuery ExpressionsRange VariablesQuery Syntax Versus SQL SyntaxQuery Syntax Versus Fluent SyntaxMixed-Syntax QueriesDeferred ExecutionReevaluationCaptured VariablesHow Deferred Execution WorksChaining DecoratorsHow Queries Are ExecutedSubqueriesSubqueries and Deferred ExecutionComposition StrategiesProgressive Query BuildingThe into KeywordWrapping QueriesProjection StrategiesObject InitializersAnonymous TypesThe let KeywordInterpreted QueriesHow Interpreted Queries WorkCombining Interpreted and Local QueriesAsEnumerableEF CoreEF Core Entity ClassesDbContextObject TrackingChange TrackingNavigation PropertiesDeferred ExecutionBuilding Query ExpressionsDelegates Versus Expression TreesExpression Trees
9. LINQ Operators
OverviewSequence→SequenceSequence→Element or ValueVoid→SequenceFilteringWhereTake and SkipTakeWhile and SkipWhileDistinctProjectingSelectSelectManyJoiningJoin and GroupJoinThe Zip OperatorOrderingOrderBy, OrderByDescending, ThenBy, and ThenByDescendingGroupingGroupBySet OperatorsConcat and UnionIntersect and ExceptConversion MethodsOfType and CastToArray, ToList, ToDictionary, ToHashSet, and ToLookupAsEnumerable and AsQueryableElement OperatorsFirst, Last, and SingleElementAtDefaultIfEmptyAggregation MethodsCount and LongCountMin and MaxSum and AverageAggregateQuantifiersContains and AnyAll and SequenceEqualGeneration MethodsEmptyRange and Repeat

10. LINQ to XML
Architectural OverviewWhat Is a DOM?The LINQ to XML DOMX-DOM OverviewLoading and ParsingSaving and SerializingInstantiating an X-DOMFunctional ConstructionSpecifying ContentAutomatic Deep CloningNavigating and QueryingChild Node NavigationParent NavigationPeer Node NavigationAttribute NavigationUpdating an X-DOMSimple Value UpdatesUpdating Child Nodes and AttributesUpdating Through the ParentWorking with ValuesSetting ValuesGetting ValuesValues and Mixed Content NodesAutomatic XText ConcatenationDocuments and DeclarationsXDocumentXML DeclarationsNames and NamespacesNamespaces in XMLSpecifying Namespaces in the X-DOMThe X-DOM and Default NamespacesPrefixesAnnotationsProjecting into an X-DOMEliminating Empty ElementsStreaming a Projection
11. Other XML and JSON Technologies
XmlReaderReading NodesReading ElementsReading AttributesNamespaces and PrefixesXmlWriterWriting AttributesWriting Other Node TypesNamespaces and PrefixesPatterns for Using XmlReader/XmlWriterWorking with Hierarchical DataMixing XmlReader/XmlWriter with an X-DOMWorking with JSONUtf8JsonReaderUtf8JsonWriterJsonDocument
12. Disposal and Garbage Collection
IDisposable, Dispose, and CloseStandard Disposal SemanticsWhen to DisposeClearing Fields in DisposalAnonymous DisposalAutomatic Garbage CollectionRootsGarbage Collection and WinRTFinalizersCalling Dispose from a FinalizerResurrectionHow the GC WorksOptimization TechniquesForcing Garbage CollectionTuning Garbage Collection at RuntimeMemory PressureArray PoolingManaged Memory LeaksTimersDiagnosing Memory LeaksWeak ReferencesWeak References and CachingWeak References and Events
13. Diagnostics
Conditional CompilationConditional Compilation Versus Static Variable FlagsThe Conditional AttributeDebug and Trace ClassesFail and AssertTraceListenerFlushing and Closing ListenersDebugger IntegrationAttaching and BreakingDebugger AttributesProcesses and Process ThreadsExamining Running ProcessesExamining Threads in a ProcessStackTrace and StackFrameWindows Event LogsWriting to the Event LogReading the Event LogMonitoring the Event LogPerformance CountersEnumerating the Available CountersReading Performance Counter DataCreating Counters and Writing Performance DataThe Stopwatch ClassCross-Platform Diagnostics Toolsdotnet-countersdotnet-tracedotnet-dump
14. Concurrency and Asynchrony
IntroductionThreadingCreating a ThreadJoin and SleepBlockingLocal versus Shared StateLocking and Thread SafetyPassing Data to a ThreadException HandlingForeground versus Background ThreadsThread PrioritySignalingThreading in Rich Client ApplicationsSynchronization ContextsThe Thread PoolTasksStarting a TaskReturning valuesExceptionsContinuationsTaskCompletionSourceTask.DelayPrinciples of AsynchronySynchronous versus Asynchronous OperationsWhat Is Asynchronous Programming?Asynchronous Programming and ContinuationsWhy Language Support Is ImportantAsynchronous Functions in C#AwaitingWriting Asynchronous FunctionsAsynchronous Lambda ExpressionsAsynchronous Streams (C# 8)Asynchronous Methods in WinRTAsynchrony and Synchronization ContextsOptimizationsAsynchronous PatternsCancellationProgress ReportingThe Task-Based Asynchronous PatternTask CombinatorsAsynchronous LockingObsolete PatternsAsynchronous Programming ModelEvent-Based Asynchronous PatternBackgroundWorker
15. Streams and I/O
Stream ArchitectureUsing StreamsReading and WritingSeekingClosing and FlushingTimeoutsThread SafetyBacking Store StreamsFileStreamMemoryStreamPipeStreamBufferedStreamStream AdaptersText AdaptersBinary AdaptersClosing and Disposing Stream AdaptersCompression StreamsCompressing in MemoryUnix gzip File CompressionWorking with ZIP FilesFile and Directory OperationsThe File ClassThe Directory ClassFileInfo and DirectoryInfoPathSpecial FoldersQuerying Volume InformationCatching Filesystem EventsFile I/O in UWPWorking with DirectoriesWorking with FilesObtaining Directories and FilesOS SecurityRunning in a Standard User AccountAdministrative Elevation and VirtualizationMemory-Mapped FilesMemory-Mapped Files and Random File I/OMemory-Mapped Files and Shared Memory (Windows)Cross-Platform Interprocess Shared MemoryWorking with View Accessors
16. Networking
Network ArchitectureAddresses and PortsURIsClient-Side ClassesWebClientWebRequest and WebResponseHttpClientProxiesAuthenticationException HandlingWorking with HTTPHeadersQuery StringsUploading Form DataCookiesWriting an HTTP ServerUsing FTPUsing DNSSending Mail with SmtpClientUsing TCPConcurrency with TCPReceiving POP3 Mail with TCPTCP in UWP
17. Serialization
Serialization ConceptsSerialization EnginesFormattersExplicit Versus Implicit SerializationThe XML SerializerGetting Started with Attribute-Based SerializationSubclasses and Child ObjectsSerializing CollectionsIXmlSerializableThe JSON SerializerGetting StartedSerializing Child ObjectsSerializing CollectionsControlling Serialization with AttributesCustomizing Data ConversionJSON Serialization OptionsThe Binary SerializerGetting StartedBinary Serialization Attributes[NonSerialized][OnDeserializing][OnDeserialized][OnSerializing] and [OnSerialized][OptionalField] and VersioningBinary Serialization with ISerializableSubclassing Serializable Classes
18. Assemblies
What’s in an AssemblyThe Assembly ManifestThe Application Manifest (Windows)ModulesThe Assembly ClassStrong Names and Assembly SigningHow to Strongly Name an AssemblyAssembly NamesFully Qualified NamesThe AssemblyName ClassAssembly Informational and File VersionsAuthenticode SigningHow to Sign with AuthenticodeResources and Satellite AssembliesDirectly Embedding Resources.resources Files.resx FilesSatellite AssembliesCultures and SubculturesLoading, Resolving, and Isolating AssembliesAssembly Load ContextsThe Default ALCThe Current ALCAssembly.Load and Contextual ALCsLoading and Resolving Unmanaged LibrariesAssemblyDependencyResolverUnloading ALCsThe Legacy Loading MethodsWriting a Plug-In System
19. Reflection and Metadata
Reflecting and Activating TypesObtaining a TypeType NamesBase Types and InterfacesInstantiating TypesGeneric TypesReflecting and Invoking MembersMember TypesC# Members versus CLR MembersGeneric Type MembersDynamically Invoking a MemberMethod ParametersUsing Delegates for PerformanceAccessing Nonpublic MembersGeneric MethodsAnonymously Calling Members of a Generic InterfaceReflecting AssembliesModulesWorking with AttributesAttribute BasicsThe AttributeUsage AttributeDefining Your Own AttributeRetrieving Attributes at RuntimeDynamic Code GenerationGenerating IL with DynamicMethodThe Evaluation StackPassing Arguments to a Dynamic MethodGenerating Local VariablesBranchingInstantiating Objects and Calling Instance MethodsException HandlingEmitting Assemblies and TypesThe Reflection.Emit Object ModelEmitting Type MembersEmitting MethodsEmitting Fields and PropertiesEmitting ConstructorsAttaching AttributesEmitting Generic Methods and TypesDefining Generic MethodsDefining Generic TypesAwkward Emission TargetsUncreated Closed GenericsCircular DependenciesParsing ILWriting a Disassembler
20. Dynamic Programming
The Dynamic Language RuntimeNumeric Type UnificationDynamic Member Overload ResolutionSimplifying the Visitor PatternAnonymously Calling Members of a Generic TypeImplementing Dynamic ObjectsDynamicObjectExpandoObjectInteroperating with Dynamic LanguagesPassing State Between C# and a Script
21. Cryptography
OverviewWindows Data ProtectionHashingHash Algorithms in .NET CoreHashing PasswordsSymmetric EncryptionEncrypting in MemoryChaining Encryption StreamsDisposing Encryption ObjectsKey ManagementPublic-Key Encryption and SigningThe RSA ClassDigital Signing
22. Advanced Threading
Synchronization OverviewExclusive LockingThe lock StatementMonitor.Enter and Monitor.ExitChoosing the Synchronization ObjectWhen to LockLocking and AtomicityNested LockingDeadlocksPerformanceMutexLocking and Thread SafetyThread Safety and .NET Core TypesThread Safety in Application ServersImmutable ObjectsNonexclusive LockingSemaphoreReader/Writer LocksSignaling with Event Wait HandlesAutoResetEventManualResetEventCountdownEventCreating a Cross-Process EventWaitHandleWait Handles and ContinuationsWaitAny, WaitAll, and SignalAndWaitThe Barrier ClassLazy InitializationLazy<T>LazyInitializerThread-Local Storage[ThreadStatic]ThreadLocal<T>GetData and SetDataAsyncLocal<T>TimersMultithreaded TimersSingle-Threaded Timers
23. Parallel Programming
Why PFX?PFX ConceptsPFX ComponentsWhen to Use PFXPLINQParallel Execution BallisticsPLINQ and OrderingPLINQ LimitationsExample: Parallel SpellcheckerFunctional PuritySetting the Degree of ParallelismCancellationOptimizing PLINQThe Parallel ClassParallel.InvokeParallel.For and Parallel.ForEachTask ParallelismCreating and Starting TasksWaiting on Multiple TasksCanceling TasksContinuationsTask SchedulersTaskFactoryWorking with AggregateExceptionFlatten and HandleConcurrent CollectionsIProducerConsumerCollection<T>ConcurrentBag<T>BlockingCollection<T>Writing a Producer/Consumer Queue
24. Span<T> and Memory<T>
Spans and SlicingCopyTo and TryCopyToWorking with TextMemory<T>Forward-Only EnumeratorsWorking with Stack-Allocated and Unmanaged Memory
25. Native and COM Interoperability
Calling into Native DLLsType MarshalingMarshaling Common TypesMarshaling Classes and StructsIn and Out MarshalingCallbacks from Unmanaged CodeSimulating a C UnionShared MemoryMapping a Struct to Unmanaged Memoryfixed and fixed {...}COM InteroperabilityThe Purpose of COMThe Basics of the COM Type SystemCalling a COM Component from C#Optional Parameters and Named ArgumentsImplicit ref ParametersIndexersDynamic BindingEmbedding Interop TypesType EquivalenceExposing C# Objects to COMEnabling Registry-Free COM
26. Regular Expressions
Regular Expression BasicsCompiled Regular ExpressionsRegexOptionsCharacter EscapesCharacter SetsQuantifiersGreedy Versus Lazy QuantifiersZero-Width AssertionsLookahead and LookbehindAnchorsWord BoundariesGroupsNamed GroupsReplacing and Splitting TextMatchEvaluator DelegateSplitting TextCookbook Regular ExpressionsRecipesRegular Expressions Language Reference
27. The Roslyn Compiler
Roslyn ArchitectureWorkspacesScriptingSyntax TreesSyntaxTree StructureObtaining a Syntax TreeTraversing and Searching a TreeTriviaTransforming a Syntax TreeCompilations and Semantic ModelsCreating a CompilationEmitting an AssemblyQuerying the Semantic ModelExample: Renaming a Symbol
Index

Content preview from C# 8.0 in a Nutshell

Chapter 22. Advanced Threading

We started Chapter 14 with the basics of threading as a precursor to tasks and asynchrony. Specifically, we showed how to start and configure a thread, and covered essential concepts such as thread pooling, blocking, spinning, and synchronization contexts. We also introduced locking and thread safety, and demonstrated the simplest signaling construct, ManualResetEvent.

This chapter picks up where Chapter 14 left off on the topic of threading. In the first three sections, we flesh out synchronization, locking, and thread safety in greater detail. We then cover:

Nonexclusive locking (Semaphore and reader/writer locks)
All of the signaling constructs (AutoResetEvent, ManualResetEvent, CountdownEvent, and Barrier)
Lazy initialization (Lazy<T> and LazyInitializer)
Thread-local storage (ThreadStaticAttribute, ThreadLocal<T>, and GetData/SetData)
Timers

Threading is such a vast topic that we’ve put additional material online to complete the picture. Go online for a discussion on the following, more arcane, topics:

Monitor.Wait and Monitor.Pulse for specialized signaling scenarios
Nonblocking synchronization techniques for micro-optimization (Interlocked, memory barriers, volatile)
SpinLock and SpinWait for high-concurrency scenarios

Synchronization Overview

Synchronization is the act of coordinating concurrent actions for a predictable outcome. Synchronization is particularly important when multiple threads access the same data; it’s surprisingly easy ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781492051121Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 8.0 in a Nutshell

by Joseph Albahari, Eric Johannsen

Chapter 22. Advanced Threading

Synchronization Overview

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.