Vahid Taslimi's Web log (وبلاگ وحید تسلیمی) - ASP.net

Using Unity with ASP.NET WEB API Controller

Sun, 15 Apr 2012 00:39:00 GMT

Support for Ioc containers is backed into ASP.NET WEB API and uses the service locator pattern dependency resolver by default.

the default service locator implements the IDependencyResolver interface. This interface has two methods.

GetService: Creates one instance of a specified type.
GetServices: Create a collection of objects of a specified type.

in order to use Microsoft Unity framework with ASP.NET WEB API we need to map these to methods to Resolve and ResolveAll methods of Utity. to do so first add the following method to your global.asax.cs or your bootstrapper class

        Public static void RegisterDependencies(IUnityContainer container)

            GlobalConfiguration.Configuration.ServiceResolver.SetResolver(

                t =>

try

                        return container.Resolve(t);

                    catch (ResolutionFailedException)

                        return null;

},

                t =>

try

                        return container.ResolveAll(t);

                    catch (ResolutionFailedException)

                        return new List<object>();

});

this is the method which maps the GetService and GetServices methods to Resolve and ResolveAll methods.

the next and final step is to plug in this method to the framework. to do so you just need to call this method from the method in which you construct your unity container. in my case I create a separate method to take care of this:

        private static IUnityContainer BuildUnityContainer()

            var container = new UnityContainer();

            RegisterMappers(container);

            RegisterDependencies(container);

            container.RegisterControllers();

            DependencyResolver.SetResolver(new UnityDependencyResolver(container));

            return container;

and you are done. you should be able to use your Ioc container with ASP.NET WEB API now.

Hosting ASP.NET WEB API

Sun, 18 Mar 2012 11:26:50 GMT

You may want to host you HTTP Service i.e. ASP.NET WEB API in a console app. well it can be easily done.

to show this lets create a console app and add reference to the following assemblies:

System.Web

System.Web.Http

System.Web.Http.Common

System.Web.Http.SelfHost

System.Web.Http.WebHost

System.Net;

System.Net.Http.Formatting;

System.Net.Http.Headers;

this step is optional but for just touching on Json.net I am going to install Json.net using Nuget.

Now lets add a CarInfo class to return it in our controller

   1:      public class CarInfo

   2:      {

   3:          private readonly DateTime releaseDate = DateTime.UtcNow;

   4:          private readonly Dictionary<int, string> availableColors = new Dictionary<int, string>

   5:            {

   6:            { 1, "yellow"},

   7:            { 2, "red" },

   8:            { 3, "black" },

   9:            };

10:

  11:          public string Name

  12:          {

  13:              get

  14:              {

  15:                  return "BMW X6";

  16:              }

  17:          }

  18:          public DateTime ReleaseDate { get { return releaseDate; } }

  19:          public IDictionary<int, string> AvailableColors { get { return availableColors; } }

  20:      }

And let’s create our home controller as bellow:

   1:      public class HomeController : ApiController

   2:      {

   3:          // GET /api/<controller>

   4:          public CarInfo Get()

   5:          {

   6:              return new CarInfo();

   7:          }

   8:      }

as you see our controller has got just one method which responds to the Get request.

we also need a little helper class to integrate JSon.net to our application. please note as mentioned above using Json.net is optional.

  public class JsonNetFormatter : MediaTypeFormatter

        private readonly JsonSerializerSettings jsonSerializerSettings;

        public JsonNetFormatter(JsonSerializerSettings jsonSerializerSettings)

            this.jsonSerializerSettings = jsonSerializerSettings ?? new JsonSerializerSettings();

            SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));

            Encoding = new UTF8Encoding(false, true);

        protected override bool CanReadType(Type type)

            return type != typeof(IKeyValueModel);

        protected override bool CanWriteType(Type type)

            return true;

        protected override Task<object> OnReadFromStreamAsync(Type type, Stream stream,

HttpContentHeaders contentHeaders, FormatterContext formatterContext)

            var serializer = JsonSerializer.Create(this.jsonSerializerSettings);

            return Task.Factory.StartNew(() =>

                using (var streamReader = new StreamReader(stream, Encoding))

                    using (var jsonTextReader = new JsonTextReader(streamReader))

                        return serializer.Deserialize(jsonTextReader, type);

});

        protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream,

