Introducing ASP.NET Core: The New ASP.NET in Town!

The new version of ASP.NET is called ASP.NET Core (a.k.a ASP.NET 5) and it has the most significant architectural redesign of ASP.NET. This article will highlight the new features and concepts in the new ASP.NET.

What is ASP.NET Core?

ASP.NET Core 1.0 is a new open-source and cross-platform framework for building modern cloud-based web apps It has been built from the ground up to provide an optimized development framework for web apps that are either deployed to the cloud or in your local servers. Adding to that, it was redesigned to make ASP.NET leaner, modular (so you can just add features that your application requires), cross-platform (so you can easily develop and run your app on Windows, Mac or Linux that is pretty awesome) and cloud optimized (so you can deploy and debug apps over the cloud). (Read more here)

Previous Versions

What does that mean for us that work on previous versions of ASP.NET?

If you are using the past versions of ASP.NET or if you are coming from a WebForms development background then you might find ASP.NET Core completely new. It's like the feeling of moving from classic ASP to the ASP.NET world or perhaps the feeling of my dog looking into my screen monitor while I am programming:

Now let's get Cracking!

Here are the lists of the core significant changes in ASP.NET Core 1.0.

Cross-Platform Runtime

For the first time in the history of ASP.NET, you can run ASP.NET Core applications on OSX and Linux. Yes, ASP.NET Core apps can run on Windows, OSX and Linux. This fact opens up ASP.NET to an entirely new audience of developers and designers. ASP.NET Core comes with two flavors of runtime environments when running your app. This means that you can choose from two runtime environments to provide you greater flexibility when deploying your app as in the following.

ASP.NET Core 1.0 is a refactored version of ASP.NET and runs on top of .NET Core. It was redesigned to be modular that allows developers to plug in components that are only required for your project, most features will be available as plugins via NuGet. One of the good things about being modular is the ability to upgrade features without impacting the other features that your application uses. Adding to that, .NET Core is a cross-platform runtime that enables you to deploy apps in OSX or Linux operating systems. It also is a cloud-optimized runtime that enables you to deploy and debug apps in the cloud. The .NET Core can be bin-deployed along with your app, allowing you to run ASP.NET Core apps on the same server that targets multiple versions of the .NET Core.

You can also create an ASP.NET Core app for Windows only that runs on .NET full framework.

ASP.NET 4.6 is the latest release of .NET Full Framework which enables you to utilize all .NET components that are available and supports backward compatibility. If you plan on migrating apps to run on .NET Core then you may need to do some modifications since the .NET Core is currently limited compared to the full .NET Framework.

To be clear, ASP.NET 4.6 is the more mature platform. It's battle-tested and released and available today. ASP.NET Core 1.0 is a 1.0 release that includes Web API and MVC but doesn't yet have SignalR or Web Pages. It doesn't yet support VB or F#.

ASP.NET Core is Not All About using Visual Studio

ASP.NET Core is not all about using Visual Studio. Enabling ASP.NET Core to run on Windows, OSX and Linux changes everything. For the first time, developers and designers can start building apps with ASP.NET Core using their favorite development environments such as Sublime Text and WebStorm when working with ASP.NET. That's pretty awesome!

New Project Solution Structure

If you create an empty ASP.NET Core project in Visual Studio 2015 then you will be surprised seeing this (unless if you have not done creating any project using a previous version of ASP.NET):

Surprised? Yes, the new project structure is totally different. The project template is completely new and now includes the following new files:

• global.json: this is where you put solution-level settings and allows you to do project-to-project references.
• Program.cs: this file contains the Main method of an ASP.NET Core RC2 app, which is responsible for configuring and running the app.
• src folder: contains all the projects that contain source code that make up your application.
• wwwroot: is a folder in which all your static files will be placed. These are the assets that your ASP.NET app will serve directly to the client, including HTML, CSS, Images and JavaScript files.
• project.json: contains project settings. In ASP.NET Core you manage dependencies by adding Nuget packages using the NuGet Package Manager (NPM) or the new project.json file. This file enables you to easily manage dependencies in your application because you can edit it using any text editors. It would be easier to work with this file because in Visual Studio 2015, Intellisense will assist you in finding the available NuGet packages that you can add as dependencies. Here's who the project.json looks like:

• startup.cs – this is where you put your startup and configuration code for your ASP.NET Core App. To give you a quick view, here's what the startup class would look like:

The ConfigureServices method defines the services used by your application and the Configure method is used to define what middleware makes up your request pipeline.

• References: it contains the .NETCoreApp Version 1 runtime references.

WebForms

Yes, it's a sad fact that WebForms is not part of ASP.NET 5. You can still continue to build Web Forms apps in Visual Studio 2015 by targeting the framework .NET 4.6. However, Web Forms apps cannot take advantage of the new features of ASP.NET 5.

I've spent years building WebForms applications from small to large enterprise app. I love Web Forms, in fact I still continue supporting the community that uses WebForms at various forums such as http://forums.asp.net. However, it's time to move forward, learn the new stuff and it's finally time for you to learn ASP.NET MVC. Like so many things in the past, times are changing and you either adapt or you become extinct.

Aside from WebForms, the .NET Core in general will not include Windows Forms, WCF, WPF, Silverlight and so on.

VB.NET and F#

At the  moment, with the current realase  of ASP.NET Core 1.0 RC2, VB.NET and F# isn't supported.

ASP.NET Core the Unified Framework

The newASP.NET will see MVC, Web API and probably Web Pages combined into one framework called ASP.NET Core. Though at the current release, Web Pages and SignalR are not yet included.

In previous versions of ASP.NET MVC, MVC controllers were different from Web API controllers. An MVC controller used the System.Web.MVC.Controller base class and a Web API controller used the System.Web.Http.ApiController base class. In MVC Core, there is only one Controller base class for both MVC and Web API controllers that is the Microsoft.AspNetCore.Mvc.Controller class.

The merge is possibly true for HTML helpers in both MVC and Web Pages that are implemented differently before. The Web Pages programming model isn't available yet for the current release so we can never really tell what will be the other features that they're going to merge, but we can assume that the traditional MVC model-binding will be available to it.

View Components

In previous versions of ASP.NET MVC, the Html.Action() helper is typically used to invoke a sub-controller. ASP.NET MVC Core introduced the new View Component to replace widgets that use Html.Action().

View Components supports fully async allowing you to make view component asynchronous. Here's a sample view component that returns person profiles based on some status:

Hide    Shrink     Copy Code

using Microsoft.AspNetCore.Mvc;
using MVC6Demo.Models;
using System.Threading.Tasks;
using System.Collections.Generic;  

namespace MVC6Demo.ViewComponents
{
    public class PersonListViewComponent : ViewComponent
    {
        public async Task<iviewcomponentresult> InvokeAsync(string status) {
            string viewToUse = "Default";
            bool isFiltered = false;  

            PersonModel model = new PersonModel();  

            if (status.ToLower().Equals("registered")) {
                viewToUse = "Registered"; isFiltered = true;
            }  

            var p = await GetPersonAsync(status, isFiltered);
            return View(viewToUse,p);
        }  

        private Task<ienumerable<person>> GetPersonAsync(string status, bool isFiltered) {
            return Task.FromResult(GetPerson(status,isFiltered));
        }
        private IEnumerable<person> GetPerson(string status, bool isFiltered) {
            PersonModel model = new PersonModel();  

            if (isFiltered)
                return model.GetPersonsByStatus(status);
            else
                return model.GetAll;  

        }
    }
}  </person>

And here's the view for the View Component:

Hide    Copy Code

<h3>Person List</h3>
<ul>
    @foreach (var p in Model) {
        <li>@string.Format("{0} {1}",p.FirstName,p.LastName)</li>
    }
</ul> 

And here's how you call the View Components in the main view:

Hide    Copy Code

<div>
    @await Component.InvokeAsync("PersonList", new { type = "Registered" })
</div>  

New Directives: @inject, @using, @inherits

ASP.NET MVC Core has few new directives that we can use in our application. Here we'll have a look at how to use @inject. The @inject directive allows you to inject some method calls from a class directly into your view. Here's a simple class that exposes some async methods:

