book

C# 12 in a Nutshell

Name: C# 12 in a Nutshell
Author: Joseph Albahari
ISBN: 9781098147440

by Joseph Albahari

November 2023

Intermediate to advanced

1086 pages

26h 52m

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 ExamplesHow to Contact UsAcknowledgmentsJoseph Albahari
1. Introducing C# and .NET
Object OrientationType SafetyMemory ManagementPlatform SupportCLRs, BCLs, and RuntimesCommon Language RuntimeBase Class LibraryRuntimesNiche RuntimesA Brief History of C#What’s New in C# 12What’s New in C# 11What’s New in C# 10What’s New in C# 9.0What’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 TypesTypes and ConversionsValue 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 TypeUTF-8 StringsArraysDefault Element InitializationIndices and RangesMultidimensional ArraysSimplified Array Initialization ExpressionsBounds CheckingVariables and ParametersThe Stack and the HeapDefinite AssignmentDefault ValuesParametersRef LocalsRef Returnsvar—Implicitly Typed Local VariablesTarget-Typed new ExpressionsExpressions and OperatorsPrimary ExpressionsVoid ExpressionsAssignment ExpressionsOperator Precedence and AssociativityOperator TableNull OperatorsNull-Coalescing OperatorNull-Coalescing Assignment OperatorNull-Conditional OperatorStatementsDeclaration StatementsExpression StatementsSelection StatementsIteration StatementsJump StatementsMiscellaneous StatementsNamespacesFile-Scoped NamespacesThe using DirectiveThe global using Directiveusing staticRules Within a NamespaceAliasing Types and NamespacesAdvanced Namespace Features
3. Creating Types in C#
ClassesFieldsConstantsMethodsInstance ConstructorsDeconstructorsObject InitializersThe this ReferencePropertiesIndexersPrimary Constructors (C# 12)Static 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 MembersStatic Interface MembersEnumsEnum 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 DelegatesInstance and Static Method TargetsMulticast DelegatesGeneric Delegate TypesThe Func and Action DelegatesDelegates Versus InterfacesDelegate CompatibilityEventsStandard Event PatternEvent AccessorsEvent ModifiersLambda ExpressionsExplicitly Specifying Lambda Parameter and Return TypesDefault Lambda Parameters (C# 12)Capturing Outer VariablesLambda Expressions Versus Local MethodsAnonymous Methodstry Statements and ExceptionsThe catch ClauseThe finally BlockThrowing ExceptionsKey Properties of System.ExceptionCommon Exception TypesThe TryXXX Method PatternAlternatives to ExceptionsEnumeration and IteratorsEnumerationCollection Initializers and Collection ExpressionsIteratorsIterator SemanticsComposing SequencesNullable Value TypesNullable<T> StructImplicit and Explicit Nullable ConversionsBoxing and Unboxing Nullable ValuesOperator Liftingbool? with & and | OperatorsNullable Value Types and Null OperatorsScenarios for Nullable Value TypesAlternatives to Nullable Value TypesNullable Reference TypesThe Null-Forgiving OperatorSeparating the Annotation and Warning ContextsTreating Nullable Warnings as ErrorsExtension MethodsExtension Method ChainingAmbiguity and ResolutionAnonymous TypesTuplesNaming Tuple ElementsAliasing Tuples (C# 12)ValueTuple.CreateDeconstructing TuplesEquality ComparisonThe System.Tuple classesRecordsBackgroundDefining a RecordNondestructive MutationProperty ValidationCalculated Fields and Lazy EvaluationPrimary ConstructorsRecords and Equality ComparisonPatternsConstant PatternRelational PatternsPattern Combinatorsvar PatternTuple and Positional PatternsProperty PatternsList PatternsAttributesAttribute ClassesNamed and Positional Attribute ParametersApplying Attributes to Assemblies and Backing FieldsApplying Attributes to Lambda ExpressionsSpecifying Multiple AttributesCaller Info AttributesCallerArgumentExpressionDynamic 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 falseStatic PolymorphismPolymorphic OperatorsGeneric MathUnsafe Code and PointersPointer BasicsUnsafe CodeThe fixed StatementThe Pointer-to-Member OperatorThe stackalloc KeywordFixed-Size Buffersvoid*Native-Sized IntegersFunction Pointers[SkipLocalsInit]Preprocessor DirectivesConditional AttributesPragma WarningXML DocumentationStandard XML Documentation TagsUser-Defined TagsType or Member Cross-References
5. .NET Overview
Runtime Targets and TFMs.NET Standard.NET Standard 2.0Other .NET Standards.NET Framework and .NET 8 CompatibilityReference AssembliesRuntime and C# Language VersionsThe CLR and BCLSystem TypesText ProcessingCollectionsQueryingXML and JSONDiagnosticsConcurrency and AsynchronyStreams and Input/OutputNetworkingAssemblies, Reflection, and AttributesDynamic ProgrammingCryptographyAdvanced ThreadingParallel ProgrammingSpan<T> and Memory<T>Native and COM InteroperabilityRegular ExpressionsSerializationThe Roslyn CompilerApplication LayersASP.NET CoreWindows DesktopUWP and WinUI 3MAUI
6. .NET Fundamentals
String and Text HandlingCharStringComparing StringsStringBuilderText Encodings and UnicodeDates and TimesTimeSpanDateTime and DateTimeOffsetDateOnly and TimeOnlyDates and Time ZonesDateTime and Time ZonesDateTimeOffset and Time ZonesTimeZoneInfoDaylight 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 NumbersConversionsMathBigIntegerHalfComplexRandomBitOperationsEnumsEnum 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 PerformanceFrozen CollectionsPlugging 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, TakeLast, Skip, SkipLastTakeWhile and SkipWhileDistinct and DistinctByProjectingSelectSelectManyJoiningJoin and GroupJoinThe Zip OperatorOrderingOrderBy, OrderByDescending, ThenBy, ThenByDescendingGroupingGroupByChunkSet OperatorsConcat, Union, UnionByIntersect, Intersect By, Except, and ExceptByConversion MethodsOfType and CastToArray, ToList, ToDictionary, ToHashSet, ToLookupAsEnumerable and AsQueryableElement OperatorsFirst, Last, and SingleElementAtMinBy and MaxByDefaultIfEmptyAggregation 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 JSONUtf8JsonReaderUtf8JsonWriterJsonDocumentJsonNode
12. Disposal and Garbage Collection
IDisposable, Dispose, and CloseStandard Disposal SemanticsWhen to DisposeClearing Fields in DisposalAnonymous DisposalAutomatic Garbage CollectionRootsFinalizersCalling 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 Diagnostic 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 StreamsAsynchronous 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 FilesWorking with Tar FilesFile and Directory OperationsThe File ClassThe Directory ClassFileInfo and DirectoryInfoPathSpecial FoldersQuerying Volume InformationCatching Filesystem EventsOS 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 PortsURIsHttpClientGetAsync and Response MessagesSendAsync and Request MessagesUploading Data and HttpContentHttpMessageHandlerProxiesAuthenticationHeadersQuery StringsUploading Form DataCookiesWriting an HTTP ServerUsing DNSSending Mail with SmtpClientUsing TCPConcurrency with TCPReceiving POP3 Mail with TCP
17. 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
18. 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 InterfaceCalling Static Virtual/Abstract Interface MembersReflecting 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
19. Dynamic Programming
The Dynamic Language RuntimeDynamic Member Overload ResolutionSimplifying the Visitor PatternAnonymously Calling Members of a Generic TypeImplementing Dynamic ObjectsDynamicObjectExpandoObjectInteroperating with Dynamic LanguagesPassing State Between C# and a Script
20. Cryptography
OverviewWindows Data ProtectionHashingHash Algorithms in .NETHashing PasswordsSymmetric EncryptionEncrypting in MemoryChaining Encryption StreamsDisposing Encryption ObjectsKey ManagementPublic-Key Encryption and SigningThe RSA ClassDigital Signing
21. 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 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>TimersPeriodicTimerMultithreaded TimersSingle-Threaded Timers
22. 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
23. Span<T> and Memory<T>
Spans and SlicingCopyTo and TryCopyToSearching in SpansWorking with TextMemory<T>Forward-Only EnumeratorsWorking with Stack-Allocated and Unmanaged Memory
24. Native and COM Interoperability
Calling into Native DLLsType and Parameter MarshalingMarshaling Common TypesMarshaling Classes and StructsIn and Out MarshalingCalling ConventionsCallbacks from Unmanaged CodeCallbacks with Function PointersCallbacks with DelegatesSimulating 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
25. 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
Index
About the Author

Overview

When you have questions about C# 12 or .NET 8, this best-selling guide has the answers you need. C# is a language of unusual flexibility and breadth, and with its continual growth, there's always 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.

Aimed at intermediate and advanced programmers, this is a book whose explanations get straight to the point, covering C#, the CLR, and the core .NET libraries in depth without long intros or bloated samples.

Get up to speed on C# from syntax and variables to advanced topics such as pointers, 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, assemblies, spans, cryptography, and reflection.emit

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: 9781098147433Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills