Asp.net web api extensibility

ASP.NET Web API
Extensibility

Eyal Vardi
CEO E4D Solutions LTD
Microsoft MVP Visual C#
blog: www.eVardi.com

Expert Days 2012


© 2010 E4D LTD. All rights reserved. Tel: 054-5-767-300, Email: Eyal@E4D.co.il

Agenda


Web API Configuration


Configuring ASP.NET Web API
 Global Configuration Settings (ASP.NET Hosting)
 Global Configuration Settings (Self-Hosting)
 Services
 Per-Controller Configuration


Global Configuration Settings
(ASP.NET Hosting)

 Stored in the GlobalConfiguration object,
which is contains a singleton
HttpConfiguration instance.


HttpConfiguration
Member Description

DependencyResolver Enables dependency injection for controllers.

Filters Action filters.
Formatters Media-type formatters.

Specifies whether the server should include error details, such as
IncludeErrorDetailPolicy
exception messages and stack traces, in HTTP response messages.

Initializer A function that performs final initialization of the HttpConfiguration.

MessageHandlers HTTP message handlers.

ParameterBindingRules A collection of rules for binding parameters on controller actions.

Properties A generic property bag.

Routes The collection of routes
Services The collection of services.


WebApiConfig
 The call to WebApiConfig.Register configures
Web API. The definition for the WebApiConfig
class is located in the App_Start directory.


Global Configuration Settings
(Self-Hosting)
 If you self-host Web API, the configuration
settings are stored in the
HttpSelfHostConfiguration class, which
derives from HttpConfiguration.

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

// Add a route
config.Routes.MapHttpRoute(
"API Default",
"api/{controller}/{id}",
new { id = RouteParameter.Optional });

// Add a media-type formatter
config.Formatters.Add(new MyFormatter());


Services
 The HttpConfiguration.Services collection
contains a set of global services that Web API
uses to perform various tasks.
 Controller selection (IHttpControllerSelector)
 Content negotiation (IContentNegotiator)
 IActionValueBinder
 IApiExplorer
 IAssembliesResolver
 IBodyModelValidator
 IDocumentationProvider
 IHttpActionInvoker
 IHttpControllerTypeResolver
 ITraceManager & ITraceWriter
 …

Per-Controller Configuration
 You can override per controller
 Media-type formatters
 Parameter binding rules
 Services

public class ControllerConfigAttribute : Attribute, IControllerConfiguration
{
public void Initialize(HttpControllerSettings settings,
HttpControllerDescriptor descriptor)
{
// Remove the JSON formatter.
var jsonFormatter = settings.Formatters.JsonFormatter;
settings.Formatters.Remove(jsonFormatter);

// Add a custom media-type formatter.
settings.Formatters.Add(new MyFormatter());

// Add a custom action selector.
settings.Services.Replace(typeof(IHttpActionSelector), new MyActionSelector());
}
}


Routing


Routing Tables
routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
constraints: new { id = @"d+" }

);

Action HTTP method Relative URI
Get a list of all products GET /api/products
Get a product by ID GET /api/products/id

Get a product by category GET /api/products?category=1


Selecting a Controller
 Controller selection is handled by the
IHttpControllerSelector.SelectController
method.
 This method takes an HttpRequestMessage
instance and returns an HttpControllerDescriptor.
 The default implementation is provided by the
DefaultHttpControllerSelector class.
1. Look in the route dictionary for the key "controller".

2. Take the value for this key and append the string "Controller"
to get the controller type name.

3. Look for a Web API controller with this type name.


 For step 3, DefaultHttpControllerSelector uses
the IHttpControllerTypeResolver interface to
get the list of Web API controller types.

 The default implementation of
IHttpControllerTypeResolver returns all public
classes that:
 Implement IHttpController,
 Not abstract
 Have a name that ends in "Controller".


Action Selection
 Action selection done by calling the
IHttpActionSelector.SelectAction
method.