Hide    Copy Code

using System.Threading.Tasks;
using System.Linq;  

namespace MVC6Demo.Models
{
    public class Stats
    {
        private PersonModel _persons = new PersonModel();  

        public async Task<int> GetPersonCount() {
            return await Task.FromResult(_persons.GetAll.Count());
        }  

        public async Task<int> GetRegisteredPersonCount() {
            return await Task.FromResult(
                      _persons.GetAll.Where(o => o.Status.ToLower().Equals("registered")).Count());
        }  

        public async Task<int> GetUnRegisteredPersonCount() {
            return await Task.FromResult(
                     _persons.GetAll.Where(o => o.Status.ToLower().Equals("")).Count());
        }
    }
} 

Now we can call those methods in the view using @inject like:

Hide    Copy Code

@inject MVC6Demo.Models.Stats Stats  

@{
    ViewBag.Title = "Stats";
}  

<div>
    <p>Registered: @await Stats.GetRegisteredPersonCount()</p>

That's pretty cool! Isn't it?

Check out my article about ASP.NET MVC Core for detailed example of the new features here: Getting Started with ASP.NET MVC Core

Tag Helpers

Another cool thing in ASP.NET MVC Core is the tag helpers. Tag helpers are optional replacements for the previous HTML Helpers.

So instead of doing this:

Hide    Copy Code

@using (Html.BeginForm("Login", "Account", FormMethod.Post,
        new { @class = "form-horizontal", role = "form" }))
            {
                @Html.AntiForgeryToken()
                <h4>Use a local account to log in.</h4>
                <hr />
                @Html.ValidationSummary(true, "", new { @class = "text-danger" })
                <div class="form-group">
                    @Html.LabelFor(m => m.UserName, new { @class = "col-md-2 control-label" })
                    <div class="col-md-10">
                        @Html.TextBoxFor(m => m.UserName, new { @class = "form-control" })
                        @Html.ValidationMessageFor(m => m.UserName, "", new { @class = "text-danger" })
                    </div>
                </div>
}

You can instead do this:

Hide    Copy Code

<form asp-controller="Account" asp-action="Login" method="post" class="form-horizontal" role="form">
    <h4>Use a local account to log in.</h4>
    <hr />
    <div asp-validation-summary="ValidationSummary.ModelOnly" class="text-danger"></div>
    <div class="form-group">
        <label asp-for="UserName" class="col-md-2 control-label"></label>
        <div class="col-md-10">
            <input asp-for="UserName" class="col-md-2 control-label" />
            <span asp-validation-for="UserName" class="text-danger"></span>
        </div>
    </div>
</form>

ASP.NET Core is not all about IIS

14 years ago, there was basically one web server for ASP.NET platforms and that was IIS. A few years later the Visual Studio Development Web Server (a.k.a “Cassini”) came along as a dev-only server. All of them ultimately used System.Web as the hosting layer between the application and the web server. The System.Web host is tightly coupled to IIS and is very difficult to run on another host.

Later on OWIN came around as an interface between applications and web servers. Microsoft wrote Katana as one OWIN implementation that could host ASP.NET Web API, SignalR and other third-party frameworks on top of several servers, including IIS and IIS Express, Katana's self-host server and custom hosts.

ASP.NET Core is host-agnostic in the same manner as Katana and OWIN and any ASP.NET Core application can be hosted on IIS, IIS Express or self-hosted in your own process. Adding to that ASP.NET Core will include a web server for iOS and Linux based operating systems called Kestrel built on libuv.

New HTTP Request Pipeline

ASP.NET Core introduces a new HTTP request pipeline that is modular so you can add only the components that you need. The pipeline is also no longer dependent on System.Web. By reducing the overhead in the pipeline, your app can experience better performance and better-tuned HTTP stacks. The new pipeline is based on much of what was learned from the Katana project and also supports OWIN.

Dynamic Web Development

Another cool feature in Visual Studio 2015 is the ability to do dynamic compilation. In the previous versions of ASP.NET, when we change code in our application, we are required to compile and build the application every time we want to see the changes. In the new version of Visual Studio there's no need to do those extra steps anymore, instead you just need to save the file that you are modifying and then refresh the browser to see the changes.

