Running Gulp tasks in Visual Studio

Over the last decade, front end development has matured from a point where CSS and JavaScript were written in badly organised files containing the exact code a browser would interpret, to something that now more resembles back end development.

Pure CSS has become the byte code of the front end world with LESS and Sass becoming the languages of choice. Instead of MSBuild for running a compilation Gulp can be used to automate workflows to compile Sass files, minify them and do whatever else is needed to produce the code for deployment (not really an exact comparison, but you get the point).

To truly achieve a matured development setup though, the final step is to remove those “compiled” css and js files from source control. After all you wouldn’t check in a dll with the source code for each build. If your using a build server then this is a relatively easy step to add to your workflow. However the bigger issue is not making life hard for your back end developers.

Without the final CSS and JS files in source control your back end devs may now be faced with a site lacking all style and front end functionality when they hit F5. With LESS and Sass also not really being there thing, they’re now left not really knowing what to do, and also not overly happy about having to learn something about front end do continue with there back end work. To make matters worse, Visual Studio often isn’t the front end dev’s choice of tool so copying the front enders setup isn’t an ideal solution either.

The Aim

The ideal solution would be for a back end dev to be able to check out a solution from source control (containing no compiled CSS of JS files), hit F5 in Visual Studio, the final CSS and JS be created as part of the build and the site to run. No opening a command prompt to run a gulp task, or any other process the front end devs may be using. It should be completely invisible to them.

Visual Studio Task Runner

With Visual Studios Task Runner, this is entirely possible.

The Task Runner is built into Visual Studio, so there’s no need for the back end dev to install any extra tools, and more importantly, tasks can be linked into a before build event so that the back end dev doesn’t need to do anything.

A bit of background on gulp and the task runner

When front end developers set up gulp, they will configure a set of gulp tasks within a file named gulpfile.js (in reality they may actually separate the tasks into multiple files referenced by gulpfile.js, but this file is the important bit). These tasks may look a bit like this:

