In Visual Studio 2013 they decided to create one web project called ASP.NET Web Application to make it simpler as opposed to VS 2012 which had 7 different templates. I like this project wizard but I think there is a gap in the templates it provides when you want to start a Web API project. If you select Web API it comes with a full blown ASP.NET MVC website. If you select Empty you don’t get anything. I feel like there should be something in between: A functional Web API project with no overhead of the website.

Minimal Web API

The steps to achieve this are simple. I found this blog post that helped me to get what I wanted quickly.

For the sake of completeness the steps to create the minimal Web API project is as follows (I changed some of the steps to suit my needs):

1. Create an Emptry ASP.NET Web Project

2. Install Web API package via Nuget

    Install-Package Microsoft.AspNet.WebApi
   

3. Add a Global Configuration Class and add the following line defining a default route to Application_Start method

    protected void Application_Start(object sender, EventArgs e)
    {
        GlobalConfiguration.Configuration.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
    }
   

1. Add a controller from Web API Controller Class (v2.1) template and rename it to DefaultController. By default it comes with method implementations for GET/POST/PUT/DELETE HTTP verbs:

    public class DefaultController : ApiController
    {
        // GET: api/Entry
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }
   
        // GET: api/Entry/5
        public string Get(int id)
        {
            return "value";
        }
   
        // POST: api/Entry
        public void Post([FromBody]string value)
        {
        }
   
        // PUT: api/Entry/5
        public void Put(int id, [FromBody]string value)
        {
        }
   
        // DELETE: api/Entry/5
        public void Delete(int id)
        {
        }
    }	
   

2. In order to run properly the following references need to be deployed:

   • System.Net.Http.Formatting
   • System.Web.Http
   • System.Web.Http.WebHost

So change Copy Local to true in the properties window.

That’s all it takes to create a working Web API.

Templates in action

Now I have what I want but when I need a new Web API project I don’t want to start from scratch every time. Instead I’d rather use the nice and easy templating feature of Visual Studio. To create the template:

1. Select File -> Export Template

   

2. Leave “Project template” selected and click next. Give the template a name and description. It will automatically import the template to Visual Studio so leave the defaults.

   

When you need to create a simple Web API you can use this template from now on by simply searching webapi in the templates:

And when you create a new project based on this template (not surprisingly) you get something like this:

Creating the project from scratch was easy enough but using templates is even easier so why not use it!

Resources

• ASP.NET Web API from scratch

Moving on in the TryFSharp.org site today I finished the last two sections in the Advanced part.

Notes

• Computational Expressions can be used to “alter the standard evaluation rule of the language and define sub-languages that model certain programming patterns”

  The reason we can alter the semantics of the language is the F# compiler rewrites (de-sugars) computation expressions before compiling.

  For example the code snippet below

    type Age =
    | PossiblyAlive of int
    | NotAlive
  	
    type AgeBuilder() =
        member this.Bind(x, f) =
            match x with
            | PossiblyAlive(x) when x >= 0 && x <= 120 -> f(x)
            | _ -> NotAlive
        member this.Delay(f) = f()
        member this.Return(x) = PossiblyAlive x
  	
    let age = new AgeBuilder()
  	
    let willBeThere a y =
      age { 
        let! current = PossiblyAlive a
        let! future = PossiblyAlive (y + a)
  	
        return future
      }
    willBeThere 38 150
  

  is de-sugared to this:

    let willBeThere2 a y =
      age.Delay(fun () -> 
        age.Bind(PossiblyAlive a, fun current ->
          age.Bind(PossiblyAlive (y+a), fun future ->
            age.Return(future))))
  	
    willBeThere2 38 80
  

  At this point this concept seems too complicated to sink my teeth into. TryFSharp.suggests further study of the following concepts to have a better understanding of computation expressions:

  • The sophisticated architecture of function calls that are generated by de-sugaring
  • Monads - the theory behind computational expressions

• Quotations is a language feature “that enables you to generate and work with F# code expressions programmatically. This feature lets you generate an abstract syntax tree that represents F# code. The abstract syntax tree can then be traversed and processed according to the needs of your application. For example, you can use the tree to generate F# code or generate code in some other language.”

Conclusion

After dabbling 4 days in TryFSharp.org I think it’s time to move on. There are 4 more sections in the site but since I can only learn by building something on my own I’ll try to come up with a small project to use the basics. Otherwise it’s likely that all this information will be forgotten. It’s already very overwhelming and I need a small achievement to motivate myself.

So I leave TryFSharp.org at this point, for a while at least. Even though I don’t find the advanced topics well-explained it’s still a very nice resource to get started.

Resources

• MSDN Article - Code Quotations
• TryFSharp.org
• StackOverflow - Getting started with F#

I’m glad I moved my blog to GitHub pages (especially after I saw this news) and I’m very happy using Jekyll locally while working on my posts. But as a recent Surface Pro 3 owner (review pending) I thought I could work outside home more often which broached the subject how do I synchronize the posts that are not ready to be published.

So far, I was storing them locally on my machine until they are finished which always posed the risk of losing them as they are the sole copy of the post.

Today I discovered a neat feature of Jekyll to end my local copy problem and making all my posts easily synced to everywhere: _drafts folder

Normally the posts go to _posts folder. Now I keep all incomplete posts under _drafts folder. I can checkin anytime as they don’t go live. And I can still use local Jekyll server by using the –drafts flag such as

bundle exec jekyll serve --drafts

With this flag they are compiled like normal posts which allows me to preview them easily.

Best of both worlds!