dev visual_studio, web_api

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 });
     }
    
  4. 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)
         {
         }
     }	
    
  5. 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

    Visual Studio Project Template Wizard

  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.

    Visual Studio Project Template Wizard Otions

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

Visual Studio Project Template Search

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

Visual Studio Project Template-Based Project Output

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

Resources

dev fsharp

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.

TryFSharp.org

Resources

dev fsharp

It’s hard to accustomed to F# notation after getting used to OO languages like C#. Today I’ll work on the advanced section of the TryFSharp.org site. As I go forward the concepts are taking longer and becoming harder to grasp!

Notes

  • Currying is an interesting concept. It means you don’t have to provide all of the arguments when calling a function. for example

An addition function can be defined as

let add x y = x + y

and another function using this definition can be defined as

let addFive = add 5

In this case addFive returns another function which is waiting for the rest if the arguments. For example the following code snippet prints 17

let add x y = x + y
let addFive = add 5
printfn "%d" (addFive 12)
  • Operators can be overloaded but it should be used with care as it may make the code obfuscated in some cases
type Point(x:float, y:float) =
  member this.X = x
  member this.Y = y

  static member (+) (p1:Point, p2:Point) = 
      new Point(p1.X + p2.X, p1.Y+p2.Y)

let p1, p2 = new Point(0., 1.), new Point(1.,1.)
p1 + p2
  • Active Patterns allow to wrap arbitrary values in a union-like data structure for easy pattern matching.

For example:

let (|Even|Odd|) n =
    if n % 2 = 0 then
        Even
    else
        Odd

In this case Even and Odd are union constructors, so our active pattern either returns an instance of Even or an instance of Odd.

Conclusion

Today I completed the first 2 sections of Advanced section in TryFSharp.org, only 2 more to go. Even though I’m planning to finish all the material in the site it feels like the advanced topics are not covered in depth. The examples provided are too complex for an absolute beginner. I found the F# Programming Wiki as a better resource for these topics and I’m now going over both these resources.

Resources