gulp.task("min:js", () => {
  return gulp.src([paths.js, "!" + paths.minJs], { base: "." })

gulp.task("min:css", () => {
  return gulp.src([paths.css, "!" + paths.minCss])

gulp.task("min", gulp.series(["min:js", "min:css"]));

In this example there are 3 tasks. The first minifies some JS while the second minifies some CSS. The third is defining a series which runs the first 2.

Visual Studios task runner will look file the file called gulpfile.js and pull out all the tasks within it. The task runner window may not be open by default, so to open it type task runner in the search box and select it from the results. Alternatively you can right click the gulpfile in the solution and select Task Runner from the context menu.

The task runner window will open at the bottom of the screen, and will list out all the gulp tasks found within the gulpfile.js file. If the front end devs have organised the tasks into separate files, as long as the gulpfile.js file in the root of the project has some way of referencing them, they will still show up.

If you don’t see any of the tasks, and have only just added the file or a task to the file. You may need to click the refresh button.

To run a task, simply right click it and then choose Run.

Automating on build

Being able to run a gulp task is handy, but what we’re really after is for it to be automated as part of the build.

For this we just need to right click the task to be run, and then from the bindings option, select before build.

This will add a comment to the top of the gulpfile.js which Visual Studio will look for to know what task should be run before a build.

/// <binding BeforeBuild='min' />

With this set, the back end devs no longer need to be concerned with not having any compiled css and js, and with a small amount of knowledge also have the ability to make minor changes to css and js where needed.

Some others tips

Depending on your front end devs setup there could be some additional challenges to overcome.

Front end devs not using Visual Studio

Quite often Visual Studio isn’t the choice of dev environment for a front end dev. One issue this can lead to is files missing from the Visual Studio solution. However an easy fix for this is to use wild cards in the csproj file.

If the front end devs code can be grouped into specific folders then use a wild card to include all the files from that folder in the project.

<None Include="build\js\**\*.js" />

CSS/JS not in the web project

If the front end devs have a separate folder for there work. e.g. they might work with static html files. Then the code may not be in the project what will be run, and therefore nothing will trigger the gulp file to have it’s task run.

A simple solution for this is to create a visual studio project for the folder with there work so that it has a build event to be attached to. Make sure your web project also references this project to trigger it to be built when the web project is.


For more info on using Gulp with Visual Studio. Check out Microsofts guide on using Gulp with ASP.NET Core.

Using Visual Studio with Git Hub

This is one of those great examples of writing a blog post to yourself to remind you how to do something.

If your using Visual Studio 2012 then to add Git support you will need the Visual Studio Tools for Git plugin created by Microsoft’s TFS Power Tools Team (, if your using a later version of Visual Studio then it’s already built in.

If you’re thinking in of using Git Hub as your source control provider then the most basic thing you’re going to need to know is how do you get the Git plugin to link up to GitHub. Here’s a couple of different methods;

Creating a Project in Git Hub

Click New Repository. Enter a new, Select Public or Private and click Create new Repository.

A new repository will be created in Git Hub

Clone the Project in Visual Studio

Now the project has been created in Git Hub you will need to clone it to your machine so that you can start adding files and sync then back.

Open a new instance of Visual Studio and do the following:

  1. Open the Team Explorer window
  2. Click the connect button
  3. In the list of Local Git Repositories click clone
  4. In the URL box enter the HTTP URL from Git Hub
  5. The second box should auto populate with a location on your hard disk
  6. Click Clone

Creating a Repository on Git Hub using the Git Hub app

Rather than creating the Git Hub repo through the GitHub website you can use their app. Once you’ve got the app installed and logged in do the following:

  1. Select the GitHub account you want to add the repo to on the left
  2. Click Create button at the top
  3. Enter a name and click create
  4. The repository will be created in GitHub and automatically sync with the folder on your machine

Adding an existing Repository to Visual Studio

If you already have a repository cloned on your machine but it’s not showing in Team Explorer you can add it by clicking on Add

  1. Click the Connect button to view the list of local repositories
  2. Click add an enter the path to the repository on your hard drive
  3. Click Add

.NET Charts (Pleasing clients by giving them a graph to look at)

Irruspective of if your working on some kind of company extranet or the admin side of a public facing site, one thing that will make you’re clients go ooooooo and love your work is the inclusion of a funky looking chart. It may not serve any amazing purpose, but as there looking through all the boring text area’s and buttons that actually make up the functinality of the site, the inclusion of nice looking chart is going to make them go “oooo that’s nice” and like you even more. For those of us working in .NET, thank’s to an update from Microsoft at the end of 2008 it’s also something that’ve very quick an easy to do. Better yet the update was free so the only cost is the time you take to impletement it. 

First off if you want to use the chart’s and you haven’t downloaded them then that’s what you need to do. The chart’s shipped after .NET 3.5 so there a seperate install, .NET 4 however has them included by default. 

Using the Chart Control

Like I said adding a chart to a page is a quick and easy thing to do. Once you have the Visual Studio add on installed you can also drag and drop everything into place. However im going to go into a bit more detail. 

To start your going to need a data source. In this example im using a SQL Data Source object for ease of use, in a production environment I heavely recomend against using them as there going to make your code a completly unmanagable mess, instead I would use something like a Entity Data Source. My chart is going to be showing a graph of mobile phone handset popularity so my SQL is simply just returning a table of phone names and how many people use them. 

Code so far: 

<asp:SqlDataSource ID=”ChartDB” runat=”server” ConnectionString=”<%$ ConnectionStrings:ConnectionString %> SelectCommand=”SELECT [Name], [People] FROM [PhonePopularity]”>

Next we need to add a chart, the easiest way to do this is to just drag a chart object onto the page from the toolbox, however if you do want to type it yourself it’s not particularly complex. 

First you will need to register the assembly on the page.. 

 <%@ Register assembly=”System.Web.DataVisualization, Version=, Culture=neutral, PublicKeyToken=31bf3856ad364e35″ namespace=”System.Web.UI.DataVisualization.Charting” tagprefix=”asp” %> 

And then add the chart like so…

<asp:Chart ID=”Chart1″ runat=”server” DataSourceID=”ChartDB” Height=”400px” Width=”400px”>

Now we’re ready to start customizing what type of chart we’re going to have and what data it should show from our data source.

To actually show a chart there’s two bits of information you have to describe, area’s and series’. The first area’s is used to define an area for a chart to appear, one interesting thing about the chart control is you arn’t limited to just one area. In fact in this example I’m going to have to chart’s one showing a pie chart of phone popularity that will quickly show what kind of share each phone has, and then a second bar chart making it more clear the actual numbers people have of each phone. Area’s also let you set properties on what the chart is actually going to look like as well. In this instance I’m going to set for both charts to be 3D.

The second bit of information is the Series. This is where you’re actually specifying what data is going to be shown in which area and what kind of chart it is (e.g. Pie, Column, Donut etc). My completed code then looks like this…

<asp:Chart ID=”Chart1″ runat=”server” DataSourceID=”ChartDB” Height=”400px” Width=”400px”>


<asp:Series ChartArea=”ChartArea1″ ChartType=”Pie” Name=”Series1″ XValueMember=”Name” YValueMembers=”People”>
<asp:Series ChartArea=”ChartArea2″ Name=”Series2″ XValueMember=”Name” YValueMembers=”People”>


<asp:ChartArea AlignmentOrientation=”Horizontal” Name=”ChartArea1″>

<Area3DStyle Enable3D=”True” />

<asp:ChartArea Name=”ChartArea2″>

<area3dstyle enable3d=”True” />




Depending on your data this should give you something like this…

This is just a simple example of what you can do, but if you download the Chart Samples Project and have a look through there is no end to the possibilites with everything from different styles of charts to adding ajax functionality even with the ability to click of different parts of the carts to trigger events.