book

C# 9 and .NET 5 – Modern Cross-Platform Development - Fifth Edition

Name: C# 9 and .NET 5 – Modern Cross-Platform Development - Fifth Edition
Author: Mark J. Price
ISBN: 9781800568105

by Mark J. Price

November 2020

Beginner to intermediate

822 pages

19h 18m

English

Packt Publishing

Read now

Unlock full access

Preface
What this book coversWhat you need for this bookDownloading the color images of this bookConventionsGet in touchReviews
Hello, C#! Welcome, .NET!
Setting up your development environmentUsing Visual Studio Code for cross-platform developmentUsing GitHub Codespaces for development in the cloudUsing Visual Studio 2019 for Windows app developmentUsing Visual Studio for Mac for mobile developmentRecommended tools for chaptersDeploying cross-platformUnderstanding Microsoft Visual Studio Code versionsDownloading and installing Visual Studio CodeInstalling other extensionsUnderstanding .NETUnderstanding .NET FrameworkUnderstanding the Mono and Xamarin projectsUnderstanding .NET CoreUnderstanding .NET 5 and the journey to one .NETUnderstanding .NET supportUnderstanding .NET Runtime and .NET SDK versionsRemoving old versions of .NETWhat is different about .NET Core and .NET 5?Understanding .NET Standard.NET platforms and tools used by the book editionsUnderstanding intermediate languageComparing .NET technologiesBuilding console apps using Visual Studio CodeWriting code using Visual Studio CodeCompiling and running code using the dotnet CLIWriting top-level programsDownloading solution code from the GitHub repositoryUsing Git with Visual Studio CodeCloning 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 blogScott Hanselman's videosPracticing and exploringExercise 1.1 – Test your knowledgeExercise 1.2 – Practice C# anywhereExercise 1.3 – Explore topicsSummary
Speaking C#
Introducing C#Understanding language versions and featuresC# 1.0C# 2.0C# 3.0C# 4.0C# 5.0C# 6.0C# 7.0C# 7.1C# 7.2C# 7.3C# 8.0C# 9.0Discovering your C# compiler versionsEnabling a specific language version compilerUnderstanding C# basicsUnderstanding C# grammarStatementsCommentsBlocksUnderstanding C# vocabularyChanging the color scheme for syntaxComparing programming languages to human languagesHelp for writing correct codeVerbs are methodsNouns are types, fields, and variablesRevealing the extent of the C# vocabularyWorking with variablesNaming things and assigning valuesLiteral valuesStoring textUnderstanding verbatim stringsStoring numbersStoring whole numbersStoring real numbersWriting code to explore number sizesComparing double and decimal typesStoring BooleansUsing Visual Studio Code workspacesStoring any type of objectStoring dynamic typesDeclaring local variablesSpecifying and inferring the type of a local variableUsing target-typed new to instantiate objectsGetting default values for typesStoring multiple valuesWorking with null valuesMaking a value type nullableUnderstanding nullable reference typesEnabling nullable and non-nullable reference typesDeclaring non-nullable variables and parametersChecking for nullExploring console applications furtherDisplaying output to the userFormatting using numbered positional argumentsFormatting using interpolated stringsUnderstanding format stringsGetting text input from the userImporting a namespaceSimplifying the usage of the consoleGetting key input from the userGetting argumentsSetting options with argumentsHandling platforms that do not support an APIPracticing and exploringExercise 2.1 – Test your knowledgeExercise 2.2 – Practice number sizes and rangesExercise 2.3 – Explore topicsSummary
Controlling Flow and Converting Types
Operating on variablesUnary operatorsBinary arithmetic operatorsAssignment operatorsLogical operatorsConditional logical operatorsBitwise 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 timesAvoiding exceptions using the TryParse methodHandling exceptions when converting typesWrapping error-prone code in a try blockCatching all exceptionsCatching specific exceptionsChecking 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 functionsWriting a times table functionWriting a function that returns a valueWriting mathematical functionsConverting numbers from cardinal to ordinalCalculating factorials with recursionDocumenting functions with XML commentsUsing lambdas in function implementationsDebugging during developmentCreating code with a deliberate bugSetting a breakpointNavigating with the debugging toolbarDebugging windowsStepping through codeCustomizing breakpointsLogging during development and runtimeInstrumenting with Debug and TraceWriting to the default trace listenerConfiguring trace listenersSwitching trace levelsUnit testing functionsCreating a class library that needs testingWriting unit testsRunning unit testsPracticing 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 object-oriented programmingBuilding class librariesCreating a class libraryDefining a classUnderstanding membersInstantiating a classReferencing an assemblyImporting a namespace to use a typeManaging multiple filesUnderstanding 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 collectionsMaking a field staticMaking a field constantMaking a field read-onlyInitializing fields with constructorsSetting fields with default literalsWriting and calling methodsReturning values from methodsCombining multiple returned values using tuplesNaming the fields of a tupleInferring tuple namesDeconstructing tuplesDefining and passing parameters to methodsOverloading methodsPassing optional parameters and naming argumentsControlling how parameters are passedUnderstanding ref returnsSplitting classes using partialControlling access with properties and indexersDefining read-only propertiesDefining settable propertiesDefining indexersPattern matching with objectsCreating and referencing a .NET 5 class libraryDefining flight passengersEnhancements to pattern matching in C# 9Working with recordsInit-only propertiesUnderstanding recordsSimplifying data membersPositional recordsPracticing and exploringExercise 5.1 – Test your knowledgeExercise 5.2 – Explore topicsSummary
Implementing Interfaces and Inheriting Classes
Setting up a class library and console applicationSimplifying methodsImplementing functionality using methodsImplementing functionality using operatorsImplementing functionality using local functionsRaising and handling eventsCalling methods using delegatesDefining and handling delegatesDefining and handling eventsImplementing interfacesCommon interfacesComparing objects when sortingComparing objects using a separate classDefining interfaces with default implementationsMaking types safely reusable with genericsWorking with generic typesWorking with generic methodsManaging memory with reference and value typesWorking with struct typesReleasing unmanaged resourcesEnsuring that Dispose is calledInheriting from classesExtending classes to add functionalityHiding membersOverriding membersPreventing 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 functionalityPracticing and exploringExercise 6.1 – Test your knowledgeExercise 6.2 – Practice creating an inheritance hierarchyExercise 6.3 – Explore topicsSummary
Understanding and Packaging .NET Types
Introducing .NET 5.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 5.0Improving performance from .NET Core 2.0 to .NET 5Understanding .NET componentsUnderstanding assemblies, packages, and namespacesUnderstanding dependent assembliesUnderstanding the Microsoft .NET project SDKsUnderstanding NuGet packagesUnderstanding frameworksImporting a namespace to use a typeRelating C# keywords to .NET typesSharing code with legacy platforms using .NET StandardCreating a .NET Standard 2.0 class libraryPublishing your applications for deploymentCreating a console application to publishUnderstanding dotnet commandsCreating new projectsManaging projectsPublishing a self-contained appPublishing a single-file appReducing the size of apps using app trimmingDecompiling assembliesPackaging your libraries for NuGet distributionReferencing a NuGet packageFixing dependenciesPackaging a library for NuGetTesting your packagePorting from .NET Framework to .NET 5Could you port?Should you port?Differences between .NET Framework and .NET 5Understanding the .NET Portability AnalyzerUsing non-.NET Standard librariesPracticing and exploringExercise 7.1 – Test your knowledgeExercise 7.2 – Explore topicsSummary
Working with Common .NET Types
Working with numbersWorking with big integersWorking with complex numbersWorking 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 textUnderstanding the syntax of a regular expressionExamples of regular expressionsSplitting a complex comma-separated stringRegular expression performance improvementsStoring multiple objects in collectionsCommon features of all collectionsUnderstanding collection choicesListsDictionariesStacksQueuesSetsWorking with listsWorking with dictionariesSorting collectionsUsing specialized collectionsUsing immutable collectionsWorking with spans, indexes, and rangesUsing memory efficiently using spansIdentifying positions with the Index typeIdentifying ranges with the Range typeUsing indexes and rangesWorking with network resourcesWorking with URIs, DNS, and IP addressesPinging a serverWorking with types and attributesVersioning of assembliesReading assembly metadataCreating custom attributesDoing more with reflectionWorking with imagesInternationalizing your codeDetecting and changing the current cultureHandling time zonesPracticing 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 streamsWriting to text streamsWriting to XML streamsDisposing of file resourcesCompressing streamsCompressing with the Brotli algorithmHigh-performance streams using pipelinesAsynchronous streamsEncoding and decoding textEncoding strings as byte arraysEncoding and decoding text in filesSerializing object graphsSerializing as XMLGenerating compact XMLDeserializing XML filesSerializing with JSONHigh-performance JSON processingPracticing and exploringExercise 9.1 – Test your knowledgeExercise 9.2 – Practice serializing as XMLExercise 9.3 – Explore topicsSummary

