In this blog post we are going to talk about the basics and new features in ASP.NET 5 and Visual Studio 2015 by creating our favourite Hello World Program.

Visual Studio 2015 is a File based project system now which means that when we add a file in the file system then it is automatically picked up and a dynamic compilation happens that could result in faster refresh and faster build behind the scenes. This is possible because of the Rosyln compiler https://github.com/dotnet/roslyn.
In the newer version of Visual studio we can develop applications with the full featured .Net framework as well as the Cloud Optimized Core CLR. The idea of designing this new Core CLR is to make the application with fast startup, low memory usage and high throughput (I wonder why this is not the default framework always). Core CLR is designed to work on the  environments other than windows as well like Linux and OSX. Core CLR is available as a nuget package and hence could be deployed as part of the application itself but keep in mind, this being an optimized CLR might be missing types available in the full features .NET framework.

 

The newer version of ASP.NET has taken steps towards unification by combining ASP.NET MVC + WebAPI into one class itself which means that it would have only one base controller for both.

 

MVC 6 does not rely on the System.Web anymore and also the minimum size of the HttpContext is reduced to 2kb from 30kb. Let’s create our favourite project HelloWorld in ASP.NET 5

 

Make sure you select the Web Application under ASP.NET 5 Templates. and Uncheck the Host in Cloud checkbox for now.

 

Now let’s navigate to the Controllers folder of the project in the File Explorer and create a new file named HellowWorldController.cs

You would notice that this file is automatically refreshed in the solution

 

Now let’s add some code to this controller to see it in action.

using Microsoft.AspNet.Mvc;

namespace HelloASPNET5.Controllers
{
   public class HelloWorldController : Controller
   {
       public string Index()
       {
           return "Hello World! Have we achieved World Peace Yet?";
       }
   }
}

 

Build and run the project by pressing Ctrl + F5 and change the url to call the controller that we just created.

 

This was certainly less painful as we do not have to remember what files we created in the file system (Not that I do, Git takes care of all that) as Visual Studio automatically takes care of that.

Now if we change the controller and save the file and then refresh the browser, my changes are reflected which was not the case before while working with C# files.

 

The root of the website is not longer the root of the project. By default the root of the website is wwwroot folder which contain all the static resources of the Website (including the bin folder for dlls) by default. We can add more static resources here as well. This allows a clear separation between the files that need to deployed to webserver and the configuration files.

 

By default the views also reference resources from the webroot (~) of the website.

 

We could change it by modifying the webroot in the project.json file.We will also notice the new way of declaring dependencies.

However the dependencies that could be added in project.json has be 100% .NET dependencies. We could include these dependencies using the good old Manage Nuget Packages option.

 

or we could hand type the dependencies in the project.json files itself and intellisense would help us out there. We could specify the version we want to target or add empty string (“”) to use the latest always.

Once we do that and save the project.json file we would see that the References section in the solution explorer will show the progress of getting and mapping the package that we just added. And at last building the project.

 

If you look further down in the project.json file you would see in the framework section that both full featured dotnet and dotnet core frameworks have been included. This will make visual studio build the solution against both the framework which could be beneficial when we are supporting multiple frameworks.

 

When we run the project in the local system it would run against only one of the framework so to check which framework we are running against we could go to the project properties we could select the framework.

 

When we are working in the solution on anything like say in the HelloWorldController I want to return the current date and time using timezone then we could see the information of availability in intellisence.

 

We could use the # defined symbols to write code against specific frameworks. Like we could use #dnx451 for dotnet framework and #dnxcore50 for core framework.

namespace HelloASPNET5.Controllers
{
   public class HelloWorldController : Controller
   {
       public string Index()
       {
#if dnx451
           return "Hello World its " + System.TimeZone.CurrentTimeZone.ToLocalTime(System.DateTime.Now).ToString() + "here.";
#endif
           return "I don't know whet time it is.";
       }
   }
}

 

 

Now if you see the in the current solution of the project you would not find the packages that are listed as dependencies. The reason is because they are present under the user profile folder in .dnx folder.

 

When you go inside the .dnx folder you would see the packages folder where all the packages referenced by the current project and all the other projects will be present so that all of them could be reusable.

 

You would also see a runtimes folder where we could see the available runtimes which are x64 and x86 versions of both full dotnet framework and core framework.

 

 

Any questions, comments and feedback are always welcome.