HttpContentHeaders contentHeaders, FormatterContext formatterContext, TransportContext transportContext)

            var serializer = JsonSerializer.Create(this.jsonSerializerSettings);

            return Task.Factory.StartNew(() =>

                using (var jsonTextWriter =

new JsonTextWriter(new StreamWriter(stream, Encoding)) { CloseOutput = false })

                    serializer.Serialize(jsonTextWriter, value);

                    jsonTextWriter.Flush();

});

ok it’s time to create actual host to host our service. you just need to add few lines of code to the main method of the program

        static void Main(string[] args)

            // Set up server configuration

            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost:8081");

            config.Routes.MapHttpRoute("Default", "{controller}", new { controller = "Home" });

            JsonSerializerSettings serializerSettings = new JsonSerializerSettings();

            serializerSettings.Converters.Add(new IsoDateTimeConverter());

            config.Formatters[0] = new JsonNetFormatter(serializerSettings);

            // Create server

            var server = new HttpSelfHostServer(config);

            // Start listening

            server.OpenAsync().Wait();

            Console.ReadLine();

to test the application open Fiddler and create a request as below:

basically you need to set the address to http://localhost:8081/Home and content-type to Content-Type: application/json; charset=utf-8. once you create the request click on execute and you should be getting the following response back

as you see we get Json representation of the CarInfo object.

it was quit simple, wasn’t it?

Make a call to a JSON/XML ASP.Net WEB API from server code

Mon, 12 Mar 2012 02:21:54 GMT

There is plenty of articles out there on how to make a ajax call to a asp.net web api service. but what if you want to make a call to the same service from a server code? this can happen because of various reasons like when you want to offer a service and use IP validation.

anyway this is quite simple to call a service exposed by ASP.net WEB API either using JSON or XML. and it is like calling a WCF or XML web service from a server side code without adding a reference to the service.

Lets assume that our ASP.net WEB API provide a service to and and return flights using a given FlightSearchRequest object.

FlightSearchRequest

 1:     public class FlightSearchRequest

 2:     {

 3:         public string DepartureAirportCode { get; set; }

4:

 5:         public string ArrivalAirportCode { get; set; }

 6:     }

WEB API Method

 1:         [HttpPost]

 2:         public IEnumerable<Flight> GetFlights(FlightSearchRequest flightRequest)

 3:         {

4:

 5:             return new List<Flight>

 6:                 {

 7:                     new Flight { Id=1, AirlineCode = "EK", Price = 350 },

 8:                     new Flight { Id=2, AirlineCode = "LX", Price = 280 },

 9:                 };

 10:         }

and here is the code to call the service:

Using JSON

 1:             HttpWebRequest request;

 2:             HttpWebResponse hwResponse;

 3:             string url = "http://127.0.0.1:26030/api/MyAPI/GetFlights";

 4:             string responseBody = string.Empty;

 5:             string requestBody =

			"[{\"DepartureAirportCode\":\"MEL\",\"ArrivalAirportCode\":\"LHR\"}]";

6:

 7:                 byte[] byteData = UTF8Encoding.UTF8.GetBytes(requestBody.ToString());

 8:                 request = (HttpWebRequest)HttpWebRequest.Create(url);

 9:                 request.ContentType = "application/json;charset=utf-8";

 10:                 request.UserAgent =

	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; BOIE9;ENUS)";

 11:                 request.Accept = "*/*";

 12:                 request.Method = "POST";

 13:                 request.ContentLength = byteData.Length;

14:

 15:                 // Write data

 16:                 using (Stream postStream = request.GetRequestStream())

 17:                 {

 18:                     postStream.Write(byteData, 0, byteData.Length);

 19:                 }

