book

C# 9.0 in a Nutshell

by Joseph Albahari

February 2021

Intermediate to advanced

1060 pages

26h 28m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Intended AudienceHow This Book Is OrganizedWhat You Need to Use This BookConventions Used in This BookUsing Code ExamplesWe’d Like to Hear from YouO’Reilly Online LearningAcknowledgments
Object OrientationType SafetyMemory ManagementPlatform SupportCLRs, BCLs, and RuntimesCommon Language RuntimeBase Class LibraryRuntimesLegacy and Niche RuntimesA Brief History of C#What’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
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 TypesNative-Sized Integers (C# 9)Special Float and Double Valuesdouble Versus decimalReal Number Rounding ErrorsBoolean Type and Operatorsbool ConversionsEquality and Comparison OperatorsConditional OperatorsStrings and CharactersChar ConversionsString TypeArraysDefault 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 Expressions (C# 9)Expressions and OperatorsPrimary ExpressionsVoid ExpressionsAssignment ExpressionsOperator Precedence and AssociativityOperator TableNull OperatorsNull-Coalescing OperatorNull-Coalescing Assignment OperatorNull-Conditional OperatorStatementsDeclaration StatementsExpression StatementsSelection StatementsIteration StatementsJump StatementsMiscellaneous StatementsNamespacesThe using Directiveusing staticRules Within a NamespaceAliasing Types and NamespacesAdvanced Namespace Features
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 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
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 TypesCapturing 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 InitializersIteratorsIterator 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 ElementsValueTuple.CreateDeconstructing TuplesEquality ComparisonThe System.Tuple classesRecords (C# 9)BackgroundDefining a RecordNondestructive MutationProperty ValidationCalculated Fields and Lazy EvaluationPrimary ConstructorsRecords and Equality ComparisonPatternsvar PatternConstant PatternRelational Patterns (C# 9)Pattern Combinators (C# 9)Tuple and Positional PatternsProperty PatternsAttributesAttribute 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*Function Pointers (C# 9)[SkipLocalsInit] (C# 9)Preprocessor DirectivesConditional AttributesPragma WarningXML DocumentationStandard XML Documentation TagsUser-Defined TagsType or Member Cross-References
.NET Standard.NET Standard 2.0.NET Standard 2.1Older .NET Standards.NET Framework and .NET 5 CompatibilityRuntime and C# Language VersionsReference AssembliesThe 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 3Xamarin and Xamarin Forms
String and Text HandlingCharStringComparing StringsStringBuilderText Encodings and UnicodeDates and TimesTimeSpanDateTime and DateTimeOffsetDates 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 NumbersConversionsMathBigIntegerHalfComplexRandomEnumsEnum ConversionsEnumerating Enum ValuesHow Enums WorkThe Guid StructEquality ComparisonValue Versus Referential EqualityStandard Equality ProtocolsEquality and Custom TypesOrder ComparisonIComparable< and >Implementing the IComparable InterfacesUtility ClassesConsoleEnvironmentProcessAppContext
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
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
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

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
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
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
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
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
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
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
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
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
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
OverviewWindows Data ProtectionHashingHash Algorithms in .NETHashing PasswordsSymmetric EncryptionEncrypting in MemoryChaining Encryption StreamsDisposing Encryption ObjectsKey ManagementPublic-Key Encryption and SigningThe RSA ClassDigital Signing
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>TimersMultithreaded TimersSingle-Threaded Timers
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
Spans and SlicingCopyTo and TryCopyToWorking with TextMemory<T>Forward-Only EnumeratorsWorking with Stack-Allocated and Unmanaged Memory
Calling into Native DLLsType and Parameter MarshalingMarshaling Common TypesMarshaling Classes and StructsIn and Out MarshalingCalling ConventionsCallbacks from Unmanaged CodeCallbacks with Function Pointers (C# 9)Callbacks 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
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

Content preview from C# 9.0 in a Nutshell

Chapter 13. Diagnostics

When things go wrong, it’s important that information is available to aid in diagnosing the problem. An Integrated Development Environment (IDE) or debugger can assist greatly to this effect—but it is usually available only during development. After an application ships, the application itself must gather and record diagnostic information. To meet this requirement, .NET provides a set of facilities to log diagnostic information, monitor application behavior, detect runtime errors, and integrate with debugging tools if available.

Some diagnostic tools and APIs are Windows specific because they rely on features of the Windows operating system. In an effort to prevent platform-specific APIs from cluttering the .NET BCL, Microsoft has shipped them in separate NuGet packages that you can optionally reference. There are more than a dozen Windows-specific packages, which you can reference all at once with the Microsoft.Windows.Compatibility “master” package.

The types in this chapter are defined primarily in the System.Diagnostics namespace.

Conditional Compilation

You can conditionally compile any section of code in C# with preprocessor directives. Preprocessor directives are special instructions to the compiler that begin with the # symbol (and, unlike other C# constructs, must appear on a line of their own). Logically, they execute before the main compilation takes place (although in practice, the compiler processes them during the lexical parsing phase). ...