ASP.NET

Routing in WebAPI is very similar to routing in MVC. In MVC application routing maps a URL to action methods in Controller.Similarly in WebAPI routing is used to map a URL to action method in Controller.

In a WebAPI project routing is defined in the file WebApiConfig.cs in the App_Start folder.By default following route is defined in the WebApiConfig file

public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}

There are few important things to note in the WebApiConfig file

1.It imports the System.Web.Http namespace instead of using System.Web.Mvc unlike RouteConfig class in MVC

using System.Web.Http

2.It uses the MapHttpRoute method for adding the routes to the routing table.It is MapRoute method in MVC.

config.Routes.MapHttpRoute()

3.Route template does not include the action method name as in the case of MVC.

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

Instead of declaring action method name as a segment variable the action method is selected based on the HTTP method used to make the request.Though we can also include the action method name in a route if required as:

api/{controller}/{action}/{id}

In this case action method is explicitly specified and the route will map to URLs which includes action method name in URL.

4.Route template has api prefix.This is to distinguish WebAPI URL from the MVC URL.

Follow on:

In a client server communication client sends a request to a server and server responds with some response message.In this communication the request and response have a specific format.Response returned by the server has the following format
Status denotes the success or failure
Header additional information about the response
Message-body actual response

WebAPI return types

HTTP service we develop using WebAPI can return different types of information.WebAPI can return the following types

• Simple or complex types  Inbuilt types or types which we define such as class
• No return type or void   No value is returned
• HTTPResponseMessage  Gives more control over the returned value
• IHTTPAction in WebAPI2  A way of creating HTTPResponseMessage

HTTPResponseMessage in WebAPI

HTTPResponseMessage in WebAPI is one of the types which can be returned from an action method.We can use this type to set the different response values.We can use it to set the response values such as Headers  and status code.

Use of HTTPResponseMessage

If we can directly return a specific data type from a WebAPI action method then what is the need of using HTTPResponseMessage.Though we can directly data from a WebAPI action method as:

public Student Get(int id)
{
return StudentRepository.GetById(id);
}

The above method will return a data type of Student type with status of success.The value of Student type is passed in the message body.

So if we directly return a specific data type from a method then we don’t have much control over the other values in the http response such as status code and header values.

If we use HTTPResponse message then we can set the response values such as Header values and status code.

How to use HTTPResponseMessage

We can return HTTPResponseMessage from action method using the CreateResponse extension method.This method is defined in the System.Net.Http.Formatting namespace.We need to add the reference to System.Net.Http.Formatting.dll assembly to use this method.

So we can return the student object using HTTPResponseMessage object using CreateResponse method as:

 Request.CreateResponse<Student>(HttpStatusCode.OK, student);

Some of the useful properties defined by the HTTPResponseMessage class are:

Content        For retrieving or setting HTTP response message.
Headers        For retrieving HTTP response headers.
RequestMessage   For retrieving the request message for the current response.
StatusCode    For retrieving or setting the status code of the HTTP response.
Version    For retrieving or setting the HTTP message version.

So HTTPResponseMessage return type gives more control over the response returned to the client.We can use the properties defined by this type to set the different response values.

We can also create an instance of HttpResponseMessage as:

var response = new HttpResponseMessage(HttpStatusCode.OK);

We can use the HttpResponseException type to return exceptions from action methods.We can use this type to return status codes corresponding to the exceptions.

We can return HttpResponseException as:

Request.CreateErrorResponse(HttpStatusCode.BadRequest, CustomError);
{
"Message": "The request has error",
"ErrorCode": 40
}

 

 

Follow on:

WebAPI is a framework used for developing HTTP services.

Like MVC application WebAPI also uses controller and action methods to handle the requests.Similar to MVC WebAPI also supports concepts such as:

• Controllers and action methods
• Routing
• Filters
• Model Binding

But it differs from MVC

Unlike MVC application WebAPI application can not return views

Unlike MVC WebAPI controllers are derived from APIController instead of Controller base class.

Whenever  a request is received it is mapped to the action method in controller in following manner

1.If the action method has specified any HTTP method attribute such as [HTTGET] ,[HTTPPOST] then the action method handles that HTTP verb.For example the following action method will handle the get request.

2.If the action method name starts with the name of any verb then that action method will handle that specific request.The below action method will handle the request for GET.

public IEnumerable<Employee> GetAll()
{
return EmployeeList;
}

Following will also handle the Get request

public Employee Get(int id)
{
Employee e = EmployeeList.Where(x => x.Id == id).FirstOrDefault();
return e;
}

3.If none of the above are specified then the action method handles POST request by default.

Follow on:

When a request is received by the web server or IIS , the request is sent to the worker process.Worker process initializes ASP.NET runtime which handles the request.Request flows through a well defined pipeline to generate the response.

Following are the main components of the HTTP Request pipeline

• HttpModules
• HttpHandler

HttpModule is implemented as a class which has access to both the request and response.It handles the request lifecycle events and can modify the request or the response information.There can be multiple HttpModules for a request.

The events that Modules handle can also be handled in the global application class.For understanding the use of global application class ,please refer  global application class.

Using Module to handle the request events has the following advantages.

• Module can be created once and used across different applications.
• Modules allow to keep the even handling logic separate from the application class.This results in better segregation of code.

HttpModule implements the interface IHttpModule.This interface provides the following methods

• Init(HttpApplication)   This method is used to register the event handlers.
• Dispose()   Disposes the resources which are used by the module.

Following are the steps to implement a custom HttpHandler

• Implement a class which implements the IHttpModule interface.
• Implement the Init method in the class.This method should subscribe to events we need For example, we can subscribe EndRequest event.
• Write the custom logic for the event handler we subscribed to in step 2.
• Finally we register the module in the Web.config file.

public class ICustomModule : IHttpModule
{
public void Dispose()
{

}

public void Init(HttpApplication context)
{
context.EndRequest += new EventHandler(context_EndRequest);
}

void context_EndRequest(object sender, EventArgs e)
{
//modify the response
}

}

HttpHandler is a class which ultimately receives the request and generates the response.There can be only one HttpHandler for a request.There are handlers which are provided by the framework such as the page handler which generates the response for .aspx pages. HttpHandler implements the IHttpHandler interface.This interface provides the following members

ProcessRequest  Method which generates the response for the request
IsReusable  Property which specifies if the handler can be reused.

Some of the inbuilt handlers provided by ASP.NET are

ASP.NET page handler   HTTP handler for ASP.NET (*.aspx)  pages .
Web service handler          HTTP handler for  web services (*.asmx)

Following are the steps to implement a custom HttpHandler

• Implement a class which implements the IHttpHandler interface.
• Implement the ProcessRequest method in the class.This method should generate the response.
• Implement IsReusable boolean property to specify if the HttpHandler can be reused.
• Finally we register the Handler in the Web.config file.

public class ICustomHandler :IHttpHandler
{
public bool IsReusable
{
get { return false; }
}

public void ProcessRequest(HttpContext context)
{

}
}

In web.config

<httpHandlers>
<add verb="*" path="*.cst" type="ICustomHandler"/>
</httpHandlers>

 

Follow on: