Contents tagged with ASP.net

  • Using Unity with ASP.NET WEB API Controller

    518 comments

    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.

    Written by vahid

    Saturday, April 14, 2012 at 5:40 PM

    Tagged with , ,

  • Hosting ASP.NET WEB API

    307 comments

    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.

    image

     

    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:

    image

    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

    image

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

    it was quit simple, wasn’t it?

    Written by vahid

    Sunday, March 18, 2012 at 4:26 AM

    Tagged with ,

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

    913 comments

    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 Smile

    Written by vahid

    Sunday, March 11, 2012 at 7:25 PM

    Tagged with ,

  • ASP.Net WEB API VS WCF Service

    343 comments

    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

    Written by vahid

    Sunday, March 11, 2012 at 5:00 AM

    Tagged with , ,

  • ASP.NET Web API

    231 comments

    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

    image

    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 Smile

     

    Written by vahid

    Thursday, March 8, 2012 at 4:11 AM

    Tagged with

  • ASP.Net Page Lifecycle Events

    163 comments

    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

    Written by vahid

    Wednesday, March 7, 2012 at 5:10 AM

    Tagged with