Using Angular 2 with ASP.NET Core

This tutorial is aimed at beginners starting Angular 2 in ASP.NET Core using Visual Studio 2015. I have compiled the steps involved in starting to learn Angular 2. This is largely a step-by-step explanation, and you will feel much more confident at the end of the article.

I used Visual Studio 2015 Community Edition Update 3, TypeScript 2.0, latest NPM, Gulp. For Visual Studio and TypeScript, I suggest that you use the same versions that I use in this guide.

ASP.NET Core is designed as pluggable framework to include and use only necessary packages, instead of including too many modules initially.

Let's create an HTML file named index.html under wwwroot folder.

Right click on wwwroot folder, Add New Item and create the index.html file. This HTML page will act as default page.

For ASP.NET Core to serve static files, we need to add StaticFiles middleware in the Configure method of the Startup.cs page. Ensure that packages are restored properly.

project.json is redesigned to make it better, we have StaticFiles middleware to serve static assets like HTML, JS files etc.

Interestingly Program.cs is an entry point of application execution just like main().

Run the application now. Notice that ASP.NET Core renders the static HTML page.

Delete this index.html page, we will be injecting this dynamically later. Till now you saw demonstration of “wwwroot“ as root folder for ASP.NET Core web apps.

Angular 2 has famously claimed to be the ONE Framework for mobile and desktop apps.

This tutorial refers to 5 MIN QUICK START for getting started. The 5-minute guide is more focused on other light-weight code editors. However, we are using Visual Studio 2015 Community Edition Update 3 for its built-in TypeScript tooling and other features.

We will be using Webpack as our module bundler. It’s an excellent alternative to the systemJS approach. To learn more about Webpack, read Webpack and Angular 2

The majority of Webpack scripting is based on AngularClass’s angular2-webpack-starter. I have modified it according to ASP.NET Core web apps.

ASP.NET Core follows Single Page Application (SPA) architecture rather than a Model-View-Controller (MVC) framework.

Why Webpack for Angular 2 in ASP.NET Core? I could have probably used many other bundlers.

However, Webpack does have many perks:

• It's much simpler to code, plugins based working with static files.
• Webpack 2 with dev-server runs application in memory, live reloading & compilation is easy. It provides tree shaking to eliminate unused code.
• Integrating with 3rd party packages like Angular Material 2, AngularFire, bootstrap, and more is short and sweet.
• The AngularClass webpack starter kit provides HMR (Hot Module Replacement) – maintain execution state while code gets modified.
• Webpack is adopted by Angular CLI, AngularService by Microsoft for making bundles much smaller.

The Angular 2 team is pushing the code changes using NPM rather than CDN or any other source. Due to this, we need to add an NPM configuration file (package.json) to this ASP.NET Core application.

Right Click on “ngCoreContacts“, add new file “NPM Configuration File“; by default package.json is added to ASP.NET Core project. This acts Node Package Manager (NPM) file, a must-have for adding packages when using Angular 2.

From the Angular 2 Quick Start provided above, we need to add required dependencies. Copy-paste the below configuration in your package.json file

Right after saving this, ASP.NET Core starts restoring the packages. It will download all packages mentioned in the dependencies section of the package.json file.

The Visual Studio Solution Explorer might read ‘Dependencies – not installed’. Don’t worry; all the npm packages have been installed. This is simply a bug in the tooling.

You must do this for Angular 2 in ASP.NET Core apps that use TypeScript. The TypeScript Configuration file handles transpiling our application to JavaScript, loads modules, and meets ES5 standards.

Refer to Getting Started with TypeScript if want a beginner intro on TypeScript configuration.

Add tsconfig.json in the project, and add in the configuration below.

“baseUrl” ensures that TypeScript files are transpiled to JavaScript from the ‘./clientsrc‘. This folder is virtual directory for TypeScript

At present typings.json is not required because we are using @types with TypeScript. However if your using any other packages which don’t have entries in @types then typings.json has to be added.

Webpack is a powerful module bundler. A bundle is a JavaScript file that incorporate assets that belong together and should be served to the client in a response to a single file request. A bundle can include JavaScript, CSS, HTML, and almost any other language.

Webpack roams over your application source code, looking for import statements, building a dependency graph, and emitting one (or more) bundles. With plugin “loaders” Webpack can preprocess and minify different non-JavaScript files such as TypeScript, SASS, and LESS files.

