book

ASP.NET Core: Cloud-ready, Enterprise Web Application Development

Name: ASP.NET Core: Cloud-ready, Enterprise Web Application Development
ISBN: 9781788296526

by Mugilan T. S. Ragupathi, Valerio De Sanctis, James Singleton

June 2017

Intermediate to advanced

1083 pages

22h 12m

English

Packt Publishing

Read now

Unlock full access

ASP.NET Core: Cloud-ready, Enterprise Web Application Development
ASP.NET Core: Cloud-ready, Enterprise Web Application Development
ASP.NET Core: Cloud-ready, Enterprise Web Application Development
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example code

Errata
Piracy
Questions
1. Module 1
1. Introduction to ASP.NET Core
How web applications workSo what is an HTTP protocol?Request-response patternStateless nature of HTTP
Client-side and server-side
HTTP methods
GET methodPOST method
What is ASP.NET?
ASP.NET Web FormsASP.NET Web PagesASP.NET MVC
Features of ASP.NET MVC
Convention over configurationSeparation of concernsControl over the generated HTMLBetter support for unit testing
ASP.NET 5
Features of ASP.NET 5
Summary
2. Setting Up the Environment
Purpose of IDE
Visual Studio offerings
System requirementsVisual Studio Community 2015Visual Studio ProfessionalVisual Studio EnterpriseVisual Studio Test Professional
Installing Visual Studio Community
Installing ASP.NET 5
Project structure in ASP.NET 5 application
File-based projectSupport for full .NET and .NET coreThe Project.json packageControllersModelsViewsMigrationsThe wwwroot folderOther files
Summary
3. Controllers
Role of the Controller in ASP.NET MVC applications
Introduction to routing
Creating ASP.NET 5 application
Installing the ASP.NET Core NuGet package in your application
Our first Controller
IActionResult
Adding Views
Adding Models
Passing data from Controller to View
Filters
Authorization filtersResource filtersAction filtersException filtersResult filters
Summary
4. Views
The View engine and the Razor View engineRazor View engineProgramming in Razor View engineVariables in Razor ViewThe for loopThe while loopThe foreach loopThe if condition
Layout
Creating _ViewStart.cshtmlCreating _Layout.cshtmlAdding a page-specific View
Generating HTML
HTML Helpers
Partial View
Calling the Partial View
View components
Creating a View component
Tag Helpers
Creating custom Tag Helpers
Summary
5. Models
ModelsModels specific to a View componentNote on ViewModelsData flow with respect to a Model
Model binding
The Entity Framework
The Entity Framework is independent of ASP.NET MVCCreating console applications with the Entity FrameworkInstalling the Entity Framework 7 NuGet packageUsing the NuGet Package ManagerUsing the Package Manager ConsoleInstalling Entity Framework commandsCreating Model classesCreating the DbContext classCreate a migrationHow the SaveChanges method worksUpdating the recordDeleting the record
Using the Entity Framework in ASP.NET MVC applications
Database migration
Summary
6. Validation
Client-side and server-side validation
Server-side validation
Updating View models with the Data Annotation attributeUpdating the View model to display the validation error messageUpdating the controller action method to verify the model state
Client-side validation
Implementation
Summary
7. Routing
Convention-based routingExample 1Example 2Example 3Example 4
Attribute-based routing
Route attribute at the controller level
Passing routing values in HTTP action verbs in the Controller
Route Constraints
Summary
8. Beautifying ASP.NET MVC Applications with Bootstrap
Knowing HTML and CSS
Bootstrap
Bootstrap Grid systemFormsInline formsHorizontal formsTable CSS classesStriped tablesHover tablesBordered tablesContextual classes in tableButtonsButton sizesContextual colors
Using Bootstrap in your ASP.NET MVC application
Installing with Bower
HTML doctype
Summary
9. Deployment of ASP.NET Core Application
The project.json fileThe dependencies nodeThe frameworks node
Microsoft Azure
Signing up to Microsoft AzurePrerequisites to Azure deployment
Deploying the ASP.NET Core application in Azure
Deploying the ASP.NET Core web application in the Linux environment
Creating a Linux machineInstalling the PuTTY clientInstalling of .NET Core in a Linux machine
Creating a new ASP.NET 5 project
Configuring the Nginx server
Summary
10. Building HTTP-based Web Services Using ASP.NET Web API
HTTP basicsHTTP verbsGET methodPUT methodPOST methodDELETE methodFiddler tool
Dependency Injection
Delete methodThe Web API method for deleting a resourceWeb Repository layer code for deleting the employee data
Summary
11. Improving Performance of an ASP.NET Core Application
The UI layer
Reducing the number of HTTP requests
Using GZip compressionUsing the Content Delivery Network (CDN)Using JavaScript wherever possibleUsing CSS stylesheets
Minification of JavaScript and CSS files and their combination
The caching process
Client-side cachingResponse caching
The web/application layer
No business logic in ViewsUsing asynchronous loggingThe DB layerUnderstanding the queries generated by the ORMUsing classic ADO.NET if you really want toReturn only the required dataFine tuning the indicesUsing the correct column type and size for your database columnsAvoiding correlated subqueries
Generic performance improvement tips
Avoiding the Response.Redirect methodUsing string builder
Summary
12. ASP.NET Core Identity
Authentication
Authorization
Adding the relevant dependencies to the project.json file
Adding ApplicationUser and ApplicationDbContext classes
Configuring the application to use Identity
Creating ViewModels
Creating Controllers and associated action methods
Creating Views
E-mail and SMS services
Securing an action method in a Controller
Summary
2. Module 2
1. Getting Ready
Two players one goalWhat's new in Angular 2?The ASP.NET Core revolution
The field of choice – single-page application
Common features of a competitive SPAProduct owner expectations
A sample single-page application project
The visionCore requirements
Preparing the workspace
Setting up the projectPackage and resource managersInstalling the packagesNuGet and ASP.NETProject.jsonStartup.csTesting the HTTP request pipelineNewtonsoft.JsonJavaScript, TypeScript, or Dart?Adding the tsconfig.json fileIntroducing NPMWorking with GulpDependent tasksUsing Grunt instead of GulpAdding Angular 2Using NPMAdding TypingsUsing a CDNUpgrading the typescriptServices.js fileSetting up the client codeThe component fileA word on components and modulesThe module fileThe bootstrap fileThe module loader configuration fileWhy use a dynamic module loader?The index.html file
First run
Caching issuesThe new ASP.NET Core configuration pattern
A faster alternative using scaffolding tools
The reasons to say no (not yet)A quick scaffolding sample
References
Suggested topics
Summary
2. ASP.NET Controllers and Server-Side Routes
Data flowThe role of the ViewModel
Our first Controller
The ItemViewModelThe ItemsController
Understanding routes
Defining routingRouting through the agesHandling routes in ASP.NET CoreConvention-based routingAttribute-based routingThree choices to route them allAdding more routesThe dummy data provider
Dealing with single items
Suggested topics
Summary
3. Angular 2 Components and Client-Side Routing
Master-detail bindingThe Item classThe ItemService classThe ItemListComponent classA quick implementation testThe ItemDetailComponent classAdding the @angular/forms libraryUpdating the root moduleConnecting the dotsTesting it up
Adding additional lists
Multiple component instances
Two-way data binding
Disabling two-way data binding
Client-side routing
Adding the @angular/router libraryPathLocationStrategy versus HashLocationStrategyRefactoring our appAdding the AppRouting schemeAdding the HomeComponentAdding new componentsAboutComponentLoginComponentPageNotFoundComponentUpdating the root moduleRevising the master-detail strategyAdding the ItemDetail routeChanging the ItemListComponentUpdating the ItemDetailComponent
Full routing test
Handling rewrites in ASP.NET CoreShowing the issueUnderstanding the causesImplementing the fixValidating the outcome
Suggested topics
Summary
4. The Data Model
Getting readyInstalling the EntityFramework CoreData modeling approachesThe model-first approachProsConsThe database-first approachProsConsThe code-first approachProsConsMaking a choice
Creating entities
ItemsCommentsUsers
Defining relationships
Setting up DbContext
Database initialization strategies
Choosing the database engine
Updating appsettings.json
Creating the database
Updating Startup.csConfiguring the EF toolsAdding the initial migrationUnderstanding migrations
Implementing a data seed strategy
Creating a DbSeeder classPrivate membersConstructorPublic methodsSeed methodsUtility methodsAdding the DbSeeder to Startup.csHandling exceptions
Seeding the database
Updating the ItemsControllerInstalling TinyMapperImplementing the mapping
Testing the data provider
Suggested topics
Summary
5. Persisting Changes
Add, update, and delete itemsUpdating the Web APIAdapting the clientImproving the ItemServiceUpdating the GUIAdd newUpdate and DeleteTesting it outAdding a new testUpdate testDelete test
Splitting the ItemDetail component
Adding the ItemDetailView componentRefactoring ItemDetail into ItemDetailEditUpdating the Root moduleUpdating the RoutesTracking the outdated referencesImplementing the tab menuTemplateClass codeStylesTesting it out
Suggested topics
Summary
6. Applying Styles
How bad is it, doc?
Introducing LESS
Style sheet languagesCSSCSS code sampleWhat is LESS and why to use itVariablesImport directivesNested selectorsMixinsExtend pseudo-classLESS docs and supportSystematically Awesome Style Sheets, Stylus, and other alternatives
Configuring LESS
Adding the LESS fileUpdating Gulp scriptLinking the stylesheetTesting it up
DIY versus framework-based styling
Do it yourself approachProsConsFramework-based approachProsConsConclusions
Adding Bootstrap
Choosing a native directives moduleInstalling ng2-bootstrap
Applying styles
Main navigation barDetecting the active routeWelcome ViewItem Detail ViewDisplay modeEdit modeConclusions
Suggested topics
Summary
7. Authentication and Authorization
Do we really need these?
Authentication
Third-party authentication
Authorization
Third-party authorization
Proprietary or third-party?
Choosing an authentication mode
Installing AspNetCore.Identity
Adding the packageUpdating the project classesApplicationDbContext.csApplicationUser.csStartup.csDbSeeder.cs
Updating the database
Authentication methods
SessionsTokensSignaturesTwo-factorConclusions
Implementing JSON web token authentication
JWT providerPrivate membersStatic membersConstructorPublic methodsPrivate methodsExtension methodsFull source codeAdding the middleware to the pipelineAngular 2 login formAdding stylesUpdating the root module fileUI and validation testAuthService componentUpdating the AppModuleUpdating the LoginComponentLogin testAuthHttp wrapperAdding authorization rulesAdapting the clientTesting the clientProtecting the serverRetrieving the user IDAuthorization test
Suggested topics
Summary
8. Third-Party Authentication and External Providers
Introducing OpenID connect servers
Installing OpenIddict
Adding MyGet to the package sourcesInstalling the OpenIddict packageUpdating ApplicationUser and ApplicationDbContextAdding a new migrationUpdating the DbSeederMoving literal values to appsettings.jsonConfiguring the Startup classUpdating the Web.Config rewrite rulesSeeding the database
External authentication providers
OAuth2 authorization flowFacebookCreating a Facebook AppStoring the keys in App settingsAdding the Facebook middlewareAdding the AccountsControllerBaseControllerAccountsControllerNamespacesClass declarationConstructorExternalLoginExternalLoginCallBackLogoutUpdating the ItemsControllerConfiguring the clientUpdating the LoginComponentUpdating the AuthServiceUpdating the AppComponentUnderstanding zonesTesting it outGoogleTwitterElevated permissions requestTroubleshooting
Conclusions
Suggested topics
Summary
9. User Registration and Account Edit
User RegistrationUserViewModelAccountsControllerGetAddE-mail confirmationUpdateDeleteUser classAuthServiceUserEditComponentConnecting the dotsUpdating the root moduleImplementing the routeAdding the Register linkDefining the stylesUpdating the menuTesting it out
Edit Account
Two routes, one componentAdapting the UserEditComponentUpdating the navigation menuAdding stylesFinal test
Conclusions
Suggested topics
Summary
10. Finalization and Deployment
Switching to SQL Server
Installing SQL Server 2016 Express
Installing SQL Server Management Studio
Configuring the databaseChanging the authentication modeAdding the OpenGameList databaseAdding the OpenGameList loginMapping the login to the databaseAdding a SQL Server connection stringCreating an application settings file for productionUpdating AppSettingsUpdating external providersConfiguring the publishOptionsChecking the Startup classUpdating the launchSettings.json
Publishing our native web application
Creating a Publish profileFile System Publish profileFTP Publish profile
Configuring IIS
Installing the ASP.NET Core module for IISAdding the websiteConfiguring the Application Pool
Firing up the engine
TroubleshootingThe Kestrel test
Suggested topics
Summary
3. Module 3
1. Why Performance Is a Feature
Performance as a feature
Common classes of performance problems
Language considerationsTypes of performance problemsWhen performance mattersSlower is sometimes betterWhy issues are missedMeasuringThe benefits of planning ahead
Understanding hardware
Storage access speedsScaling approach changes
Tools and costs
ToolsLooking at some alternative tools
The new .NET
Summary
2. Measuring Performance Bottlenecks
ToolsSQLSQL Server ProfilerExecuting a simple queryMiniProfilerApplication profilingGlimpseUsing GlimpseIDEMonitoring HTTPBrowsersChromeFirefoxFiddlerNetworkMicrosoft Message AnalyzerWiresharkRoll your own
Science
RepeatabilityOnly change one thing
Summary
3. Fixing Common Performance Problems
Latency
Asynchronous operations
Simple asynchronous toolsBackground queuingHangfire
Select N+1 problems
Efficient pagingStatic site generators
Pragmatic solutions with hardware
A desktop exampleWeb applications
Oversized images
Image resolutionImage format
Summary
4. Addressing Network Performance
Internet protocolsTCP/IPSlow-startHTTPHeadersHTTP methodsStatus codesEncryptionKey exchangeDelay diagnosticsPerformance tweaksHTTP/2WebSockets
Compression
Lossless compression algorithmsBundling and minificationBundlingMinificationChanges in ASP.NET CoreImage optimizationPNGJPEGOther image formatsResizing images
Caching
BrowserServerProxy servers between you and your usersCDNs
Summary
5. Optimizing I/O Performance
Input/outputCategories of I/ODisksVirtual file systemsDatabasesAPIsNetwork diagnostics toolsPingTracertNslookupBuild your own
Solutions
Batching API requestsEfficient DB operationsDatabase tuningReportingAggregatesSamplingInserting dataGUIDsAdvanced DB topics
Simulation and testing
Summary
6. Understanding Code Execution and Asynchronous Operations
Getting started with the core projects.NET CoreASP.NET CoreKestrel
Data structures
ListsDictionariesCollection benchmarksBloom filters
Hashing and checksums
Hashing benchmarks
Serialization
SIMD CPU instructions
Parallel programming
Task Parallel LibraryParallel LINQParallel benchmarkingParallel programming limitations
Practices to avoid
ReflectionRegular expressionsString concatenation in tight loopsDynamic typingSynchronous operationsExceptions
Summary
7. Learning Caching and Message Queuing
Why caching is hardWeb cachingCaching backgroundHTTP headersCache bustingService workersService worker exampleWeb and proxy serversIISVarnishWorking with a content delivery networkWhen not to cacheApplication layer cachingRedisDatabase result set caching
Message queuing
Coffee shop analogyMessage queuing stylesCommon messaging patternsUnicastPub/subRabbitMQQueuing frameworks and libraries
Summary
8. The Downsides of Performance-Enhancing Tools
Managing complexityUnderstanding complexityComplexity reductionFrameworksArchitectureMonolith versus microservicesArchitecture comparisonRefactoring
A culture of high performance
A blameless cultureIntellectual dishonestySlow down to go fasterFrom the ground upShared values
The price of performance
Distributed debugging
LoggingError loggingApplication InsightsIntegrated loggingCentralized loggingStatistics
Managing stale caches
Summary
9. Monitoring Performance Regressions
Profiling and measurement
Testing
Automated testingContinuous integrationSlow testingFixing performance regressionsLoad testingRealismRealistic environmentsRealistic workloadsFeature switchingExperimenting for scienceA/B testingUser interface testingWeb UI testing toolsAutomating UI performance tests
Staying alert
DevOps
DevOps toolingProvisioningMonitoring
Hosting
Summary
10. The Way Ahead
Reviewing what we learned
Further reading
Going nativeProcessor architectureHardware is hardMachine learningBig data and MapReduceOrleansCustom transportsAdvanced hashing
Library and framework support
The future
Summary
Bibliography

Content preview from ASP.NET Core: Cloud-ready, Enterprise Web Application Development

Seeding the database

We're now ready to seed our database. Since we hooked the DbSeeder.SeedAsync to the Startup class, it'll be as easy as hitting F5 and letting the application work its magic. If we have done everything correctly, our database should be populated in no time. In order to check that, we can:

Open the Server Object Explorer panel.
Expand the nodes up to our OpenGameList database.
Right-click on the dbo.Items table and select View Data.

Upon doing that, we should see something like the following:

Updating the ItemsController

Last but not least, we need to modify our ItemsController to use the ApplicationDbContext to retrieve data, getting ...

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

Hands-On RESTful Web Services with ASP.NET Core 3

Publisher Resources

ISBN: 9781788296526

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

ASP.NET Core: Cloud-ready, Enterprise Web Application Development

by Mugilan T. S. Ragupathi, Valerio De Sanctis, James Singleton

Seeding the database

Updating the ItemsController

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.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

Hands-On RESTful Web Services with ASP.NET Core 3

ASP.NET Core and Vue.js

Customizing ASP.NET Core 5.0

Customizing ASP.NET Core 6.0 - Second Edition

Publisher Resources