book

C# 10 and .NET 6 – Modern Cross-Platform Development - Sixth Edition

by Mark J. Price

November 2021

Intermediate to advanced

826 pages

20h 10m

English

Packt Publishing

Read now

Unlock full access

Where to find the code solutionsWhere to find the online chaptersWhat this book coversWhat you need for this bookGet in touchShare your thoughts
Setting up your development environmentChoosing the appropriate tool and application type for learningPros and cons of the .NET Interactive Notebooks extensionUsing Visual Studio Code for cross-platform developmentUsing GitHub Codespaces for development in the cloudUsing Visual Studio for Mac for general developmentUsing Visual Studio for Windows for general developmentWhat I usedDeploying cross-platformDownloading and installing Visual Studio 2022 for WindowsMicrosoft Visual Studio for Windows keyboard shortcutsDownloading and installing Visual Studio CodeInstalling other extensionsUnderstanding Microsoft Visual Studio Code versionsMicrosoft Visual Studio Code keyboard shortcutsUnderstanding .NETUnderstanding .NET FrameworkUnderstanding the Mono, Xamarin, and Unity projectsUnderstanding .NET CoreUnderstanding the journey to one .NETUnderstanding .NET supportUnderstanding .NET Runtime and .NET SDK versionsRemoving old versions of .NETWhat is different about modern .NET?Windows developmentWeb developmentDatabase developmentThemes of modern .NETUnderstanding .NET Standard.NET platforms and tools used by the book editionsUnderstanding intermediate languageComparing .NET technologiesBuilding console apps using Visual Studio 2022Managing multiple projects using Visual Studio 2022Writing code using Visual Studio 2022Compiling and running code using Visual StudioUnderstanding the compiler-generated folders and filesWriting top-level programsAdding a second project using Visual Studio 2022Implicitly imported namespacesBuilding console apps using Visual Studio CodeManaging multiple projects using Visual Studio CodeWriting code using Visual Studio CodeCompiling and running code using the dotnet CLIAdding a second project using Visual Studio CodeManaging multiple files using Visual Studio CodeExploring code using .NET Interactive NotebooksCreating a notebookWriting and running code in a notebookSaving a notebookAdding Markdown and special commands to a notebookExecuting code in multiple cellsUsing .NET Interactive Notebooks for the code in this bookReviewing the folders and files for projectsUnderstanding the common folders and filesUnderstanding the solution code on GitHubMaking good use of the GitHub repository for this bookRaising issues with the bookGiving me feedbackDownloading solution code from the GitHub repositoryUsing Git with Visual Studio Code and the command lineCloning the book solution code repositoryLooking for helpReading Microsoft documentationGetting help for the dotnet toolGetting definitions of types and their membersLooking for answers on Stack OverflowSearching for answers using GoogleSubscribing to the official .NET blogWatching Scott Hanselman's videosPracticing and exploringExercise 1.1 – Test your knowledgeExercise 1.2 – Practice C# anywhereExercise 1.3 – Explore topicsSummary
Introducing the C# languageUnderstanding language versions and featuresC# 1.0C# 2.0C# 3.0C# 4.0C# 5.0C# 6.0C# 7.0C# 7.1C# 7.2C# 7.3C# 8C# 9C# 10Understanding C# standardsDiscovering your C# compiler versionsHow to output the SDK versionEnabling a specific language version compilerUnderstanding C# grammar and vocabularyShowing the compiler versionUnderstanding C# grammarStatementsCommentsBlocksExamples of statements and blocksUnderstanding 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# vocabularyWorking with variablesNaming things and assigning valuesLiteral valuesStoring textUnderstanding verbatim stringsStoring numbersStoring whole numbersExploring whole numbersStoring real numbersWriting code to explore number sizesComparing double and decimal typesStoring BooleansStoring any type of objectStoring dynamic typesDeclaring local variablesSpecifying the type of a local variableInferring the type of a local variableUsing target-typed new to instantiate objectsGetting and setting the default values for typesStoring multiple values in an arrayExploring more about console applicationsDisplaying output to the userFormatting using numbered positional argumentsFormatting using interpolated stringsUnderstanding format stringsGetting text input from the userSimplifying the usage of the consoleGetting key input from the userPassing arguments to a console appSetting options with argumentsHandling platforms that do not support an APIPracticing and exploringExercise 2.1 – Test your knowledgeExercise 2.2 – Test your knowledge of number typesExercise 2.3 – Practice number sizes and rangesExercise 2.4 – Explore topicsSummary
Operating on variablesExploring unary operatorsExploring binary arithmetic operatorsAssignment 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 statementPattern 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 internallyCasting and converting between typesCasting numbers implicitly and explicitlyConverting with the System.Convert typeRounding numbersUnderstanding the default rounding rulesTaking control of rounding rulesConverting from any type to a stringConverting from a binary object to a stringParsing from strings to numbers or dates and timesErrors using ParseAvoiding exceptions using the TryParse methodHandling 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 – Test your knowledgeExercise 3.2 – Explore loops and overflowExercise 3.3 – Practice loops and operatorsExercise 3.4 – Practice exception handlingExercise 3.5 – Test your knowledge of operatorsExercise 3.6 – Explore topicsSummary
Writing functionsTimes table exampleWriting a times table functionWriting 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 start debuggingUsing Visual Studio 2022Using Visual Studio CodeNavigating with the debugging toolbarDebugging windowsStepping through codeCustomizing breakpointsLogging during development and runtimeUnderstanding logging optionsInstrumenting with Debug and TraceWriting to the default trace listenerConfiguring trace listenersSwitching trace levelsAdding packages to a project in Visual Studio CodeAdding packages to a project in Visual Studio 2022Reviewing project packagesUnit testingUnderstanding types of testingCreating a class library that needs testingWriting unit testsRunning unit tests using Visual Studio CodeRunning unit tests using Visual StudioFix the bugThrowing and catching exceptions in functionsUnderstanding usage errors and execution errorsCommonly thrown exceptions in functionsUnderstanding the call stackWhere to catch exceptionsRethrowing exceptionsImplementing the tester-doer patternProblems with the tester-doer patternPracticing and exploringExercise 4.1 – Test your knowledgeExercise 4.2 – Practice writing functions with debugging and unit testingExercise 4.3 – Explore topicsSummary
Talking about OOPBuilding class librariesCreating a class libraryDefining a class in a namespaceSimplifying namespace declarationsUnderstanding membersInstantiating a classReferencing an assemblyImporting a namespace to use a typeUnderstanding objectsInheriting from System.ObjectStoring data within fieldsDefining fieldsUnderstanding access modifiersSetting and outputting field valuesStoring a value using an enum typeStoring multiple values using an enum typeStoring multiple values using collectionsUnderstanding generic collectionsMaking a field staticMaking a field constantMaking a field read-onlyInitializing fields with constructorsDefining multiple constructorsWriting and calling methodsReturning values from methodsCombining multiple returned values using tuplesLanguage support for tuplesNaming the fields of a tupleInferring tuple namesDeconstructing tuplesDeconstructing typesDefining and passing parameters to methodsOverloading methodsPassing optional and named parametersNaming parameter values when calling methodsControlling how parameters are passedSimplified out parametersUnderstanding ref returnsSplitting classes using partialControlling access with properties and indexersDefining read-only propertiesDefining settable propertiesRequiring properties to be set during instantiationDefining indexersPattern matching with objectsCreating and referencing a .NET 6 class libraryDefining flight passengersEnhancements to pattern matching in C# 9 or laterWorking with recordsInit-only propertiesUnderstanding recordsPositional data members in recordsSimplifying data members in recordsPracticing and exploringExercise 5.1 – Test your knowledgeExercise 5.2 – Explore topicsSummary
Setting up a class library and console applicationMore about methodsImplementing functionality using methodsImplementing functionality using operatorsImplementing functionality using local functionsRaising and handling eventsCalling methods using delegatesDefining and handling delegatesDefining and handling eventsMaking types safely reusable with genericsWorking with non-generic typesWorking with generic typesImplementing interfacesCommon interfacesComparing objects when sortingComparing objects using a separate classImplicit and explicit interface implementationsDefining interfaces with default implementationsManaging memory with reference and value typesDefining reference and value typesHow reference and value types are stored in memoryEquality of typesDefining struct typesWorking with record struct typesReleasing unmanaged resourcesEnsuring that Dispose is calledWorking with null valuesMaking a value type nullableUnderstanding nullable reference typesEnabling nullable and non-nullable reference typesDeclaring non-nullable variables and parametersChecking for nullChecking for null in method parametersInheriting from classesExtending classes to add functionalityHiding membersOverriding membersInheriting from abstract classesPreventing inheritance and overridingUnderstanding polymorphismCasting within inheritance hierarchiesImplicit castingExplicit castingAvoiding casting exceptionsInheriting and extending .NET typesInheriting exceptionsExtending types when you can't inheritUsing static methods to reuse functionalityUsing extension methods to reuse functionalityUsing an analyzer to write better codeSuppressing warningsFixing the codeUnderstanding common StyleCop recommendationsPracticing and exploringExercise 6.1 – Test your knowledgeExercise 6.2 – Practice creating an inheritance hierarchyExercise 6.3 – Explore topicsSummary
The road to .NET 6.NET Core 1.0.NET Core 1.1.NET Core 2.0.NET Core 2.1.NET Core 2.2.NET Core 3.0.NET Core 3.1.NET 5.0.NET 6.0Improving performance from .NET Core 2.0 to .NET 5Checking your .NET SDKs for updatesUnderstanding .NET componentsUnderstanding assemblies, NuGet packages, and namespacesWhat is a namespace?Understanding dependent assembliesUnderstanding the Microsoft .NET project SDKsUnderstanding namespaces and types in assembliesUnderstanding NuGet packagesUnderstanding frameworksImporting a namespace to use a typeRelating C# keywords to .NET typesMapping C# aliases to .NET typesRevealing the location of a typeSharing code with legacy platforms using .NET StandardUnderstanding defaults for class libraries with different SDKsCreating a .NET Standard 2.0 class libraryControlling the .NET SDKPublishing your code for deploymentCreating a console application to publishUnderstanding dotnet commandsCreating new projectsGetting information about .NET and its environmentManaging projectsPublishing a self-contained appPublishing a single-file appReducing the size of apps using app trimmingEnabling assembly-level trimmingEnabling type-level and member-level trimmingDecompiling .NET assembliesDecompiling using the ILSpy extension for Visual Studio 2022Decompiling using the ILSpy extension for Visual Studio CodeNo, you cannot technically prevent decompilationPackaging 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 packagePorting from .NET Framework to modern .NETCould you port?Should you port?Differences between .NET Framework and modern .NETUnderstanding the .NET Portability AnalyzerUnderstanding the .NET Upgrade AssistantUsing non-.NET Standard librariesWorking with preview featuresRequiring preview featuresEnabling preview featuresGeneric mathematicsPracticing and exploringExercise 7.1 – Test your knowledgeExercise 7.2 – Explore topicsExercise 7.3 – Explore PowerShellSummary
Working with numbersWorking with big integersWorking with complex numbersUnderstanding quaternionsWorking with textGetting the length of a stringGetting the characters of a stringSplitting a stringGetting part of a stringChecking a string for contentJoining, formatting, and other string membersBuilding strings efficientlyWorking with dates and timesSpecifying date and time valuesGlobalization with dates and timesWorking with only a date or a timePattern 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 stringStoring multiple objects in collectionsCommon features of all collectionsImproving performance by ensuring the capacity of a collectionUnderstanding collection choicesListsDictionariesStacksQueuesSetsCollection methods summaryWorking with listsWorking with dictionariesWorking with queuesSorting collectionsMore specialized collectionsWorking with a compact array of bit valuesWorking with efficient listsUsing immutable collectionsGood practice with collectionsWorking with spans, indexes, and rangesUsing memory efficiently using spansIdentifying positions with the Index typeIdentifying ranges with the Range typeUsing indexes, ranges, and spansWorking with network resourcesWorking with URIs, DNS, and IP addressesPinging a serverWorking with reflection and attributesVersioning of assembliesReading assembly metadataCreating custom attributesDoing more with reflectionWorking with imagesInternationalizing your codeDetecting and changing the current culturePracticing and exploringExercise 8.1 – Test your knowledgeExercise 8.2 – Practice regular expressionsExercise 8.3 – Practice writing extension methodsExercise 8.4 – Explore topicsSummary
Managing the 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 helpersWriting to text streamsWriting to XML streamsDisposing of file resourcesSimplifying disposal by using the using statementCompressing streamsCompressing with the Brotli algorithmEncoding and decoding textEncoding strings as byte arraysEncoding and decoding text in filesSerializing object graphsSerializing as XMLGenerating compact XMLDeserializing XML filesSerializing with JSONHigh-performance JSON processingControlling JSON processingNew JSON extension methods for working with HTTP responsesMigrating from Newtonsoft to new JSONPracticing and exploringExercise 9.1 – Test your knowledgeExercise 9.2 – Practice serializing as XMLExercise 9.3 – Explore topicsSummary

