book

C# 14 and .NET 10 – Modern Cross-Platform Development Fundamentals - Tenth Edition

Name: C# 14 and .NET 10 – Modern Cross-Platform Development Fundamentals - Tenth Edition
Author: Mark J. Price
ISBN: 9781836206637

by Mark J. Price

November 2025

Beginner to intermediate

828 pages

20h 39m

English

Packt Publishing

Read now

Unlock full access

Contributors
Join .NETPro — It’s Free
Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touchFree Benefits with Your BookHow to Unlock
Hello, C#! Welcome, .NET!
Free Benefits with Your BookIntroducing this book and its contentsGetting code solutions for this book.NET terms used in this bookThe style of this bookTopics covered by this bookTopics covered by Real-World Web Development with .NET 10Topics covered by Apps and Services with .NET 10Topics covered by Tools and Skills for .NET 10Shared content across all my booksFinding 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 developmentCross-platform development on WindowsWhat 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 .NET support phasesUnderstanding end of lifeUnderstanding .NET Runtime and .NET SDK versionsListing and removing versions of .NETUnderstanding how .NET and C# are relatedUnderstanding intermediate languageComparing legacy and modern .NET technologiesBuilding console apps and managing multiple projects in a solutionBuilding .NET projects using Visual StudioCompiling and running code using Visual StudioAttaching the debugger in 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 StudioMaking good use of the GitHub repository for this bookUnderstanding the solution code on GitHubRaising issues with the bookGiving me feedbackAvoiding common mistakesDownloading the solution code from the GitHub repositoryUsing Git with VS Code and the command promptCloning the book solution code repositoryRunning a C# code file without a project fileIntroducing file-based appsCreating a file-based appConfiguring no-project C# code filesConverting a file-based app to a project-based appPublishing a file-based appLooking for helpPracticing 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 newslettersCopilot articlesExercise 1.2 – Practice exercisesPractice C# anywhere with a browserFuture versions of .NETExercise 1.3 – Test your knowledgeExercise 1.4 – Explore topicsSummaryJoin .NETPro — It’s Free
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 10 to a future versionShowing the compiler versionUnderstanding C# grammar and vocabularyStatementsCommentsBlocksRegionsExamples of statements and blocksChanging the color scheme for C# syntaxFormatting code using white spaceUnderstanding C# vocabularyComparing programming languages to human languagesHelp with 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 textRepresenting the escape characterVerbatim literal 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 typesDynamic types with ExpandoObjectDeclaring 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 formattingOutputting a value using multiple formatsGetting 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 argumentsPracticing and exploringExercise 2.1 – Online materialHandling platforms that do not support an APIExplore Spectre and other console app enhancement packagesExercise 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 operatorsNull-conditional assignment operatorExploring logical operatorsExploring conditional logical operatorsExploring bitwise and binary shift operatorsMiscellaneous operatorsUnderstanding selection statementsBranching with the if statementWhy you should always use braces with if statementsEarly return or guard clause style 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 blockDisabling the warning using the null-forgiving operatorCatching 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 recursionChecking for number overflowDocumenting functions with XML commentsGetting ChatGPT to add XML commentsUsing lambdas in function implementationsDebugging during developmentCreating code with a deliberate bugSetting a breakpoint and starting debuggingNavigating with the debugging toolbarDebugging windowsStepping through codeCustomizing breakpointsHot reloading during developmentHot reloading using Visual StudioUnit testingUnderstanding types of testingCreating a class library that needs testingWriting unit testsRunning unit testsFixing 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 stackCreating a class library with some functions to callCreating a console app to call the class libraryWhere to catch exceptionsRethrowing exceptionsRethrowing exceptions in actionImplementing the tester-doer and try patternsPracticing and exploringExercise 4.1 – online materialLogging during development and runtimeFree .NET debugging bookExercise 4.2 – practice exercisesWriting functions with debugging and unit testingExercise 4.3 – test your knowledgeExercise 4.4 – explore topicsSummaryJoin .NETPro — It’s Free
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-onlyOutputting an object’s state using DumpifyRequiring 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 parametersCombining 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 propertiesImplementing properties using the field keywordLimiting flags enum valuesPartial membersDefining 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 materialPartial membersPattern matchingDiscriminated union types in C#Exercise 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 appStatic methods and overloading operatorsImplementing functionality using methodsImplementing functionality using operatorsDumping an object graph to the outputMaking types safely reusable with genericsWorking with non-generic typesWorking with generic typesRaising and handling eventsCalling methods using delegatesDefining and handling delegatesDefining and handling eventsImplementing interfacesCommon interfacesComparing objects when sortingImplicit and explicit interface implementationsDefining interfaces with default implementationsAdding a default implementationWorking 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 styleExtension membersExtension blocksExtending static typesDocumentation about extension membersPracticing and exploringExercise 6.1 – Online materialManaging memory with reference and value typesWriting better codeExtension membersExercise 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 10.NET Standard-compatible frameworksChecking your .NET SDKs for updatesUnderstanding .NET componentsAssemblies and NuGet packagesDependent assembliesWhat is a namespace?.NET project SDKsProject file configurationThe PropertyGroup elementThe ItemGroup 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 libraryChoosing between targeting .NET Standard 2.0 and .NET 10 for class librariesControlling 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 CLINoun-first alias for dotnet CLI commandsSetting project properties at the command linePublishing 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 dependenciesVersion rangesPackaging 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 packagePracticing and exploringExercise 7.1 – Online materialWorking with preview featuresImproving performance in .NETDecompiling .NET assembliesPorting from .NET Framework to modern .NETMulti-targeting frameworksRewriting NuGet Restore in .NET 9 and laterExercise 7.2 – Practice exercisesCreating source generatorsExercise 7.3 – Test your knowledgeExercise 7.4 – Explore topicsSummary
Working with Common .NET Types
Working with numbersWorking with big integersMultiplying big integersWorking with complex numbersGenerating 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 valuesNumeric ordering for string comparisonJoining, 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 listsUsing read-only listsWorking with dictionariesSets, stacks, and queuesWorking with setsWorking with queuesCollection add and remove methodsSorting collectionsSpecialized collectionsRead-only, immutable, and frozen collectionsAdding to an immutable collectionExploring frozen collectionsInitializing collections using collection expressionsUsing the spread elementGood practice with collectionsPresizing collectionsPassing collections to methodsReturning collections from membersPracticing and exploringExercise 8.1 – online materialWorking with spans, indexes, and rangesWorking with network resourcesCollection expressionsExercise 8.2 – practice exercisesRegular expressionsExtension methodsExercise 8.3 – test your knowledgeExercise 8.4 – explore topicsSummaryJoin .NETPro — It’s Free