20:

 21:                 // Get response

 22:                 using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)

 23:                 {

 24:                     // Get the response stream

 25:                     using (var reader = new StreamReader(response.GetResponseStream()))

 26:                     {

 27:                         responseBody = reader.ReadToEnd();

 28:                     }

 29:                 }

to make the same call using XML you just need to change the ContentType to application/xml and also change the request body to an xml format

Using XML

 1:             HttpWebRequest request;

 2:             HttpWebResponse hwResponse;

 3:             string url = "http://127.0.0.1:26030/api/MyAPI/GetFlights";

 4:             string responseBody = string.Empty;

 5:             string requestBody =

				"<Product><Id>6</Id><Name>Jackson</Name></Product>";

 6:                 byte[] byteData = UTF8Encoding.UTF8.GetBytes(requestBody.ToString());

 7:                 request = (HttpWebRequest)HttpWebRequest.Create(url);

 8:                 request.ContentType = "application/xml;charset=utf-8";

 9:                 request.UserAgent =

	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; BOIE9;ENUS)";

 10:                 request.Accept = "*/*";

 11:                 request.Method = "POST";

 12:                 request.ContentLength = byteData.Length;

13:

 14:                 // Write data

 15:                 using (Stream postStream = request.GetRequestStream())

 16:                 {

 17:                     postStream.Write(byteData, 0, byteData.Length);

 18:                 }

19:

 20:                 // Get response

 21:                 using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)

 22:                 {

 23:                     // Get the response stream

 24:                     using (var reader = new StreamReader(response.GetResponseStream()))

 25:                     {

 26:                         responseBody = reader.ReadToEnd();

 27:                     }

 28:                 }

now the more I play with WEP API the more I like it

ASP.Net WEB API VS WCF Service

Sun, 11 Mar 2012 12:00:42 GMT

Well as soon as i heard and read about asp.net web api, i was very excited about it but in between i had that mmmmm moment. i was like, this is great but what about WCF? I am not going to create any WCF services anymore?

so I had think again about it but could not find any concrete answer as these two are overlapping in many areas. so I had to do a bit more R&D about the differences and I came across this blog post from Matt Milner.

the post has got very fair point on when to use WCF services and when to use ASP.net web api. but in nutshell I think for most of our feature service development for web –over http-, we are going to use ASP.net web api and it kind of make sense as it’s much easier to setup and use.

here is blog post address:

http://mattmilner.com/Milner/Blog/post/2012/02/28/WebAPI-or-WCF.aspx

ASP.NET Web API

Thu, 08 Mar 2012 12:11:53 GMT

I am a huge fan of Ajax. If you want to create a great experience for the users of your website – regardless of whether you are building an ASP.NET MVC or an ASP.NET Web Forms site — then you need to use Ajax. Otherwise, you are just being cruel to your customers.

Most of the new websites expose data from the server as JSON and use jQuery to retrieve and update that data from the browser.

One challenge, when building an ASP.NET website, is deciding on which technology to use to expose JSON data from the server. For example, how do you expose a list of products from the server as JSON so you can retrieve the list of products with jQuery? You have a number of options (too many options) including ASMX Web services, WCF Web Services, ASHX Generic Handlers, WCF Data Services, and MVC controller actions.

With the release of ASP.NET 4 Beta, Microsoft has introduced a new technology for exposing JSON from the server named the ASP.NET Web API. You can use the ASP.NET Web API with both ASP.NET MVC and ASP.NET Web Forms applications.

Create a Web API Controller

to create a new web API controller you just need to select template as API Controller

this would create a class with default empty methods to get you started.

to test this lets create a new class called Product to send data back to JavaScript:

   1:      public class Product

   2:      {

   3:          public int Id { get; set; }

4:

   5:          public string Name { get; set; }

6:

   7:      }

and let’s update the controller method as below for testing:

   1:      public class MyAPIController : ApiController

   2:      {

   3:          // GET /api/myapi

   4:          public IEnumerable<Product> Get()

   5:          {

   6:              return new List<Product>

   7:                  {

   8:                      new Product { Id = 1, Name = "Product1" },

   9:                      new Product { Id = 2, Name = "Product2" },

  10:                  };

  11:          }

12:

  13:          // GET /api/myapi/5

  14:          public Product Get(int id)

  15:          {

  16:              return new Product { Id = 3, Name = "Product3" };

  17:          }

18:

  19:          // POST /api/myapi

  20:          public HttpResponseMessage<Product> Post(Product newProduct)

  21:          {

  22:              newProduct.Id = 23;

  23:              var response = new HttpResponseMessage<Product>(newProduct, HttpStatusCode.Created);

  24:              var relativePath = "/api/movie/" + newProduct.Id;

  25:              response.Headers.Location = new Uri(Request.RequestUri, relativePath);

  26:              return response;

  27:          }

28:

  29:          // PUT /api/myapi/5

  30:          public void Put(int id, Product productToUpdate)

  31:          {

  32:              if (productToUpdate.Id == 1)

  33:              {

  34:                  // Update the movie in the database

  35:                  return;

  36:              }

  37:              // If you can't find the movie to update

  38:              throw new HttpResponseException(HttpStatusCode.NotFound);

  39:          }

40:

  41:          // DELETE /api/myapi/5

  42:          public HttpResponseMessage Delete(int id)

  43:          {

  44:              // Delete the movie from the database     // Return status code

  45:              return new HttpResponseMessage(HttpStatusCode.NoContent);

  46:          }

  47:      }

To use this ASP.net creates the following route in the global.asax

   1:              routes.MapHttpRoute(

   2:                  name: "DefaultApi",

   3:                  routeTemplate: "api/{controller}/{id}",

   4:                  defaults: new { id = RouteParameter.Optional }

   5:              );

and let’s start using the Controller:

Get Single Product

To invoke the Get functions from JavaScript using JQuery you do the following:

   1:  <!DOCTYPE html>

   2:  <html xmlns="http://www.w3.org/1999/xhtml">

   3:  <head>

   4:      <title>Get product</title>

   5:  </head>

   6:  <body>

   7:      <div>

   8:          Title: <span id="Id"></span>

   9:      </div>

  10:      <div>

  11:          Director: <span id="Name"></span>

  12:      </div>

  13:      <script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script>

  14:      <script type="text/javascript">

  15:          getProduct(1, function (product) {

  16:              $("#Id").html(product.Id);

  17:              $("#Name").html(product.Name);

  18:          });

19:

  20:          function getProduct(id, callback) {

  21:              $.ajax({ url: "/api/MyAPI", data: { Id: id }

  22:           , type: "GET",

  23:                  contentType: "application/json;charset=utf-8",

  24:                  statusCode:

  25:           {

  26:               200: function (product) { callback(product); },

  27:               404: function () { alert("Not Found!"); }

  28:           }

  29:              });

  30:          }

  31:      </script>

  32:  </body>

  33:  </html>

Get Multiple Products

   1:  <!DOCTYPE html>

   2:  <html xmlns="http://www.w3.org/1999/xhtml">

   3:  <head>

   4:      <title>Get product</title>

   5:  </head>

   6:  <body>

   7:      <div>

   8:          <span id="Products"></span>

   9:      </div>

  10:      <script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script>

  11:      <script type="text/javascript">

12:

  13:          getProducts(function (products) {

  14:              var strproducts = "";

  15:              $.each(products, function (index, product) {

  16:                  strproducts += "<div>" + product.Name + "</div>";

  17:              });

  18:              $("#Products").html(strproducts);

  19:          });

  20:               function getProducts(callback) {

  21:               $.ajax(

  22:               {

  23:                  url: "/api/MyAPI/",

  24:                  data: {},

  25:                  type: "GET",

  26:                  contentType: "application/json;charset=utf-8",

  27:               }).then(function(products){

  28:                  callback(products);

  29:               });

  30:               }

  31:      </script>

  32:  </body>

  33:  </html>