Action Selection
 The default implementation is provided by the
ApiControllerActionSelector class. To select
an action, it looks at the following:
 The HTTP method of the request.

 The "{action}" placeholder in the route template, if present.

 The parameters of the actions on the controller.


Action Selection Algorithm
1. Create a list of all actions on the controller that match
the HTTP request method.
2. If the route dictionary has an "action" entry, remove
actions whose name does not match this value.
3. Try to match action parameters to the URI, as follows:
1. For each action, get a list of the parameters that are a simple type,
where the binding gets the parameter from the URI. Exclude
optional parameters.
2. From this list, try to find a match for each parameter name, either in
the route dictionary or in the URI query string. Matches are case
insensitive and do not depend on the parameter order.
3. Select an action where every parameter in the list has a match in the
URI.
4. If more that one action meets these criteria, pick the one with the
most parameter matches.
4. Ignore actions with the [NonAction] attribute.

Action Selection


HTTP Message Handlers


HTTP Message Handlers
 HttpRequestMessage
represents the HTTP request.

 HttpResponseMessage
represents the HTTP response.

 HttpMessageHandler
objects process the request and response


Client


Server
 HttpServer derives from HttpMessageHandler.
 The request then passes through a series of message
handlers.

 HttpControllerDispatcher handler uses the
routing table to route the request to a Web API
controller.


HTTP Request in Memory
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"default",
"api/{controller}/{id}",
new { id = RouteParameter.Optional });

HttpServer server = new HttpServer(config);

// Connect client directly to server
HttpClient client = new HttpClient(server);

var response = client.GetAsync("http://anything/api/products").Result;


Custom Message Handlers
 Process the request message.
 Call base.SendAsync to send the message to
the inner handler. This step is asynchronous.
 Process the response message and return it
to the caller.

Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken);


Custom Response Header
public class CustomHeaderHandler : DelegatingHandler
{
protected override Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken cancellationToken)
{
return base.SendAsync(request, cancellationToken)
.ContinueWith(
(task) =>
{
HttpResponseMessage response = task.Result;
response.Headers.Add(
"X-Custom-Header",
"This is my custom header.");
return response;
}
);
}
}


Custom Message
Handlers


Formats & Model Binding


Internet Media Types
 A media type, also called a MIME type.
 Identifies the format of a piece of data.
 Describe the format of the message body.
 A media type consists of two strings, a type and a subtype.
For example:
 text/html
 image/png
 application/json

HTTP/1.1 200 OK
Content-Length: 95267
Content-Type: image/png
Accept: text/html,application/xhtml+xml


Media Formatter
 In Web API, the media type determines how
Web API serializes and deserializes the HTTP
message body.


Custom Media
Formatter


Exceptions


Exception Handling
 By default, most exceptions are translated into an
HTTP response with status code 500, Internal Server
Error.
 For example, the following method returns 404, Not
Found, if the id parameter is not valid.

public Product GetProduct(int id)
{
Product item = repository.Get(id);
if (item == null)
{
throw new HttpResponseException(
new HttpResponseMessage( HttpStatusCode.NotFound ));
}
return item;
}


Exception Filters
 An exception filter is executed when a
controller method throws any unhandled
exception that is not an HttpResponseException
exception.
NotImplementedException exceptions into HTTP status code 501, Not Implemented.
public class NotImplExceptionFilter : ExceptionFilterAttribute
{
public override void OnException(HttpActionExecutedContext context)
{
if (context.Exception is NotImplementedException)
{
context.Response =
new HttpResponseMessage(HttpStatusCode.NotImplemented);
}
}
}


Exception Filters


Asp.net web api extensibility

Recommended

Recommended

More Related Content

Similar to Asp.net web api extensibility

Similar to Asp.net web api extensibility (20)

More from Eyal Vardi

More from Eyal Vardi (20)

Recently uploaded

Recently uploaded (20)

Asp.net web api extensibility

Editor's Notes