Understanding modern databasesUnderstanding legacy Entity FrameworkUsing the legacy Entity Framework 6.3 or laterUnderstanding Entity Framework CoreCreating a console app for working with EF CoreUsing a sample relational databaseUsing Microsoft SQL Server for WindowsDownloading and installing SQL ServerCreating the Northwind sample database for SQL ServerManaging the Northwind sample database with Server ExplorerUsing SQLiteSetting up SQLite for macOSSetting up SQLite for WindowsSetting up SQLite for other OSesCreating the Northwind sample database for SQLiteManaging the Northwind sample database with SQLiteStudioSetting up EF CoreChoosing an EF Core database providerConnecting to a 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 an EF Core model 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 databaseConfiguring preconvention modelsQuerying EF Core modelsFiltering included entitiesUnicode characters in the Windows consoleFiltering and sorting productsGetting the generated SQLLogging EF Core using a custom logging providerFiltering logs by provider-specific valuesLogging with query tagsPattern matching with LikeDefining global filtersLoading patterns with EF CoreEager loading entitiesEnabling lazy loadingExplicit loading entitiesManipulating data with EF CoreInserting entitiesUpdating entitiesDeleting entitiesPooling database contextsWorking with transactionsControlling transactions using isolation levelsDefining an explicit transactionCode First EF Core modelsUnderstanding migrationsPracticing and exploringExercise 10.1 – Test your knowledgeExercise 10.2 – Practice exporting data using different serialization formatsExercise 10.3 – Explore topicsExercise 10.4 – Explore NoSQL databasesSummary
Writing LINQ expressionsWhat makes LINQ?Building LINQ expressions with the Enumerable classUnderstanding deferred executionFiltering entities with WhereTargeting a named methodSimplifying the code by removing the explicit delegate instantiationTargeting a lambda expressionSorting entitiesSorting by a single property using OrderBySorting by a subsequent property using ThenByDeclaring a query using var or a specified typeFiltering by typeWorking with sets and bags using LINQUsing LINQ with EF CoreBuilding an EF Core modelFiltering and sorting sequencesProjecting sequences into new typesJoining and grouping sequencesJoining sequencesGroup-joining sequencesAggregating sequencesSweetening LINQ syntax with syntactic sugarUsing multiple threads with parallel LINQCreating an app that benefits from multiple threadsUsing WindowsUsing macOSFor all operating systemsCreating your own LINQ extension methodsTrying the chainable extension methodTrying the mode and median methodsWorking with LINQ to XMLGenerating XML using LINQ to XMLReading XML using LINQ to XMLPracticing and exploringExercise 11.1 – Test your knowledgeExercise 11.2 – Practice querying with LINQExercise 11.3 – Explore topicsSummary
Understanding processes, threads, and tasksMonitoring performance and resource usageEvaluating the efficiency of typesMonitoring performance and memory using diagnosticsUseful members of the Stopwatch and Process typesImplementing a Recorder classMeasuring the efficiency of processing stringsMonitoring performance and memory using Benchmark.NETRunning tasks asynchronouslyRunning multiple actions synchronouslyRunning multiple actions asynchronously using tasksStarting tasksWaiting for tasksUsing wait methods with tasksContinuing with another taskNested and child tasksWrapping tasks around other objectsSynchronizing access to shared resourcesAccessing a resource from multiple threadsApplying a mutually exclusive lock to a conchUnderstanding the lock statementAvoiding deadlocksSynchronizing eventsMaking CPU operations atomicApplying other types of synchronizationUnderstanding async and awaitImproving responsiveness for console appsImproving responsiveness for GUI appsImproving scalability for web applications and web servicesCommon types that support multitaskingUsing await in catch blocksWorking with async streamsPracticing and exploringExercise 12.1 – Test your knowledgeExercise 12.2 – Explore topicsSummary
Understanding app models for C# and .NETBuilding websites using ASP.NET CoreBuilding websites using a content management systemBuilding web applications using SPA frameworksBuilding web and other servicesBuilding mobile and desktop appsAlternatives to .NET MAUIUnderstanding Uno PlatformUnderstanding AvaloniaNew features in ASP.NET CoreASP.NET Core 1.0ASP.NET Core 1.1ASP.NET Core 2.0ASP.NET Core 2.1ASP.NET Core 2.2ASP.NET Core 3.0ASP.NET Core 3.1Blazor WebAssembly 3.2ASP.NET Core 5.0ASP.NET Core 6.0Building Windows-only desktop appsUnderstanding legacy Windows application platformsUnderstanding modern .NET support for legacy Windows platformsStructuring projectsStructuring projects in a solution or workspaceUsing other project templatesInstalling additional template packsBuilding an entity data model for the Northwind databaseCreating a class library for entity models using SQLiteImproving the class-to-table mappingCreating a class library for a Northwind database contextCreating a class library for entity models using SQL ServerPracticing and exploringExercise 13.1 – Test your knowledgeExercise 13.2 – Explore topicsSummary
Understanding web developmentUnderstanding HTTPUnderstanding the components of a URLAssigning port numbers for projects in this bookUsing Google Chrome to make HTTP requestsUnderstanding client-side web development technologiesUnderstanding ASP.NET CoreClassic ASP.NET versus modern ASP.NET CoreCreating an empty ASP.NET Core projectTesting and securing the websiteEnabling stronger security and redirect to a secure connectionControlling the hosting environmentSeparating configuration for services and pipelineEnabling a website to serve static contentCreating a folder for static files and a web pageEnabling static and default filesExploring ASP.NET Core Razor PagesEnabling Razor PagesAdding code to a Razor PageUsing shared layouts with Razor PagesUsing code-behind files with Razor PagesUsing Entity Framework Core with ASP.NET CoreConfigure Entity Framework Core as a serviceManipulating data using Razor PagesEnabling a model to insert entitiesDefining a form to insert a new supplierInjecting a dependency service into a Razor PageUsing Razor class librariesCreating a Razor class libraryDisabling compact folders for Visual Studio CodeImplementing the employees feature using EF CoreImplementing a partial view to show a single employeeUsing and testing a Razor class libraryConfiguring services and the HTTP request pipelineUnderstanding endpoint routingConfiguring endpoint routingReviewing the endpoint routing configuration in our projectRegistering services in the ConfigureServices methodSetting up the HTTP request pipeline in the Configure methodSummarizing key middleware extension methodsVisualizing the HTTP pipelineImplementing an anonymous inline delegate as middlewarePracticing and exploringExercise 14.1 – Test your knowledgeExercise 14.2 – Practice building a data-driven web pageExercise 14.3 – Practice building web pages for console appsExercise 14.4 – Explore topicsSummary
Setting up an ASP.NET Core MVC websiteCreating an ASP.NET Core MVC websiteCreating the authentication database for SQL Server LocalDBExploring the default ASP.NET Core MVC websiteUnderstanding visitor registrationReviewing an MVC website project structureReviewing the ASP.NET Core Identity databaseExploring an ASP.NET Core MVC websiteUnderstanding ASP.NET Core MVC initializationUnderstanding the default MVC routeUnderstanding controllers and actionsUnderstanding the ControllerBase classUnderstanding the Controller classUnderstanding the responsibilities of a controllerUnderstanding the view search path conventionUnderstanding loggingUnderstanding filtersUsing a filter to secure an action methodEnabling role management and creating a role programmaticallyUsing a filter to cache a responseUsing a filter to define a custom routeUnderstanding entity and view modelsUnderstanding viewsCustomizing an ASP.NET Core MVC websiteDefining a custom styleSetting up the category imagesUnderstanding Razor syntaxDefining a typed viewReviewing the customized home pagePassing parameters using a route valueUnderstanding model binders in more detailDisambiguating action methodsPassing a route parameterPassing a form parameterValidating the modelUnderstanding view helper methodsQuerying a database and using display templatesImproving scalability using asynchronous tasksMaking controller action methods asynchronousPracticing and exploringExercise 15.1 – Test your knowledgeExercise 15.2 – Practice implementing MVC by implementing a category detail pageExercise 15.3 – Practice improving scalability by understanding and implementing async action methodsExercise 15.4 – Practice unit testing MVC controllersExercise 15.5 – Explore topicsSummary
Building web services using ASP.NET Core Web APIUnderstanding web service acronymsUnderstanding Windows Communication Foundation (WCF)An alternative to WCFUnderstanding HTTP requests and responses for Web APIsCreating an ASP.NET Core Web API projectReviewing the web service's functionalityCreating a web service for the Northwind databaseCreating data repositories for entitiesImplementing a Web API controllerUnderstanding action method return typesConfiguring the customer repository and Web API controllerSpecifying problem detailsControlling XML serializationDocumenting and testing web servicesTesting GET requests using a browserTesting HTTP requests with the REST Client extensionMaking GET requests using REST ClientMaking other requests using REST ClientUnderstanding SwaggerTesting requests with Swagger UIEnabling HTTP loggingConsuming web services using HTTP clientsUnderstanding HttpClientConfiguring HTTP clients using HttpClientFactoryGetting customers as JSON in the controllerEnabling Cross-Origin Resource SharingImplementing advanced features for web servicesImplementing a Health Check APIImplementing Open API analyzers and conventionsImplementing transient fault handlingAdding security HTTP headersBuilding web services using minimal APIsBuilding a weather service using minimal APIsTesting the minimal weather serviceAdding weather forecasts to the Northwind website home pagePracticing and exploringExercise 16.1 – Test your knowledgeExercise 16.2 – Practice creating and deleting customers with HttpClientExercise 16.3 – Explore topicsSummary
Understanding BlazorJavaScript and friendsSilverlight – C# and .NET using a pluginWebAssembly – a target for BlazorUnderstanding Blazor hosting modelsUnderstanding Blazor componentsWhat is the difference between Blazor and Razor?Comparing Blazor project templatesReviewing the Blazor Server project templateUnderstanding CSS and JavaScript isolationUnderstanding Blazor routing to page componentsHow to define a routable page componentHow to navigate Blazor routesHow to pass route parametersUnderstanding base component classesHow to use the navigation link component with routesRunning the Blazor Server project templateReviewing the Blazor WebAssembly project templateBuilding components using Blazor ServerDefining and testing a simple componentMaking the component a routable page componentGetting entities into a componentAbstracting a service for a Blazor componentDefining forms using the EditForm componentBuilding and using a customer form componentTesting the customer form componentBuilding components using Blazor WebAssemblyConfiguring the server for Blazor WebAssemblyConfiguring the client for Blazor WebAssemblyTesting the Blazor WebAssembly components and serviceImproving Blazor WebAssembly appsEnabling Blazor WebAssembly AOTExploring Progressive Web App supportImplementing offline support for PWAsUnderstanding the browser compatibility analyzer for Blazor WebAssemblySharing Blazor components in a class libraryInterop with JavaScriptLibraries of Blazor componentsPracticing and exploringExercise 17.1 – Test your knowledgeExercise 17.2 – Practice by creating a times table componentExercise 17.3 – Practice by creating a country navigation itemExercise 17.4 – Explore topicsSummary
Next steps on your C# and .NET learning journeyPolishing your skills with design guidelinesBooks to take your learning further.NET MAUI delayedNext edition coming November 2022Good luck!Share your thoughts

Content preview from C# 10 and .NET 6 – Modern Cross-Platform Development - Sixth Edition

09 Working with Files, Streams, and Serialization

This chapter is about reading and writing to files and streams, text encoding, and serialization.

We will cover the following topics:

Managing the filesystem
Reading and writing with streams
Encoding and decoding text
Serializing object graphs
Controlling JSON processing

Managing the filesystem

Your applications will often need to perform input and output operations with files and directories in different environments. The System and System.IO namespaces contain classes for this purpose.

Handling cross-platform environments and filesystems

Let's explore how to handle cross-platform environments like the differences between Windows and Linux or macOS. Paths are different for Windows, macOS, ...