IVAN SIVAK
  • About
  • Blog
  • CV
  • Contact

ASP.NET Core: MVC6 Gulp Template

9/24/2016

0 Comments

 
As discussed in the previous ASP.NET Core article the purpose of this article is to show you how set up a basic gulp template instead of default .NET Core bundles which I personally don't prefer. In my eyes the gulp is far more powerful and simply becomes a must if you deal with larger JavaScript project.
The whole empty template can be downloaded from my GitHub page: ​https://github.com/IvanSivak/ASP.NET-Core-MVC6-Gulp-Template.

Gulp

The best way to get familiar with my template is just by opening the project and see the changes. Let me just briefly clarify. 
  • There is no bundleconfig.json.
  • The whole JavaScript application is outside the wwwroot folder within the JsApp folder.
  • The same with CSS files - outside the wwwroot in the Styles folder.
  • Everything related to build process is inside the gulpfile.js
  • Every change to JavaScript or CSS files triggers gulp to rebuild the project (gulp watcher - don't forget to run it).

    
  • Everything is set up to reflect the current environment. Gulp does not minify or bundle if you're in development environment. 
  • _Layout.cshtml contains all the logic related to which environment files should be downloaded (using the new <environment> tag helper). For both the JavaScript and CSS.

    
  • Everything is simple and clean. Nicely just on one place in _Layout.cshtml and gulpfile.js.
Let me know if you have any issues with my template or recommendations. Unfortunately I was unable to export the project into a template (issue has been discussed on stack overflow) but since the project is very simple and clean you should be able to just download and rename the project or use it as a reference to set up your own new project.
0 Comments

ASP.NET Core: Overview & CHANGES

9/11/2016

0 Comments

 
After spending a couple of weeks experimenting with the new ASP.NET Core I am confident to say it's the best ASP.NET ever released. There are many reasons why the new version of ASP.NET is better from the previous versions. This article is focused on basic differences,  improvements and shows the basic project set up example using gulp.

.NET vs. mono vs. NuGet

Before we start let's just remind the basic principles and basic options of .NET.
In order to run traditional .NET application there always needs to be a version of .NET Framework installed on a machine where program runs. Whether it's EXE or DLL it always contains so called intermediate language (IL). The IL itself needs to be compiled by just-in-time (JIT) compiler which is included in .NET Framework itself and is part of Common Language Runtime (CLR). In short, just before the program executes the JIT kicks in, compiles the IL and CLR runs the program. Hence, the CLR is responsible for almost every .NET functionality and FCL (Framework Class Library) contains all .NET types and classes.
Mono is open source project developed by community. It is compatible with .NET framework and uses the same principle as MS CLR. It offers distributions for Linux, Mac and Windows which makes it a cross-platform alternative for .NET applications. Mono also stands on basis of Xamarin. 
As every packaging system the NuGet exists to make things easier. Since .NET framework itself is a very large set of classes, types, libraries etc. (the FCL and CLR) it is difficult to make updates. With every new FCL version Microsoft needs to distribute new .NET Framework version. This is what makes the NuGet so useful. You can deliver or update only particular libraries. Great example is MVC or WebAPI. These libraries are NuGet packages. They do not exist in FCL. This is what allowed these libraries to evolve so rapidly. Rapid updates of single NuGet packages not tied to .NET Framework allowed them to be developed and updated much faster. 

ASP.NET Core

There are many advantages and changes in ASP.NET Core over the previous ASP.NET. Here is a list to name the most important ones
  • While it is true that .NET Core has also an equivalent of CLR and FCL called CoreCLR and CoreFX, these are fully distributed as NuGet packages itself. This is a tremendous advantage as stated above.
  • Cross platform. One of the biggest advantages. Since the .NET Core CLI (Command Line Interface) exists in three distributions for the Linux, Mac and Windows, the .NET Core applications can hence run on these platforms as well. It is the .NET Core CLI that executes the intermediate language (IL). You don't need Windows anymore. 
  • .NET Core is much more efficient and lightweight. CoreFX does not include complete frameworks such as FCL does for WPF, WebForms etc. Traditional .NET Framework contains plenty of things you don't need in your application. The CoreFX contains only basic features such as collections etc. Everything else is distributed by the NuGet. The .NET Core is also much smaller.
  • Web Forms do not exist in ASP.NET Core anymore.
  • No need for web.config (required only if hosted on IIS).
  • No global.asax (instead application events are handled in the main method).
  • Contains various optimizations and performance improvements, is open source, can run as stand-alone application and many more details...

WebAPI vs. mvc vs. system.web

  • The system.web library is tied to IIS server.
  • In classic ASP.NET the MVC is tied to system.web which is quite constricting in terms of multi platform capabilities.
  • WebAPI is not tied to system.web library and as such it gives the project the ability to be self hosted.
  • The "old" MVC and WebAPI have been unified into one single framework called MVC for ASP.NET Core. Both share the same set of types and of course don't depend on system.web.

Example asp.net core project

Let's get started with an example. First of all, if you don't use at least Visual Studio 2015 Update 4 you will need to download the ASP.NET Core template into your visual studio. Everything is nicely described on the official documentation page here: https://docs.asp.net/en/latest/ or you can simply go straight to the download link at: ​https://www.microsoft.com/net/core.

No CSPROJ file & global.json

One thing I really like among others is that there's no csproj file anymore. It makes it easier for source version control. How many conflicts of project file we already had in GIT? The ASP.NET Core simply reflects the file system. There's no need for "include in the project" function and so on. Instead the global.json is presented. 

project.json

The project.json contains various meta data of a project, settings such as publishOptions and very important - references to NuGet packages. Note that NuGet packages are not installed into the packages folder anymore. Instead all NuGet packages are inside your user folder, e.g. c:\users\ivan\.nuget
Picture

wwwroot

In classic ASP.NET everything was pretty much contained within the project root. The new wwwroot folder brings more clarity into web publishing as only what stays in wwwroot folder is accessible by a web server. This can be changed in project.json/publishOptions though, e.g. we want Views folder to be exposed as well hence we can add it as follows:

    

Dependencies & Bower

Dependencies folder is about client side development. In principle the Bower is the same as NuGet. The difference is that Bower is focused on client side libraries and frameworks (such as jQuery, Bootstrap, Angular etc.) and runs under Node.JS. NPM (Node Package Manager) is the same thing but aims at Node.JS libraries, such as Gulp etc. 
Picture

.Net Core Bundles vs. Gulp

When you create a new ASP.NET Core Web Application the default template uses built-in .NET Core bundles mechanism which takes care of JavaScript and CSS files bundling and minification. The same can be achieved using well known Gulp and both have their pros and cons.
Personally, I prefer the Gulp over the built-in .NET Core bundles. My projects usually tend to be JavaScript very rich and it is mostly the JavaScript part that grows a lot. As the development goes by sooner or later you will end up using various gulp plugins such as nunjucks for templates processing and many others. Having it all (the minification and bundling) nicely managed by gulp since the beginning brings more clarity to the project and in my eyes is a way more powerful.
There are alternatives, for example ASP.NET MVC Boilerplate template that uses gulp. The whole story behind .NET Core default web template and why it doesn't use gulp is described here. Since Boilerplate is quite heavy template I decided to create my own lightweight ASP.NET Core MVC6 Gulp Template. This will be described in my next article about such lightweight template.
0 Comments

    About

    Blog about my programming experiments, tests and so on.

    View my profile on LinkedIn

    Categories

    All
    Algorithms
    Angular 2
    ASP.NET
    ASP.NET Core
    Aurelia JS
    Cryptography
    Data Structures
    Gulp
    JavaScript
    Math
    MVC6
    .NET Core
    React JS
    Security
    SQL Server

    Archives

    November 2016
    October 2016
    September 2016
    May 2016
    March 2016
    February 2016
    January 2016
    December 2015
    October 2015

    RSS Feed

Ivan Sivak


Stack overflow

Stack overflow profile

LinkedIn

LinkedIn profile

Email

ivansivak@outlook.com

GitHub

GitHub repository
  • About
  • Blog
  • CV
  • Contact