book

C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition

Name: C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition
Author: Mark J. Price
ISBN: 9781803237800

by Mark J. Price

November 2022

Intermediate to advanced

818 pages

20h 38m

English

Packt Publishing

Read now

Unlock full access

Preface
Where to find the code solutionsWhat this book coversWhat you need for this bookGet in touch
Hello, C#! Welcome, .NET!
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 extensionsManaging Visual Studio Code extensions at the command lineUnderstanding 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 Blazor WebAssembly versioningUnderstanding .NET supportUnderstanding .NET Runtime and .NET SDK versionsListing and removing versions of .NETWhat is different about modern .NET?Windows desktop developmentWeb developmentDatabase developmentUnderstanding .NET Standard.NET platforms and tools used by the C# and .NET book editionsTopics covered by Apps and Services with .NET 7Understanding 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 filesUnderstanding top-level programsImplicitly imported namespacesRevealing the hidden code by throwing an exceptionAdding a second project using Visual Studio 2022Building 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 CodeExploring code using .NET Interactive NotebooksUsing .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 videosA companion book to continue your learning journeyPracticing and exploringExercise 1.1 – Test your knowledgeExercise 1.2 – Practice C# anywhere with a browserExercise 1.3 – Explore topicsExercise 1.4 – Explore themes of modern .NETSummary
Speaking C#
Introducing the C# languageUnderstanding language versions and featuresProject COOLC# 1C# 1.2C# 2C# 3C# 4C# 5C# 6C# 7.0C# 7.1C# 7.2C# 7.3C# 8C# 9C# 10C# 11Understanding C# standardsDiscovering your C# compiler versionsHow to output the SDK versionEnabling a specific language version compilerSwitching the C# compiler for .NET 6Understanding 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 textVerbatim stringsRaw string literalsRaw interpolated string literalsSummarizing options for storing textStoring 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 typesExploring more about console appsDisplaying output to the userFormatting using numbered positional argumentsFormatting using interpolated stringsUnderstanding format stringsGetting text input from the userSimplifying 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 APIUnderstanding async and awaitImproving responsiveness for console appsPracticing 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
Controlling Flow, Converting Types, and Handling Exceptions
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 internallyStoring multiple values in an arrayWorking with single-dimensional arraysWorking with multi-dimensional arraysWorking with jagged arraysList pattern matching with arraysSummarizing arraysCasting 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, Debugging, and Testing Functions
Writing functionsUnderstanding top-level programs and functionsTimes table exampleWriting a times table functionA 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 developmentUsing the Visual Studio Code integrated terminal during debuggingCreating code with a deliberate bugSetting a breakpoint and starting debuggingUsing Visual Studio 2022Navigating with the debugging toolbarUsing Visual Studio CodeDebugging windowsStepping through codeCustomizing breakpointsHot reloading during developmentHot reloading using Visual Studio 2022Hot reloading using Visual Studio Code and the command lineLogging 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 2022Adding packages to a project in Visual Studio CodeReviewing project packagesLogging information about your source codeUnit testingUnderstanding types of testingCreating a class library that needs testingWriting unit testsRunning unit tests using Visual Studio 2022Running unit tests using Visual Studio CodeFixing 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
Building Your Own Types with Object-Oriented Programming
Talking about OOPBuilding class librariesCreating a class libraryDefining a class in a namespaceUnderstanding membersInstantiating a classImporting a namespace to use a typeAvoiding a namespace conflict with a using aliasRenaming a type with a using aliasUnderstanding 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 tuplesC# language support for tuplesNaming the fields of a tupleDeconstructing 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 indexersMore about methodsImplementing functionality using methodsImplementing functionality using operatorsImplementing functionality using local functionsPattern matching with objectsDefining 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
Implementing Interfaces and Inheriting Classes
Setting up a class library and console applicationMaking 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 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 typesDefining record struct typesReleasing unmanaged resourcesEnsuring that Dispose is calledWorking with null valuesMaking a value type nullableUnderstanding null-related initialismsUnderstanding nullable reference typesControlling the nullability warning check featureDeclaring 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 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 functionalityWriting better codeTreating warnings as errorsUnderstanding warning wavesUsing 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
Packaging and Distributing .NET Types
The road to .NET 7.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.0.NET 7.0Improving performance with .NET 5 and laterChecking your .NET SDKs for updatesUnderstanding .NET componentsAssemblies, NuGet packages, and namespacesWhat is a namespace?Dependent assembliesMicrosoft .NET project SDKsNamespaces and types in assembliesNuGet packagesUnderstanding 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 2.0 class libraryControlling the .NET SDKPublishing your code for deploymentCreating a console app 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 2022Viewing source links with Visual Studio 2022No, 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 .NET.NET Portability Analyzer.NET Upgrade AssistantUsing non-.NET Standard librariesWorking with preview featuresRequiring preview featuresEnabling preview featuresPracticing and exploringExercise 7.1 – Test your knowledgeExercise 7.2 – Explore topicsExercise 7.3 – Explore PowerShellSummary
Working with Common .NET Types
Working with numbersWorking with big integersWorking with complex numbersUnderstanding quaternionsGenerating random numbers for games and similar appsWorking 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 efficientlyPattern 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 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 listsWorking with 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 serverPracticing and exploringExercise 8.1 – Test your knowledgeExercise 8.2 – Practice regular expressionsExercise 8.3 – Practice writing extension methodsExercise 8.4 – Explore topicsSummary
Working with Files, Streams, and Serialization
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 streamsSimplifying disposal by using the using statementCompressing streamsWorking with tar archivesReading and writing tar entriesEncoding and decoding textEncoding strings as byte arraysEncoding and decoding text in filesReading and writing with random access handlesSerializing 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

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 Core 7Creating a console app for working with EF CoreUsing a sample relational databaseUsing SQLiteSetting up SQLite for WindowsSetting up SQLite for macOSSetting up SQLite for other OSesCreating the Northwind sample database for SQLiteIf you are using Visual Studio 2022Managing the Northwind sample database with SQLiteStudioUsing the lightweight ADO.NET provider for SQLiteUsing SQL Server for WindowsSetting 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 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 databaseCustomizing 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 tagsPattern matching with LikeGenerating a random number in queriesDefining global filtersLoading patterns with EF CoreEager loading entities using the Include extension methodEnabling lazy loadingExplicit loading entities using the Load methodModifying data with EF CoreInserting entitiesUpdating entitiesDeleting entitiesMore efficient updates and deletesPooling database contextsWorking with transactionsControlling transactions using isolation levelsDefining an explicit transactionDefining Code First EF Core modelsPracticing 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
Querying and Manipulating Data Using LINQ
Why LINQ?Comparing imperative and declarative language featuresWriting 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 ThenBySorting by the item itselfDeclaring a query using var or a specified typeFiltering by typeWorking with sets and bags using LINQUsing LINQ with EF CoreBuilding an EF Core modelUsing Visual Studio 2022 with SQLite databasesFiltering and sorting sequencesProjecting sequences into new typesJoining and grouping sequencesJoining sequencesGroup-joining sequencesAggregating sequencesBe careful with Count!Paging with LINQSweetening LINQ syntax with syntactic sugarUsing multiple threads with parallel LINQCreating 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
Introducing Web Development Using ASP.NET Core
Understanding ASP.NET CoreClassic ASP.NET versus modern ASP.NET CoreBuilding websites using ASP.NET CoreBuilding websites using a content management systemBuilding web applications using SPA frameworksBuilding web and other servicesNew 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.0ASP.NET Core 7.0Structuring projectsStructuring projects in a solution or workspaceBuilding an entity model for use in the rest of the bookCreating 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 ServerTesting the class librariesUnderstanding web developmentUnderstanding Hypertext Transfer ProtocolUnderstanding the components of a URLAssigning port numbers for projects in this bookUsing Google Chrome to make HTTP requestsUnderstanding client-side web development technologiesPracticing and exploringExercise 12.1 – Test your knowledgeExercise 12.2 – Know your webbreviationsExercise 12.3 – Explore topicsSummary
Building Websites Using ASP.NET Core Razor Pages
Exploring 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 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 CoreConfiguring 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 librariesDisabling compact folders for Visual Studio CodeCreating a Razor class libraryImplementing 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 projectSetting up the HTTP pipelineSummarizing key middleware extension methodsVisualizing the HTTP pipelineImplementing an anonymous inline delegate as middlewareEnabling request decompression supportEnabling HTTP/3 supportPracticing and exploringExercise 13.1 – Test your knowledgeExercise 13.2 – Practice building a data-driven web pageExercise 13.3 – Practice building web pages for console appsExercise 13.4 – Explore topicsSummary
Building Websites Using the Model-View-Controller Pattern
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 websiteStarting the MVC website projectExploring visitor registrationReviewing an MVC website project structureReviewing the ASP.NET Core Identity databaseExploring an ASP.NET Core MVC websiteASP.NET Core MVC initializationThe default MVC routeControllers and actionsThe ControllerBase classThe Controller classThe responsibilities of a controllerThe view search path conventionLogging using the dependency serviceEntity and view modelsViewsUnderstanding how cache busting with Tag Helpers worksCustomizing an ASP.NET Core MVC websiteDefining a custom styleSetting up the category imagesRazor syntax and expressionsDefining a typed viewPassing parameters using a route valueModel binders in more detailDisambiguating action methodsPassing a route parameterPassing a form parameterValidating the modelDefining views with HTML Helper methodsDefining views with Tag HelpersCross-functional filtersUsing a filter to secure an action methodEnabling role management and creating a role programmaticallyUsing a filter to define a custom routeUsing a filter to cache a responseUsing output cachingOutput caching endpointsOutput caching MVC viewsVarying cached data by query stringQuerying a database and using display templatesImproving scalability using asynchronous tasksMaking controller action methods asynchronousPracticing and exploringExercise 14.1 – Test your knowledgeExercise 14.2 – Practice implementing MVC by implementing a category detail pageExercise 14.3 – Practice improving scalability by understanding and implementing async action methodsExercise 14.4 – Practice unit testing MVC controllersExercise 14.5 – Explore topicsSummary
Building and Consuming Web Services
Building web services using the ASP.NET Core Web APIUnderstanding web service acronymsUnderstanding 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 loggingSupport for logging additional request headers in W3CLoggerConsuming web services using HTTP clientsUnderstanding HttpClientConfiguring HTTP clients using HttpClientFactoryGetting customers as JSON in the controllerStarting multiple projectsIf you are using Visual Studio 2022If you are using Visual Studio CodeStarting the web service and MVC client projectsImplementing advanced features for web servicesBuilding web services using Minimal APIsTesting the minimal weather serviceAdding weather forecasts to the Northwind website home pagePracticing and exploringExercise 15.1 – Test your knowledgeExercise 15.2 – Practice creating and deleting customers with HttpClientExercise 15.3 – Explore topicsSummary
Building User Interfaces Using Blazor
Understanding BlazorJavaScript and friendsSilverlight – C# and .NET using a pluginWebAssembly – a target for BlazorBlazor hosting modelsBlazor componentsWhat is the difference between Blazor and Razor?Comparing Blazor project templatesReviewing the Blazor Server project templateCSS and JavaScript isolationBlazor 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 templateDeployment choices for Blazor WebAssembly appsDifferences between Blazor Server and Blazor WebAssembly projectsSimilarities between Blazor Server and Blazor WebAssembly projectsBuilding components using Blazor ServerDefining and testing a simple Blazor Server componentMaking the component a routable page componentGetting entities into a componentAbstracting a service for a Blazor componentDefining forms using the EditForm componentBuilding a shared customer detail componentBuilding customer create, edit, and delete componentsTesting the customer componentsBuilding components using Blazor WebAssemblyConfiguring the server for Blazor WebAssemblyConfiguring the client for Blazor WebAssemblyTesting the Blazor WebAssembly components and serviceImproving Blazor WebAssembly appsPracticing and exploringExercise 16.1 – Test your knowledgeExercise 16.2 – Practice by creating a times table componentExercise 16.3 – Practice by creating a country navigation itemExercise 16.4 – Explore topicsSummary
Epilogue
The next steps on your C# and .NET learning journeyPolishing your skills with design guidelinesA companion book to continue your learning journeyOther books to take your learning furtherThe eighth edition coming November 2023Good luck!
Index

Content preview from C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition

1 Hello, C#! Welcome, .NET!

In this first chapter, the goals are setting up your development environment; understanding the similarities and differences between modern .NET, .NET Core, .NET Framework, Mono, Xamarin, and .NET Standard; creating the simplest application possible with C# 11 and .NET 7 using various code editors; and then discovering good places to look for help.

The GitHub repository for this book has solutions using full application projects for all code tasks and notebooks when possible:

https://github.com/markjprice/cs11dotnet7

Simply press the . (dot) key or manually change .com to .dev in the link to convert the GitHub repository into a live code editor based on Visual Studio Code using GitHub Codespaces, as shown in Figure ...

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# 9 and .NET 5 – Modern Cross-Platform Development - Fifth Edition

Publisher Resources

ISBN: 9781803237800

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition

by Mark J. Price

1

Hello, C#! Welcome, .NET!

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.