ASP.NET Core MVC 2.0 Cookbook

Book Image

ASP.NET Core MVC 2.0 Cookbook

By : Jason De Oliveira, Engin Polat, Stephane Belkheraz

Book Image

ASP.NET Core MVC 2.0 Cookbook

By: Jason De Oliveira, Engin Polat, Stephane Belkheraz

Overview of this book

The ASP.NET Core 2.0 Framework has been designed to meet all the needs of today’s web developers. It provides better control, support for test-driven development, and cleaner code. Moreover, it’s lightweight and allows you to run apps on Windows, OSX and Linux, making it the most popular web framework with modern day developers. This book takes a unique approach to web development, using real-world examples to guide you through problems with ASP.NET Core 2.0 web applications. It covers Visual Studio 2017- and ASP.NET Core 2.0-specifc changes and provides general MVC development recipes. It explores setting up .NET Core, Visual Studio 2017, Node.js modules, and NuGet. Next, it shows you how to work with Inversion of Control data pattern and caching. We explore everyday ASP.NET Core MVC 2.0 patterns and go beyond it into troubleshooting. Finally, we lead you through migrating, hosting, and deploying your code. By the end of the book, you’ll not only have explored every aspect of ASP.NET Core MVC 2.0, you’ll also have a reference you can keep coming back to whenever you need to get the job done.

Title Page

Copyright and Credits

Copyright and Credits

Packt Upsell

Contributors

Preface

Free Chapter

Cross-Platform with .NET Core

Cross-Platform with .NET Core

What is ASP.NET Core 2.0?

What's new in ASP.NET and CLR?

Installing or updating .NET Core

Managing NuGet packages in ASP.NET Core applications

Creating an ASP.NET Core MVC application on Linux

Creating an ASP.NET Core MVC application on Linux with Docker

Creating an ASP.NET Core MVC application on macOS

Creating and running an ASP.NET Core MVC application on Azure

Visual Studio 2017, C# 6, IDEs, and Roslyn

Visual Studio 2017, C# 6, IDEs, and Roslyn

Working with Visual Studio 2017

Working with Visual Studio Code

Installing and using OmniSharp on macOS

Installing and using OmniSharp on Linux

Working with Roslyn

Using C# 6 new features

Working with npm, Frontend Package Managers, and Task Runners

Working with npm, Frontend Package Managers, and Task Runners

Using and creating npm modules

Managing frontend dependencies with Bower

Compiling LESS files to CSS files with Grunt

Bundling and minifying JavaScript files with Gulp

Using Yeoman code-generated templates

Reusing Code with NuGet

Reusing Code with NuGet

Managing NuGet packages

Creating a NuGet package with the NuGet package class library

Creating a local NuGet repository and consuming packages from it

Creating a NuGet package with NuGet Package Explorer

Sharing NuGet packages with the community

Creating an Azure NuGet repository

SOLID Principles, Inversion of Control, and Dependency Injection

SOLID Principles, Inversion of Control, and Dependency Injection

Implementing DI with Native IOC in ASP.NET Core

Using the life cycles available in ASP.NET Core

Implementing DI with Autofac

Implementing DI with StructureMap

Implementing DI with DryIoc

Data Access - EF7 with Repository, SQL Server, and Stored Procedures

Data Access - EF7 with Repository, SQL Server, and Stored Procedures

Configuring the IOC life cycle for the repository pattern

Using EF with an existing database

Using an InMemory provider

Managing a long request batch

Using a stored procedure with EF

Writing an EF provider

Accessing data with Micro ORMs, NoSQL, and Azure

Accessing data with Micro ORMs, NoSQL, and Azure

Accessing data with Dapper

Accessing data with OrmLite

Accessing data with MongoDb

Accessing data with Windows Azure storage tables

Accessing data with Azure storage Blobs

Accessing data with SQL Azure

Cache and Session - Distributed, Server, and Client

Cache and Session - Distributed, Server, and Client

Using .NET Cache with MemoryCache

Caching HTML with Cache TagHelpers

Using ResponseCache attribute

Using Redis as Cache on-Premises

Using Redis as a cache on Azure

Caching with HTML5 cache manifest

Caching with HTML5 localStorage and sessionStorage

Routing

Before ASP.NET Core

Since ASP.NET Core

MVC and Web API routing

The route order

Routing with ASP.NET Core

Creating a route using convention routing

Creating a route using attribute routing

Creating a custom route using IRouter

Creating a route constraint

Creating a domain route

Creating SEO-friendly routes

ASP.NET Core MVC

ASP.NET Core MVC

Injecting dependencies and configuring IoC for a controller

Using ActionResults

Creating and working with areas

Creating and using POCO controllers

Creating and using controllers with MediatR

Managing exceptions

Web API

Using ActionResult

Configuring content negotiation

Configuring cross-domain origin requests

Testing Web API

Managing exceptions

Filters

Managing authentication and authorization with policies, requirements, and filters

Managing dependency injection with filters

Creating and using an action filter

Creating and using a result filter

Creating and using a resource filter

Creating and using an exception filter

Using a filter globally versus using a middleware

Views, Models, and ViewModels

Views, Models, and ViewModels

Creating and using a ViewModel with AutoMapper

Understanding and using ModelBinding

Creating our own model binder

Understanding and using a value provider

Configuring and using validation

Razor and Views

Razor and Views

Managing namespaces in views with ViewImports

Creating a strongly typed Partial view

Configuring view and area locations

Using dependency injection in views

Creating HTMLHelpers

TagHelpers and ViewComponents

TagHelpers and ViewComponents

Using Environment, Script, and Link TagHelpers

Using Form TagHelpers

Creating TagHelpers programmatically

Creating a reusable view component

Creating a view component/controller class

OWIN and Middleware

OWIN and Middleware

Understanding OWIN, Katana, and the new ASP.NET Core HTTP pipeline

Using inline middleware code as anonymous methods - Use, Run, Map, and MapWhen

Creating a reusable middleware component

Migrating an HTTP handler to middleware

Migrating HTTP modules to middleware

Security

Authentication in ASP.NET, using cookie authentication

Authentication using authorization servers

Managing identity

Securing data with Hashing

Securing data with Encryption

Frontend Development

Frontend Development

Using Bootstrap

Writing clean JavaScript

Writing and executing unit tests in JavaScript

Debugging JavaScript code in browsers

Deployment and Hosting

Deployment and Hosting

Deployment options

Hosting an ASP.NET Core web app on IIS

Hosting an ASP.NET Core web application on Kestrel

Hosting an ASP.NET Core web app on Azure

Hosting an ASP.NET Core web app in Docker containers

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Using the life cycles available in ASP.NET Core

In this recipe, we will see an example with all the life cycles available and look at what it involves.

Getting ready

We will see what the differences between all these life cycles are.

How to do it...

First, let's create an interface named IOperation with a getter on a Guid type, and four interfaces that represent a task for each life cycle available:

We will now implement these interfaces in an Operation class:

In the ConfigurationServices method of the Startup.cs class, we manage the lifetime for each interface:

Now, let's create an OperationService class that we will use in an MVC controller and execute in several HTTP requests:

Now, we create the MVC controller and add an Index action to show the value of Guid for each implementation:

Finally, we create the view that shows the result:

How it works...

We can see the different values of Guids.

Request 1 :

Request 2:

The conclusion is the following:

Transient: Objects are always different; a new instance...