Here's the output after refreshing the browser:

Attribute Routing: the [controller] and [action] tokens

In previous versions of MVC and Web API, working with attribute routing may cause some troubles, especially if you are doing some code refactoring. This is because the route always had to be specified as a string, so whenever you changed the name of the controller you would always need to change the string in the route attribute too.

MVC Core introduces the new [controller] and [action] tokens that can resolve this kind of issue. Here's an excellent article that highlights the use of these new tokens: ASP.NET MVC 6 Attribute Routing.

Integrated Dependency Injection (DI)

ASP.NET Core has built-in support for Dependency Injection and the Service Locator pattern. This means that you no longer need to rely on third-party Dependency Injection frameworks such as Ninject or AutoFac.

Integration with Grunt, Gulp and Bower

Visual Studio 2015 has built-in support for these popular open-source web development tools. Grunt and Gulp are task runners that help you automate your web development work flow. You can use both for compiling or minifying JavaScript files. Bower is a package manager for client-side libraries, including CSS and JavaScript libraries.

Built-in Templates for AngularJs

AngularJs is one of the most popular client-side frameworks for building Single Page Applications (SPAs). Visual Studio 2015 includes templates for creating AngularJs modules, controllers, directives and factories.

The support in ASP.NET Core for GruntJS makes ASP.NET an excellent server-side framework for building client-side AngularJs apps. You can combine and minify all of your AngularJs files automatically whenever you do a build. Check my examples about getting started with Angular and Angular2 in ASP.NET Core:

• ASP.NET 5: Jump Start to AngularJS with MVC 6 Web API
• ASP.NET Core: Getting Started with AngularJS 2

SignalR 3

ASP.NET Core will also be the basis for SignalR 3. This enables you to add real time functionality to cloud connected applications. Check my previous SignalR example here: ASP.Net SignalR: Building a Simple Real-Time Chat Application

Web.Config

In ASP.NET Core, the messy web.config file is being replaced with the new cloud-ready configuration file called “config.json”. Microsoft wanted us developers to deploy apps in the cloud easier and have the app automatically read the correct configuration values for specific environment. Here's an example of how the new config file looks like:

Since everything in ASP.NET Core is pluggable you need to configure the source for the configuration at the Startup class like:

Hide    Copy Code

        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath);

            builder.AddEnvironmentVariables();
            Configuration = builder.Build();
        }
        public IConfigurationRoot Configuration { get; }
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            services.AddTransient<MVC6Demo.Models.HeroStats>();
        }

        public void Configure(IApplicationBuilder app)
        {
            app.UseDeveloperExceptionPage();

            app.UseMvc(m => {
                m.MapRoute(
                    name: "default",
                    template: "{controller}/{action}/{id?}",
                    defaults: new { controller = "Home", action="Index"});
            });
        }

xUnit.Net: The New Unit Test Tool for .NET

In previous versions of ASP.NET MVC, the default testing framework was the Visual Studio Unit Testing Framework (sometimes called mstest). This framework uses the [TestClass] and [TestMethod] attributes to describe a unit test.

ASP.NET Core uses xUnit.net as its unit test framework. This framework uses the [Fact] attribute instead of the [TestMethod] attribute and eliminates the need for the [TestClass] attribute.

Absolutely Free and Open Source

Yes, ASP.NET Core as an open source project on GitHub. You can view the code, see when changes were made, download the code and submit changes.

I would agree that open-sourcing .NET makes good sense. It makes good business sense and good community sense. A big thanks to Microsoft. Job well done!

I hope someone find this article useful.

Summary

In this article we've learned some of the new cool features and concepts in ASP.NET Core 1.0.

History

<a href="http://pubads.g.doubleclick.net/gampad/jump?iu=/6839/lqm.codeproject.site/Web-Development/ASP-NET/General&sz=300x250&c=449142"><img src="http://pubads.g.doubleclick.net/gampad/ad?iu=/6839/lqm.codeproject.site/Web-Development/ASP-NET/General&sz=300x250&c=449142" width="300px" height="250px" target="_blank"/></a>

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)