Protecting Your Data and Applications
Understanding the vocabulary of protectionKeys and key sizesIVs and block sizesSaltsGenerating keys and IVsEncrypting and decrypting dataEncrypting symmetrically with AESHashing dataHashing with the commonly used SHA256Signing dataSigning with SHA256 and RSAGenerating random numbersGenerating random numbers for gamesGenerating random numbers for cryptographyWhat's new in cryptography?Authenticating and authorizing usersImplementing authentication and authorizationProtecting application functionalityPracticing and exploringExercise 10.1 – Test your knowledgeExercise 10.2 – Practice protecting data with encryption and hashingExercise 10.3 – Practice protecting data with decryptionExercise 10.4 – Explore topicsSummary
Working with Databases Using Entity Framework Core
Understanding modern databasesUnderstanding legacy Entity FrameworkUnderstanding Entity Framework CoreUsing a sample relational databaseSetting up SQLite for macOSSetting up SQLite for WindowsCreating the Northwind sample database for SQLiteManaging the Northwind sample database with SQLiteStudioSetting up EF CoreChoosing an EF Core database providerSetting up the dotnet-ef toolConnecting to the databaseDefining EF Core modelsEF Core conventionsEF Core annotation attributesEF Core Fluent APIUnderstanding data seedingBuilding an EF Core modelDefining the Category and Product entity classesDefining the Northwind database context classScaffolding models using an existing databaseQuerying EF Core modelsFiltering included entitiesFiltering and sorting productsGetting the generated SQLLogging EF CoreLogging 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 contextsTransactionsDefining an explicit transactionPracticing and exploringExercise 11.1 – Test your knowledgeExercise 11.2 – Practice exporting data using different serialization formatsExercise 11.3 – Explore the EF Core documentationSummary
Querying and Manipulating Data Using LINQ
Writing LINQ queriesExtending sequences with the Enumerable classFiltering 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 ThenByFiltering 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 sequencesAggregating sequencesSweetening LINQ syntax with syntactic sugarUsing multiple threads with parallel LINQCreating an app that benefits from multiple threadsUsing Windows 10Using macOSFor all operating systemsCreating your own LINQ extension methodsWorking with LINQ to XMLGenerating XML using LINQ to XMLReading XML using LINQ to XMLPracticing and exploringExercise 12.1 – Test your knowledgeExercise 12.2 – Practice querying with LINQExercise 12.3 – Explore topicsSummary
Improving Performance and Scalability Using Multitasking
Understanding processes, threads, and tasksMonitoring performance and resource usageEvaluating the efficiency of typesMonitoring performance and memory useImplementing the Recorder classMeasuring the efficiency of processing stringsRunning tasks asynchronouslyRunning multiple actions synchronouslyRunning multiple actions asynchronously using tasksWaiting for tasksContinuing with another taskNested and child tasksSynchronizing access to shared resourcesAccessing a resource from multiple threadsApplying a mutually exclusive lock to a resourceUnderstanding the lock statement and avoiding 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 13.1 – Test your knowledgeExercise 13.2 – Explore topicsSummary
Introducing Practical Applications of C# and .NET
Understanding app models for C# and .NETBuilding websites using ASP.NET CoreBuilding websites using a web content management systemUnderstanding web applicationsBuilding and consuming web servicesBuilding intelligent appsNew 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.0Understanding SignalRUnderstanding BlazorJavaScript and friendsSilverlight – C# and .NET using a pluginWebAssembly – a target for BlazorBlazor on the server side or client sideUnderstanding the bonus chaptersBuilding cross-platform mobile and desktop appsBuilding Windows desktop apps using legacy technologiesBuilding an entity data model for NorthwindCreating a class library for Northwind entity modelsGenerating entity models using dotnet-efManually improving the class-to-table mappingCreating a class library for a Northwind database contextSummary
Building Websites Using ASP.NET Core Razor Pages
Understanding web developmentUnderstanding HTTPClient-side web developmentUnderstanding ASP.NET CoreClassic ASP.NET versus modern ASP.NET CoreCreating an ASP.NET Core projectTesting and securing the websiteControlling the hosting environmentEnabling static and default filesExploring Razor PagesEnabling Razor PagesDefining 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 new suppliersUsing Razor class librariesCreating a Razor class libraryDisabling compact foldersImplementing 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 pipelineRegistering servicesConfiguring the HTTP request pipelineSimplest possible ASP.NET Core website projectPracticing and exploringExercise 15.1 – Test your knowledgeExercise 15.2 – Practice building a data-driven web pageExercise 15.3 – Practice building web pages for console appsExercise 15.4 – Explore topicsSummary
Building Websites Using the Model-View-Controller Pattern
Setting up an ASP.NET Core MVC websiteCreating and exploring an ASP.NET Core MVC websiteReviewing the ASP.NET Core MVC websiteReviewing the ASP.NET Core Identity databaseExploring an ASP.NET Core MVC websiteUnderstanding ASP.NET Core MVC startupUnderstanding the default MVC routeUnderstanding controllers and actionsUnderstanding the view search path conventionUnit testing MVCUnderstanding filtersUsing a filter to secure an action methodUsing 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 bindersValidating the modelUnderstanding view helper methodsQuerying a database and using display templatesImproving scalability using asynchronous tasksMaking controller action methods asynchronousUsing other project templatesInstalling additional template packsPracticing and exploringExercise 16.1 – Test your knowledgeExercise 16.2 – Practice implementing MVC by implementing a category detail pageExercise 16.3 – Practice improving scalability by understanding and implementing async action methodsExercise 16.4 – Explore topicsSummary
Building Websites Using a Content Management System
Understanding the benefits of a CMSUnderstanding basic CMS featuresUnderstanding enterprise CMS featuresUnderstanding CMS platformsUnderstanding Piranha CMSOpen source libraries and licensingCreating a Piranha CMS websiteExploring a Piranha CMS websiteEditing site and page contentCreating a new top-level pageCreating a new child pageReviewing the blog archiveCommenting on posts and pagesExploring authentication and authorizationExploring configurationTesting the new contentUnderstanding routingUnderstanding mediaUnderstanding the application serviceUnderstanding content typesUnderstanding component typesUnderstanding standard fieldsCustomizing the rich text editorReviewing the Standard page typeReviewing the Standard archive and post typesUnderstanding standard blocksReviewing component types and standard blocksDefining components, content types, and templatesCreating custom regionsCreating an entity data modelCreating custom page typesCreating custom view modelsDefining custom content templates for content typesConfiguring startup and importing from a databaseLearning how to create content using the project templateTesting the Northwind CMS websiteUploading images and creating the catalog rootImporting category and product contentManaging catalog contentReviewing how Piranha stores contentPracticing and exploringExercise 17.1 – Test your knowledgeExercise 17.2 – Practice defining a block type for rendering YouTube videosExercise 17.3 – Explore topicsSummary
Building and Consuming Web Services
Building web services using the ASP.NET Core Web APIUnderstanding web service acronymsCreating 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 controllerConfiguring the customers repository and Web API controllerSpecifying problem detailsControlling XML serializationDocumenting and testing web servicesTesting GET requests using a browserTesting HTTP requests with the REST Client extensionUnderstanding SwaggerTesting requests with Swagger UIConsuming services using HTTP clientsUnderstanding HttpClientConfiguring HTTP clients using HttpClientFactoryGetting customers as JSON in the controllerEnabling Cross-Origin Resource SharingImplementing advanced featuresImplementing a Health Check APIImplementing Open API analyzers and conventionsImplementing transient fault handlingUnderstanding endpoint routingConfiguring endpoint routingAdding security HTTP headersSecuring web servicesUnderstanding other communication technologiesUnderstanding Windows Communication Foundation (WCF)Understanding gRPCPracticing and exploringExercise 18.1 – Test your knowledgeExercise 18.2 – Practice creating and deleting customers with HttpClientExercise 18.3 – Explore topicsSummary
Building Intelligent Apps Using Machine Learning
Understanding machine learningUnderstanding the machine learning lifecycleUnderstanding datasets for training and testingUnderstanding machine learning tasksUnderstanding Microsoft Azure Machine LearningUnderstanding ML.NETUnderstanding Infer.NETUnderstanding ML.NET learning pipelinesUnderstanding model training conceptsUnderstanding missing values and key typesUnderstanding features and labelsMaking product recommendationsProblem analysisData gathering and processingCreating the NorthwindML website projectCreating the data and view modelsImplementing the controllerTraining the recommendation modelsImplementing a shopping cart with recommendationsTesting the product recommendations websitePracticing and exploringExercise 19.1 – Test your knowledgeExercise 19.2 – Practice with samplesExercise 19.3 – Explore topicsSummary
Building Web User Interfaces Using Blazor
Understanding BlazorUnderstanding Blazor hosting modelsUnderstanding Blazor componentsWhat is the deal with Blazor and Razor?Comparing Blazor project templatesReviewing the Blazor Server project templateUnderstanding CSS isolationRunning the Blazor Server project templateReviewing the Blazor WebAssembly project templateBuilding components using Blazor ServerDefining and testing a simple componentGetting entities into a componentAbstracting a service for a Blazor componentUsing Blazor formsDefining forms using the EditForm componentNavigating Blazor routesBuilding and using a customer form componentBuilding components using Blazor WebAssemblyConfiguring the server for Blazor WebAssemblyConfiguring the client for Blazor WebAssemblyExploring Progressive Web App supportPracticing and exploringExercise 20.1 – Test your knowledgeExercise 20.2 – Practice creating a componentExercise 20.3 – Explore topicsSummary
Building Cross-Platform Mobile Apps
Understanding XAMLSimplifying code using XAMLChoosing common controlsUnderstanding markup extensionsUnderstanding Xamarin and Xamarin.FormsHow Xamarin.Forms extends XamarinDevelopment tools for mobile first, cloud firstMobile platform market shareUnderstanding additional functionalityUnderstanding the INotificationPropertyChanged interfaceUnderstanding dependency servicesUnderstanding Xamarin.Forms user interface componentsUnderstanding the ContentPage viewUnderstanding the Entry and Editor controlsUnderstanding the ListView controlBuilding mobile apps using Xamarin.FormsAdding Android SDKsCreating a Xamarin.Forms solutionCreating an entity model with two-way data bindingCreating a component for dialing phone numbersCreating views for the customers list and customer detailsImplementing the customer list viewImplementing the customer detail viewSetting the main page for the mobile appTesting the mobile appConsuming a web service from a mobile appConfiguring the web service to allow insecure requestsConfiguring the iOS app to allow insecure connectionsConfiguring the Android app to allow insecure connectionsAdding NuGet packages for consuming a web serviceGetting customers from the web servicePracticing and exploringExercise 21.1 – Test your knowledgeExercise 21.2 – Explore topicsSummaryEpilogue
Index

Content preview from C# 9 and .NET 5 – Modern Cross-Platform Development - Fifth Edition

16 Building Websites Using the Model-View-Controller Pattern

This chapter is about building websites with a modern HTTP architecture on the server side using Microsoft ASP.NET Core MVC, including the startup configuration, authentication, authorization, routes, request and response pipeline, models, views, and controllers that make up an ASP.NET Core MVC project.

This chapter will cover the following topics:

Setting up an ASP.NET Core MVC website
Exploring an ASP.NET Core MVC website
Customizing an ASP.NET Core MVC website
Using other project templates

Setting up an ASP.NET Core MVC website

ASP.NET Core Razor Pages are great for simple websites. For more complex websites, it would be better to have a more formal structure to manage that complexity. ...

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# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition

Publisher Resources

ISBN: 9781800568105

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 9 and .NET 5 – Modern Cross-Platform Development - Fifth Edition

by Mark J. Price

16

Building Websites Using the Model-View-Controller Pattern

Setting up an ASP.NET Core MVC website

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.