Insert a new Product

   1:  <!DOCTYPE html>

   2:  <html xmlns="http://www.w3.org/1999/xhtml">

   3:  <head>

   4:      <title>Create product</title>

   5:  </head>

   6:  <body>

   7:      <script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script>

   8:      <script type="text/javascript">

   9:          var productToCreate = {Id: "4", Name: "Product4" };

10:

  11:          createproduct(productToCreate, function (newproduct) {

  12:              alert("New product created with an Id of " + newproduct.Id);

  13:          });

14:

  15:          function createproduct(productToCreate, callback) {

  16:              $.ajax({

  17:                  url: "/api/MyAPI",

  18:                  data: JSON.stringify(productToCreate),

  19:                  type: "POST",

  20:                  contentType: "application/json;charset=utf-8",

  21:                  statusCode: {

  22:                      201: function (newproduct) {

  23:                          callback(newproduct);

  24:                      }

  25:                  }

  26:              });

  27:          }

  28:      </script>

  29:  </body>

  30:  </html>

Update a Product

   1:  <!DOCTYPE html>

   2:  <html xmlns="http://www.w3.org/1999/xhtml">

   3:  <head>

   4:      <title>Put product</title>

   5:  </head>

   6:  <body>

   7:      <script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script>

   8:      <script type="text/javascript">

   9:          var productToUpdate = { id: 1, title: "Product5" };

  10:          updateproduct(productToUpdate, function () {

  11:              alert("product updated!");

  12:          });

  13:          function updateproduct(productToUpdate, callback) {

  14:              $.ajax({

  15:                  url: "/api/MyAPI",

  16:                  data: JSON.stringify(productToUpdate),

  17:                  type: "PUT",

  18:                  contentType: "application/json;charset=utf-8",

  19:                  statusCode: {

  20:                      200: function () {

  21:                          callback();

  22:                      },

  23:                      404: function () {

  24:                          alert("product not found!");

  25:                      }

  26:                  }

  27:              });

  28:          }

  29:      </script>

  30:  </body>

  31:  </html>

Delete a Product

   1:  <!DOCTYPE html>

   2:  <html xmlns="http://www.w3.org/1999/xhtml">

   3:  <head>

   4:      <title>Delete product</title>

   5:  </head>

   6:  <body>

   7:      <script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script>

   8:      <script type="text/javascript">

   9:          deleteproduct(1, function () {

  10:              alert("product deleted!");

  11:          });

  12:          function deleteproduct(id, callback) {

  13:              $.ajax({

  14:                  url: "/api/MyAPI",

  15:                  data: JSON.stringify({ Id: id }),

  16:                  type: "DELETE",

  17:                  contentType: "application/json;charset=utf-8",

  18:                  statusCode: {

  19:                      204: function () {

  20:                          callback();

  21:                      }

  22:                  }

  23:              });

  24:          }

  25:      </script>

  26:  </body>

  27:  </html>

having a quick look at the above sample, you’ll definitely agree that it’s quite simple to expose services through ASP.NET Web API. I am personally very excited about this

ASP.Net Page Lifecycle Events

Wed, 07 Mar 2012 13:09:00 GMT

We all know a asp.net page events, but do we exactly know the orders? and what each event is good for?

well I am putting this list together to talk about the events.

PreInit
use this event to:
- Set a master page dynamically.
- Set the Theme property dynamically.
- Read or set profile property values.
Init
Use this event to read or initialize control properties
InitComplete
Use this event to make changes to view state that you want to make sure are persisted after the next postback.
LoadState
ProcessPostData
PreLoad
Load
LoadComplete
PreRender
if you have got custom controls on your page and you want to manupulate the final page output based on some values in a custom control, you need to put your logic in this event.
SaveState
Any changes to the page or controls at this point affect rendering, but the changes will not be retrieved on the next postback.
Render