book

C# 13 and .NET 9 – Modern Cross-Platform Development Fundamentals - Ninth Edition

Name: C# 13 and .NET 9 – Modern Cross-Platform Development Fundamentals - Ninth Edition
Author: Mark J. Price
ISBN: 9781835881224

by Mark J. Price

November 2024

Beginner to intermediate

828 pages

20h 20m

English

Packt Publishing

Read now

Unlock full access

Preface
Where to find the code solutionsWhat this book coversWhat you need for this bookDownloading the color images of this bookConventionsGet in touch
Hello, C#! Welcome, .NET!
Introducing this book and its contentsGetting code solutions for this book.NET terms used in this bookThe structure and style of this bookTopics covered by this bookTopics covered by Apps and Services with .NET 8Topics covered by Tools and Skills for .NET 8Finding all my booksSetting up your development environmentChoosing the appropriate tool and application type for learningVS Code for cross-platform developmentGitHub Codespaces for development in the cloudVisual Studio for general developmentWhat I usedDeploying cross-platformDownloading and installing Visual StudioKeyboard shortcuts for Visual StudioDownloading and installing VS CodeInstalling other extensionsUnderstanding VS Code versionsKeyboard shortcuts for VS CodeUnderstanding .NETUnderstanding .NET supportUnderstanding end of life (EOL)Understanding .NET support phasesUnderstanding .NET runtime and .NET SDK versionsListing and removing versions of .NETUnderstanding intermediate languageComparing .NET technologiesBuilding console apps using Visual StudioWriting code using Visual StudioCompiling and running code using Visual StudioUnderstanding the compiler-generated folders and filesUnderstanding top-level programsRequirements for top-level programsImplicitly imported namespacesRevealing the hidden code by throwing an exceptionRevealing the namespace for the Program classAdding a second project using Visual StudioBuilding console apps using VS CodeWriting code using VS CodeCompiling and running code using the dotnet CLIAdding a second project using VS CodeSummary of steps for VS CodeSummary of other project types used in this bookMaking good use of the GitHub repository for this bookUnderstanding the solution code on GitHubRaising issues with the bookGiving me feedbackAvoiding common mistakesDownloading solution code from the GitHub repositoryUsing Git with VS Code and the command promptCloning the book solution code repositoryLooking for helpMicrosoft Learn documentation and Ask LearnDocumentation links in this bookGetting help from the dotnet toolGetting definitions of types and their membersConfiguring inline aka inlay hintsLooking for answers on Stack OverflowSearching for answers using GoogleGetting help on Discord and other chat forumsSearching the .NET source codeSource code in documentationOfficial .NET blog, standups, and newsWatching Scott Hanselman’s videosAI tools like ChatGPT and GitHub CopilotChatGPT exampleGitHub Copilot for programmersDisabling tools when they get in the wayPracticing and exploringExercise 1.1 – Online materialCurrent versions of .NETUpgrade to a new .NET versionfreeCodeCamp and C# certificationExplore Polyglot NotebooksWindows developmentC# versus other languagesFree computer science course.NET newslettersExercise 1.2 – Practice exercisesPractice C# anywhere with a browserAlpha versions of .NETExercise 1.3 – Test your knowledgeExercise 1.4 – Explore topicsSummary
Speaking C#
Introducing the C# languageC# language versions and featuresUnderstanding C# standardsDiscovering your C# compiler versionHow to output the SDK versionEnabling a specific language version compilerUsing preview C# compiler versionsSwitching the C# compiler for .NET 9 to a future versionShowing the compiler versionUnderstanding C# grammar and vocabularyUnderstanding C# grammarStatementsCommentsBlocksRegionsExamples of statements and blocksFormatting code using white spaceUnderstanding C# vocabularyComparing programming languages to human languagesChanging the color scheme for C# syntaxHelp for writing correct codeImporting namespacesImplicitly and globally importing namespacesVerbs are methodsNouns are types, variables, fields, and propertiesRevealing the extent of the C# vocabularyExample of asking ChatGPT to explain codeWorking with variablesNaming things and assigning valuesLiteral valuesStoring textOutputting emojisVerbatim stringsRaw string literalsRaw interpolated string literalsSummarizing options for storing textStoring numbersStoring whole numbersImproving legibility by using digit separatorsUsing binary or hexadecimal notationExploring whole numbersStoring real numbersWriting code to explore number sizesComparing double and decimal typesSpecial real number valuesNew number types and unsafe codeStoring BooleansStoring any type of objectStoring dynamic typesDeclaring local variablesSpecifying the type of a local variableInferring the type of a local variableWhat does new do?Using target-typed new to instantiate objectsGetting and setting the default values for typesExploring more about console appsDisplaying output to the userFormatting using numbered positional argumentsRider and its warnings about boxingFormatting using interpolated stringsUnderstanding format stringsCustom number formattingGetting text input from the userWhen does ReadLine return null?Simplifying the usage of the consoleImporting a static type for a single fileImporting a static type for all code files in a projectGetting key input from the userPassing arguments to a console appSetting options with argumentsHandling platforms that do not support an APIPracticing and exploringExercise 2.1 – Online materialUnderstanding async and awaitExplore SpectreExercise 2.2 – Practice exercisesExplore number sizes and rangesExercise 2.3 – Test your knowledgeTest your knowledge of number typesExercise 2.4 – Explore topicsSummary
Controlling Flow, Converting Types, and Handling Exceptions
Operating on variablesUnderstanding binary operatorsUnderstanding unary operatorsUnderstanding ternary operatorsExploring unary operatorsExploring binary arithmetic operatorsAssignment operatorsNull-coalescing operatorsExploring logical operatorsExploring conditional logical operatorsExploring bitwise and binary shift operatorsMiscellaneous operatorsUnderstanding selection statementsBranching with the if statementWhy you should always use braces with if statementsPattern matching with the if statementBranching with the switch statementAdding a new item to a project using Visual StudioPattern matching with the switch statementSimplifying switch statements with switch expressionsUnderstanding iteration statementsLooping with the while statementLooping with the do statementLooping with the for statementLooping with the foreach statementUnderstanding how foreach works internallyStoring multiple values in an arrayWorking with single-dimensional arraysWorking with multi-dimensional arraysWorking with jagged arraysList pattern matching with arraysTrailing commasUnderstanding inline arraysSummarizing arraysCasting and converting between typesCasting numbers implicitly and explicitlyHow negative numbers are represented in binaryConverting with the System.Convert typeRounding numbers and the default rounding rulesTaking control of rounding rulesConverting from any type to a stringConverting from a binary object to a stringBase64 for URLsParsing from strings to numbers or dates and timesAvoiding Parse exceptions by using the TryParse methodUnderstanding the Try method naming conventionHandling exceptionsWrapping error-prone code in a try blockCatching all exceptionsCatching specific exceptionsCatching with filtersChecking for overflowThrowing overflow exceptions with the checked statementDisabling compiler overflow checks with the unchecked statementPracticing and exploringExercise 3.1 – Online materialReturning result types versus throwing exceptionsC# 101 notebooksExercise 3.2 – Practice exercisesLoops and overflowPractice loops and operatorsPractice exception handlingExercise 3.3 – Test your knowledgeTest your knowledge of operatorsExercise 3.4 – Explore topicsSummary
Writing, Debugging, and Testing Functions
Writing functionsExploring top-level programs, functions, and namespacesWhat is automatically generated for a local function?Defining a partial Program class with a static functionWhat is automatically generated for a static function?Times table exampleA brief aside about arguments and parametersWriting a function that returns a valueConverting numbers from cardinal to ordinalCalculating factorials with recursionDocumenting functions with XML commentsUsing lambdas in function implementationsDebugging during developmentCreating code with a deliberate bugSetting a breakpoint and starting debuggingUsing Visual StudioUsing VS CodeNavigating with the debugging toolbarDebugging windowsStepping through codeUsing the VS Code integrated terminal during debuggingCustomizing breakpointsHot reloading during developmentHot reloading using Visual StudioHot reloading using VS Code and dotnet watchUnit testingUnderstanding types of testingCreating a class library that needs testingWriting unit testsRunning unit tests using Visual StudioRunning unit tests using VS CodeFixing the bugSpecifying multiple parameter valuesThrowing and catching exceptions in functionsUnderstanding usage errors and execution errorsCommonly thrown exceptions in functionsThrowing exceptions using guard clausesUnderstanding the call stackWhere to catch exceptionsRethrowing exceptionsImplementing the tester-doer and try patternsPracticing and exploringExercise 4.1 – online materialLogging during development and runtimeExercise 4.2 – practice exercisesWriting functions with debugging and unit testingExercise 4.3 – test your knowledgeExercise 4.4 – explore topicsSummary
Building Your Own Types with Object-Oriented Programming
Talking about OOPBuilding class librariesCreating a class libraryUnderstanding file-scoped namespacesDefining a class in a namespaceUnderstanding type access modifiersUnderstanding membersImporting a namespace to use a typeInstantiating a classInheriting from System.ObjectAvoiding a namespace conflict with a using aliasRenaming a type with a using aliasStoring data in fieldsDefining fieldsTypes for fieldsMember access modifiersSetting and outputting field valuesSetting field values using object initializer syntaxStoring a value using an enum typeStoring multiple values using an enum typeChanging an enum base type for performanceStoring multiple values using collectionsUnderstanding generic collectionsMaking a field staticMaking a field constantMaking a field read-onlyRequiring fields to be set during instantiationInitializing fields with constructorsDefining multiple constructorsSetting required fields with a constructorWorking with methods and tuplesReturning values from methodsDefining and passing parameters to methodsOverloading methodsPassing optional parametersNaming parameter values when calling methodsMixing optional and required parametersControlling how parameters are passedPassing a variable number of parametersUnderstanding ref returnsCombining multiple returned values using tuplesNaming the fields of a tupleAliasing tuplesDeconstructing tuplesDeconstructing other types using tuplesImplementing functionality using local functionsSplitting classes using partialPartial methodsControlling access with properties and indexersDefining read-only propertiesDefining settable propertiesPartial propertiesLimiting flags enum valuesDefining indexersPattern matching with objectsPattern-matching flight passengersEnhancements to pattern matching in modern C#Working with record typesInit-only propertiesDefining record typesEquality of record typesEquality of other typesPositional data members in recordsDefining a primary constructor for a classPracticing and exploringExercise 5.1 – online materialPattern matchingExercise 5.2 – practice exercisesPractice access modifiersExercise 5.3 – test your knowledgeExercise 5.4 – explore topicsSummary
Implementing Interfaces and Inheriting Classes
Setting up a class library and console applicationStatic methods and overloading operatorsImplementing functionality using methodsImplementing functionality using operatorsMaking types safely reusable with genericsWorking with non-generic typesWorking with generic typesRaising and handling eventsCalling methods using delegatesExamples of delegate useStatus: It’s complicatedDefining and handling delegatesDefining and handling eventsImplementing interfacesCommon interfacesComparing objects when sortingComparing objects using a separate classImplicit and explicit interface implementationsDefining interfaces with default implementationsWorking with null valuesMaking a value type nullableUnderstanding null-related initialismsUnderstanding nullable reference typesControlling the nullability warning check featureDisabling null and other compiler warningsDeclaring non-nullable variables and parametersChecking for nullChecking for null in method parametersInheriting from classesExtending classes to add functionalityHiding membersUnderstanding the this and base keywordsOverriding membersInheriting from abstract classesChoosing between an interface and an abstract classPreventing inheritance and overridingUnderstanding polymorphismCasting within inheritance hierarchiesImplicit castingExplicit castingAvoiding casting exceptionsUsing is to check a typeUsing as to cast a typeInheriting and extending .NET typesInheriting exceptionsExtending types when you can’t inheritUsing static methods to reuse functionalityUsing extension methods to reuse functionalityMethod chaining or fluent styleSummarizing custom type choicesCategories of custom types and their capabilitiesMutability and recordsComparing inheritance and implementationReviewing illustrative codePracticing and exploringExercise 6.1 – Online materialManaging memory with reference and value typesWriting better codeExercise 6.2 – Practice creating an inheritance hierarchyExercise 6.3 – Test your knowledgeExercise 6.4 – Explore topicsSummary
Packaging and Distributing .NET Types
The road to .NET 9.NET Standard-compatible frameworksChecking your .NET SDKs for updatesUnderstanding .NET componentsAssemblies, NuGet packages, and namespacesWhat is a namespace?Dependent assembliesMicrosoft .NET project SDKsPropertyGroup elementItemGroup elementLabel and Condition attributesNamespaces and types in assembliesNuGet packagesPackage sourcesUnderstanding frameworksImporting a namespace to use a typeRelating C# keywords to .NET typesMapping C# aliases to .NET typesUnderstanding native-sized integersRevealing the location of a typeSharing code with legacy platforms using .NET StandardUnderstanding defaults for class libraries with different SDKsCreating a .NET Standard class libraryControlling the .NET SDKMixing SDKs and framework targetsPublishing your code for deploymentCreating a console app to publishUnderstanding dotnet commandsGetting information about .NET and its environmentManaging projects using the dotnet CLIPublishing a self-contained appPublishing a single-file appReducing the size of apps using app trimmingControlling where build artifacts are createdNative ahead-of-time compilationLimitations of native AOTReflection and native AOTRequirements for native AOTEnabling native AOT for a projectBuilding a native AOT projectPublishing a native AOT projectPackaging your libraries for NuGet distributionReferencing a NuGet packageFixing dependenciesPackaging a library for NuGetPublishing a package to a public NuGet feedPublishing a package to a private NuGet feedExploring NuGet packages with a toolTesting your class library packageWorking with preview featuresRequiring preview featuresEnabling preview featuresMethod interceptorsPracticing and exploringExercise 7.1 – Online materialExperimental MSBuild editorImproving performance in .NETDecompiling .NET assembliesPorting from .NET Framework to modern .NETExercise 7.2 – Practice exercisesCreating source generatorsExplore PowerShellExercise 7.3 – Test your knowledgeExercise 7.4 – Explore topicsSummary
Working with Common .NET Types
Working with numbersWorking with big integersMultiplying big integersWorking with complex numbersWorking with tensorsGenerating random numbers for games and similar appsGenerating random numbers with the Random classNew random methods in .NET 8 and laterGenerating GUIDsWorking with textGetting the length of a stringGetting the characters of a stringSplitting a stringGetting part of a stringChecking a string for contentComparing string valuesJoining, formatting, and other string membersBuilding strings efficientlyWorking with charactersSearching in stringsPattern matching with regular expressionsChecking for digits entered as textRegular expression performance improvementsUnderstanding the syntax of a regular expressionExamples of regular expressionsSplitting a complex comma-separated stringActivating regular expression syntax coloringImproving regular expression performance with source generatorsStoring multiple objects in collectionsCommon features of all collectionsWorking with listsWorking with dictionariesSets, stacks, and queuesCollection add and remove methodsSorting collectionsSpecialized collectionsRead-only, immutable, and frozen collectionsInitializing collections using collection expressionsUsing the spread elementGood practice with collectionsPresizing collectionsPassing collections to methodsReturning collections from membersWorking with spans, indexes, and rangesUsing memory efficiently using spansIdentifying positions with the Index typeIdentifying ranges with the Range typeUsing indexes, ranges, and spansUsing spans for efficient text handlingPracticing and exploringExercise 8.1 – online materialWorking with network resourcesCollection expressionsExercise 8.2 – practice exercisesRegular expressionsExtension methodsExercise 8.3 – test your knowledgeExercise 8.4 – explore topicsSummary
Working with Files, Streams, and Serialization
Managing a filesystemHandling cross-platform environments and filesystemsManaging drivesManaging directoriesManaging filesManaging pathsGetting file informationControlling how you work with filesReading and writing with streamsUnderstanding abstract and concrete streamsUnderstanding storage streamsUnderstanding function streamsUnderstanding stream helpersBuilding a stream pipelineWriting to text streamsWriting to XML streamsSimplifying disposal by using the using statementCompressing streamsReading and writing with random access handlesEncoding and decoding textEncoding strings as byte arraysEncoding and decoding text in filesSerializing object graphsSerializing as XMLGenerating compact XMLDeserializing XML filesSerializing with JSONHigh-performance JSON processingDeserializing JSON filesJSON schema exporterControlling JSON processingA warning about binary serialization using BinaryFormatterPracticing and exploringExercise 9.1 – Online materialWorking with tar archivesMigrating from Newtonsoft to new JSONExercise 9.2 – Practice exercisesSerializing as XMLExercise 9.3 – Test your knowledgeExercise 9.4 – Explore topicsSummary