In package.json, we have added “webpack“ packages as “devdependencies“. They will perform all bundling work.

webpack.config.js defines what Webpack does. As always, the applications are run in Development, Test and Production environment.

There are some common functionalities and some specific to environments. We will focus on the development and production environment.

The development environment should have source maps for debugging TypeScript files. However, minifying bundles of JS, CSS, etc. is not required. The production environment should minify bundles to reduce loading time. Webpack 2 also does tree-shaking, a method for eliminating unused code to shrink bundle sizes.

The entire source code is on my github repo, fork or clone to play with it.

webpack.config.js – Based on environment set process.env.NODE_ENV, it runs either dev or prod configurations.

Webpack.common.js before bundling environment specific files, it performs tasks meant to be used for both environment.

Webpack splits Angular 2 apps into 3 files polyfills (to maintain backward compatibility with older browsers), vendors (all JS, CSS, HTML, SCSS, images, JSON etc into one file) and boot (application specific files). This split is resolved based on various file extensions when Webpack itself doesn’t know what to do with a non-JavaScript file.

We teach it to process such files into JavaScript using loaders. For this, we have written loaders for TS, HTML, JSON, fonts, images, and more. Any static assets placed in clientsrc/assets will be copied to assets folder using CopyWebpackPlugin. CleanWebpackPlugin cleans wwwroot/dist folder every time we run it, so that we get fresh set of files.

I told you above to delete the index.html file, now the clientsrc/index.html will be moved to wwwroot using HtmlWebpackPlugin. Plus Webpack injects the bundle files i.e. polyfills, vendor, boot JS files and includes them in HTML script reference. Now let’s see webpack.dev.js for development purpose

Running webpack-dev-server – this runs the entire application in memory. Any changes to source file gets applied immediately. Loads application in debug mode with source map. Runs the application on localhost 3000 port. (The port can be changed as your convenience.)

Now let’s take a look at what webpack.prod.js does:

• Merges all the bundle files and copies to wwwroot.
• Minifies all files to load faster using UglifyJsPlugin.

Hopefully this clarifies some of Webpack's functionalities.

Until now we created ASP.NET Core app, added TSconfig file, webpack configuration. Now it’s time to write the Angular 2 application.

In the github repo, you can see the “clientsrc” folder. This contains the Angular 2 app which gets bundled into using webpack configurations we wrote

“Clientsrc“ folder has index.html, polyfills.browses.ts, vendor.browsers.ts and mostly importantly boot.ts.

We have app folder containing HTML, Angular 2 components and root level module (app.module.ts) which gets loaded while bootstrapping application.

Some of files might be not interesting now, will focus them in separate articles later.

Before running make sure you have run command npm install. This might not be needed but still it will ensure all packages are installed.

From command line (directory should be same as package.json), type npm start & hit enter. It will start running the webpack-dev-server which loads application and listens on localhost:3000. When the console reads bundle is now VALID, open a browser and navigate to https://localhost:3000 to see the loaded application Notice wwwroot folder, we don’t see any files copied because everything is running in memory.

Now that the application runs properly on browser, let’s understand how Angular 2 app loads.

When the browser starts rendering the index.html page, it encounters the Loading… tag. Then Angular’s module platformBrowserDynamic bootstraps clientsrc/app/AppModule through line platformBrowserDynamic().bootstrapModule(AppModule).

AppModule then loads the component app.component.ts which is mentioned in @NgModule as bootstrap entry. Clientsrc/src/Appcomponent then resolves the <my-app> tag as a selector in it and renders the UI with TypeScript code.

When we enter npm start in console to run the application, execution points scripts section of package.json to below code

This invokes webpack-dev-server, runs the development config, and watches for any changes in clientsrc folder. Any changes in this folder will reload the application with changes.

Here ASP.NET Core feels just like an HTML-based web app, so run using npm start to use AngularClass features of reloading, using webpack, Hot module replacement feature.

Running the application in Production mode

Assuming the application is now ready to deployed, we need to have the PROD build. For this run command

Now if you see wwwroot folder, we see the HTML, JS bundle files. This wwwroot folder can be deployed on any web server like IIS or nginx.

You can either do F5 to run from Visual Studio IDE or run command npm run server:prod

Hopefully this tutorial helped you create your Angular 2 app using Visual Studio. Thank you for reading!