Working with Files, Streams, and Serialization
Managing a filesystemHandling cross-platform environments and filesystemsReading drive informationManaging 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 streamsAsynchronous ZIP archive APIsReading 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 exporterJSON Patch implementation improvementsControlling JSON processingPracticing and exploringExercise 9.1 – Online materialA warning about binary serialization using BinaryFormatterWorking with tar archivesMigrating from Newtonsoft to the 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 firstUsing 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 SQLiteStudioEF Core and AOTUsing 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 codeWhy the EF Core CLI cannot use data annotations for everythingCustomizing 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 modelImplementing asynchronous methods with EF CoreWhat’s new in EF Core 10Exploring 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 the Where extensionTargeting 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 lookupsDifference between GroupBy and ToLookupLeft and right join LINQ extension methodsPracticing and exploringExercise 11.1 – Online materialAggregating and paging sequencesUsing multiple threads with parallel LINQWorking with LINQ to XMLCreating your own LINQ extension methodsReviewing the implementation of SumExercise 11.2 – Practice querying with LINQExercise 11.3 – Test your knowledgeExercise 11.4 – Explore topicsSummary
Introducing Modern Web Development Using .NET
Understanding ASP.NET CoreHistory of Microsoft web-related development technologiesClassic ASP.NET and IIS versus modern ASP.NET Core and KestrelBuilding websites using ASP.NET CoreComparison of file types used in ASP.NET CoreBuilding websites using a content management systemBuilding web applications using SPA frameworksFluent UI ReactBuilding web and other servicesBuilding desktop and mobile appsMobile app platforms.NET MAUIUno platformAvaloniaStructuring projectsStructuring projects in a solutionCentral package managementFeatures and benefits of CPMDefining project properties to reuse version numbersCPM good practicePackage source mappingUnderstanding package source mappingEnabling PSMBuilding 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 SQLiteCreate a logger file in the data context projectMove and customize the data contextCustomizing 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 librariesPracticing and exploringExercise 12.1 – Online materialUnderstanding web developmentExercise 12.2 – Practice exercisesTroubleshooting web developmentExercise 12.3 – Test your knowledgeKnow your webbreviationsExercise 12.4 – Explore topicsSummaryJoin .NETPro — It’s Free
Building Websites Using ASP.NET Core
Exploring ASP.NET CoreArchitecture of ASP.NET CoreCreating an empty ASP.NET Core projectCreating and configuring the projectReviewing the global namespace importsReviewing the Program.cs fileAdding new endpoints to the serviceStarting and securing the websiteReviewing 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 8 and laterUnderstanding 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 actionsDetecting if a link is localUsing EF Core with ASP.NET CorePracticing 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 pageExercise 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 componentBuild web pages for functionsCreating 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 responsesMaking a GET request and common responsesMaking other requests, such as POST, PUT, and DELETE, and common responsesDocumenting web services with Swagger, OpenAPI, and SwashbuckleASP.NET Core Minimal API web service projectsMinimal API web service and native AOT compilationA non-benefit of the Minimal APICreating an ASP.NET Core Minimal API projectImproving the weather serviceReviewing the web service’s functionalityRoute constraintsShort-circuit routesUnderstanding endpoint route handler return typesCreating a web service for the Northwind databaseConfiguring the customer endpointsSpecifying problem detailsValidation support in Minimal API web servicesDocumenting and trying out web servicesTrying out GET requests using a browserClearing Chrome’s address bar autocompleteDesigning for case sensitivityTrying out other requests using a browserMaking GET requests using HTTP/REST toolsMaking other requests using HTTP/REST toolsPassing environment variablesReviewing and customizing the OpenAPI documentGenerating OpenAPI documents in YAML formatPopulating XML documentation comments into the OpenAPI documentImplementing Scalar for documentationEnabling HTTP loggingConsuming web services using HTTP clientsUnderstanding HttpClientConfiguring HTTP clientsCreating a Blazor WebAssembly clientConfiguring the web service to allow the client to make requestsGetting customers as JSON in a Blazor componentStarting multiple projectsIf you are using Visual Studio – manually starting each projectIf you are using Visual Studio – starting multiple projects automaticallyIf you are using VS CodeStarting the web service and Blazor client projectsPracticing and exploringExercise 15.1 – Online materialImplementing asynchronous endpointsImplementing advanced features for web servicesMinimal API 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
Unlock Your Exclusive Benefits
Unlock this Book’s Free Benefits in 3 Easy StepsStep 1Step 2Step 3Need help?
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 furtherUsing this book with future versions of .NETGood luck!
Index

Content preview from C# 14 and .NET 10 – Modern Cross-Platform Development Fundamentals - Tenth Edition

14 Building Interactive Web Components Using Blazor

This chapter is about using Blazor to build interactive web user interface components. You will learn how to build Blazor components that can execute their C# and .NET code on the web server or in the web browser.

When components execute on the server, Blazor uses SignalR to communicate necessary updates to the user interface in the browser.

When components execute in the browser using WebAssembly, they must make HTTP calls to interact with data on the server. You will learn more about this in Chapter 15, Building and Consuming Web Services.

In this chapter, we will cover the following topics:

Reviewing the Blazor Web App project template
Building components using Blazor
Defining forms using ...

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: 9781836206637

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 14 and .NET 10 – Modern Cross-Platform Development Fundamentals - Tenth Edition

by Mark J. Price

14

Building Interactive Web Components Using Blazor

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.