Working with Data Using Entity Framework Core
Understanding modern databasesUnderstanding legacy Entity FrameworkUsing the legacy Entity Framework 6.3 or laterUnderstanding Entity Framework CoreUnderstanding Database First and Code FirstPerformance improvements in EF CoreUsing a sample relational databaseUsing SQLiteUsing SQL Server or other SQL systemsSetting up SQLite CLI tools for WindowsSetting up SQLite for macOS and LinuxSetting up EF Core in a .NET projectCreating a console app for working with EF CoreCreating the Northwind sample database for SQLiteIf you are using Visual StudioManaging the Northwind sample database with SQLiteStudioUsing the lightweight ADO.NET database providersChoosing an EF Core database providerConnecting to a named SQLite databaseDefining the Northwind database context classDefining EF Core modelsUsing EF Core conventions to define the modelUsing EF Core annotation attributes to define the modelUsing the EF Core Fluent API to define the modelUnderstanding data seeding with the Fluent APIBuilding EF Core models for the Northwind tablesDefining the Category and Product entity classesAdding tables to the Northwind database context classSetting up the dotnet-ef toolScaffolding models using an existing databaseReviewing the scaffolded codeCustomizing the reverse engineering templatesConfiguring preconvention modelsQuerying EF Core modelsFiltering included entitiesFiltering and sorting productsGetting the generated SQLLogging EF CoreFiltering logs by provider-specific valuesLogging with query tagsGetting a single entityPattern matching with LikeGenerating a random number in queriesDefining global filtersSQL SELECT queriesPracticing and exploringExercise 10.1 – online materialsLoading and tracking patterns with EF CoreModifying data with EF CoreWorking with transactionsExploring a Code First EF Core modelExploring app secretsNoSQL databasesExercise 10.2 – practice exercisesExporting data using different serialization formatsExercise 10.3 – test your knowledgeExercise 10.4 – explore topicsSummary
Querying and Manipulating Data Using LINQ
Writing LINQ expressionsComparing imperative and declarative language featuresLINQ componentsBuilding LINQ expressions with the Enumerable classLINQ in practiceUnderstanding deferred executionFiltering entities using WhereTargeting a named methodSimplifying code by removing the explicit delegate instantiationTargeting a lambda expressionLambda expressions with default parameter valuesSorting and moreSorting by a single property using OrderBySorting by a subsequent property using ThenBySorting by the item itselfDeclaring a query using var or a specified typeFiltering by typeWorking with sets and bagsGetting the index as well as itemsUsing LINQ with EF CoreCreating a console app for exploring LINQ to EntitiesBuilding an EF Core modelFiltering and sorting sequencesProjecting sequences into new typesJoining, grouping, and lookupsJoining sequencesGroup-joining sequencesGrouping for lookupsPracticing and exploringExercise 11.1 – Online materialAggregating and paging sequencesUsing multiple threads with parallel LINQWorking with LINQ to XMLCreating your own LINQ extension methodsDesign of the new LINQ methods in .NET 9Exercise 11.2 – Practice querying with LINQExercise 11.3 – Test your knowledgeExercise 11.4 – Explore topicsSummary
Introducing Modern Web Development Using .NET
Understanding ASP.NET CoreClassic ASP.NET versus modern ASP.NET CoreBuilding websites using ASP.NET CoreComparison of file types used in ASP.NET CoreBuilding websites using a content management systemBuilding web applications using SPA frameworksBuilding web and other servicesBuilding desktop and mobile appsMobile app platforms.NET MAUIUno platformAvaloniaStructuring projectsStructuring projects in a solutionCentral package managementBuilding an entity model for use in the rest of the bookCreating the Northwind databaseCreating a class library for entity models using SQLiteCreating a class library for a database context using SQLiteCustomizing the model and defining an extension methodHasDefaultValue and HasDefaultValueSqlRegistering the scope of a dependency serviceCreating class libraries for entity models using SQL ServerImproving the class-to-table mappingTesting the class librariesUnderstanding web developmentUnderstanding the Hypertext Transfer ProtocolUnderstanding the components of a URLUsing Google Chrome to make HTTP requestsUnderstanding client-side web development technologiesPracticing and exploringExercise 12.1 – Online materialExercise 12.2 – Practice exercisesTroubleshooting web developmentExercise 12.3 – Test your knowledgeKnow your webbreviationsExercise 12.4 – Explore topicsSummary
Building Websites Using ASP.NET Core
Exploring ASP.NET CoreArchitecture of ASP.NET CoreCreating an empty ASP.NET Core projectTesting and securing the websiteEnabling stronger security and redirecting to a secure connectionControlling the hosting environmentEnabling a website to serve static contentCreating a folder for static files and a web pageEnabling static and default filesUnderstanding MapStaticAssetsUnderstanding browser requests during developmentHistory of BlazorJavaScript and friendsSilverlight – C# and .NET using a pluginWebAssembly – a target for BlazorBlazor hosting models in .NET 7 and earlierUnification of Blazor hosting models in .NET 8Understanding Blazor componentsWhat is the difference between Blazor and Razor?Exploring Blazor static SSREnabling Blazor static SSRAdding code to a Blazor static SSR pageUsing shared layouts with Blazor static SSR pagesCreating a suppliers pageConfiguring files included in an ASP.NET Core projectProject file build actionsUsing Entity Framework Core with ASP.NET CoreConfiguring Entity Framework Core as a servicePracticing and exploringExercise 13.1 – online materialConfiguring services and the HTTP request pipelineEnabling HTTP/3 and request decompression supportIntroducing BootstrapExercise 13.2 – practice exercisesBuild a data-driven web pageBuild web pages for functionsExercise 13.3 – test your knowledgeExercise 13.4 – explore topicsSummary
Building Interactive Web Components Using Blazor
Reviewing the Blazor Web App project templateCreating a Blazor Web App projectReviewing Blazor routing, layouts, and navigationHow to define a routable page componentHow to navigate routes and pass route parametersHow to use the navigation link component with routesUnderstanding base component classesRunning the Blazor Web App project templateBuilding components using BlazorDefining and testing a simple Blazor componentUsing Bootstrap iconsMaking the component a routable page componentGetting entities into a Blazor componentAbstracting a service for a Blazor componentEnabling streaming renderingDefining forms using the EditForm componentBuilding a customer detail componentBuilding customer create, edit, and delete componentsTesting the customer componentsPracticing and exploringExercise 14.1 – Online materialEnhancing Blazor appsLeveraging open source Blazor component librariesExercise 14.2 – Practice exercisesCreating a times table componentCreating a country navigation itemExercise 14.3 – Test your knowledgeExercise 14.4 – Explore topicsSummary
Building and Consuming Web Services
Building web services using ASP.NET CoreUnderstanding web service acronymsUnderstanding HTTP requests and responsesASP.NET Core Minimal APIs projectsMinimal APIs web service and native AOT compilationCreating an ASP.NET Core Minimal API projectReviewing the web service’s functionalityRoute constraintsShort-circuit routesImproved route tooling in ASP.NET Core 8 and laterUnderstanding endpoint route handler return typesCreating a web service for the Northwind databaseRegistering dependency servicesIn-memory, distributed, and hybrid cachesIn-memory cachingDistributed cachingHybrid cachingCreating data repositories with caching for entitiesConfiguring the customer repositorySpecifying problem detailsDocumenting and trying out web servicesTrying out GET requests using a browserMaking GET requests using HTTP/REST toolsMaking other requests using HTTP/REST toolsPassing environment variablesUnderstanding the OpenAPI SpecificationEnabling HTTP loggingLogging to the Windows-only Event LogSupport for logging additional request headers in W3CLoggerConsuming web services using HTTP clientsUnderstanding HttpClientConfiguring HTTP clientsGetting customers as JSON in a Blazor componentStarting multiple projectsIf you are using Visual StudioIf you are using VS CodeStarting the web service and Blazor client projectsPracticing and exploringExercise 15.1 – Online materialImplementing advanced features for web servicesMinimal APIs parameter bindingRefit clientWeb service security using Microsoft IdentityExercise 15.2 – Practice exercisesCreating and deleting customers with HttpClientExercise 15.3 – Test your knowledgeExercise 15.4 – Explore topicsSummary
Epilogue
Next steps on your C# and .NET learning journeyPolishing your skills with design guidelinesCompanion books to continue your learning journeyOther books to take your learning furtherThe tenth edition for .NET 10Good luck!Leave a Review!
Index

Content preview from C# 13 and .NET 9 – Modern Cross-Platform Development Fundamentals - Ninth Edition

9 Working with Files, Streams, and Serialization

This chapter is about reading and writing to files and streams, text encoding, and serialization. Applications that do not interact with a filesystem are extraordinarily rare. As a .NET developer, almost every application that you build will need to manage the filesystem and create, open, read, and write to and from files. Most of those files will contain text, so it is important to understand how text is encoded. And finally, after working with objects in memory, you will need to store them somewhere permanently for later reuse. You do that using a technique called serialization.

In this chapter, we will cover the following topics:

Managing a filesystem
Reading and writing with streams
Encoding ...

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

C# 12 and .NET 8 – Modern Cross-Platform Development Fundamentals - Eighth Edition

Publisher Resources

ISBN: 9781835881224

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 13 and .NET 9 – Modern Cross-Platform Development Fundamentals - Ninth Edition

by Mark J. Price

9

Working with Files, Streams, and Serialization

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.