Batch in Web API<\/h3>\n
In order to start using batch in Web API, the only requirement is to register a route with a batch handler. Let\u2019s start by creating the server. For this sample we will be using the brand new OWIN host for Web API. The code below creates the server and configures a web API route and a batch route.<\/p>\n
static<\/span> void<\/span> Main(string<\/span>[] args)\r\n{\r\n string<\/span> serviceUrl = "http:\/\/localhost:12345"<\/span>;\r\n using<\/span> (WebApp.Start(serviceUrl, Configuration))\r\n {\r\n\r\n Console.WriteLine("Service listening at {0}"<\/span>, serviceUrl);\r\n Console.WriteLine("Press any key to stop the service and exit the application"<\/span>);\r\n Console.ReadKey();\r\n }\r\n}\r\n\r\nprivate<\/span> static<\/span> void<\/span> Configuration(IAppBuilder builder)\r\n{\r\n HttpConfiguration configuration = new<\/span> HttpConfiguration();\r\n HttpServer server = new<\/span> HttpServer(configuration);\r\n configuration.Routes.MapHttpBatchRoute(\r\n routeName:"batch"<\/span>,\r\n routeTemplate:"api\/batch"<\/span>,\r\n batchHandler:new<\/span> DefaultHttpBatchHandler(server));\r\n configuration.Routes.MapHttpRoute("api"<\/span>, "api\/{controller}\/{id}"<\/span>, new<\/span> { id = RouteParameter.Optional });\r\n builder.UseWebApi(server);\r\n}\r\n<\/pre>\nIf we look in detail to the code in the Configuration method, we can see the following method call is the only thing required to enable batching in your Web API service:<\/p>\n
configuration.Routes.MapHttpBatchRoute(\r\n routeName:"batch"<\/span>,\r\n routeTemplate:"api\/batch"<\/span>,\r\n batchHandler:new<\/span> DefaultHttpBatchHandler(server));\r\n<\/pre>\nThe important things to notice are the following:<\/p>\n
\n- The DefaultHttpBatchHandler requires an instance of an HttpServer to work. We can create this instance ourselves in the self-host scenario or we can get it by accessing it from GlobalConfiguration.DefaultServer.<\/li>\n
- The DefaultHttpBatchHandler executes each request sequentially, but in case you don\u2019t have any dependency between requests, you can set a property to make execution non-sequential.<\/li>\n
- The MapHttpBatchRoute route template can contain parameters. So, in case you create your own batch handler, you can pass in parameters to it.<\/li>\n<\/ul>\n
That\u2019s all that is required to enable batch in your service. Let\u2019s see how to send batch requests and read batch responses using HttpClient. In order to do that, we are going to need a model, a web API controller and a route to dispatch the incoming requests. We will be using Entity Framework as the backend and AutoFixture to generate some sample data for the service. Here is the code for all of it:<\/p>\n
Route:<\/p>\n
configuration.Routes.MapHttpRoute(\r\n name: "api"<\/span>,\r\n routeTemplate: "api\/{controller}\/{id}"<\/span>,\r\n defaults: new<\/span> { id = RouteParameter.Optional });\r\n<\/pre>\nModel:<\/p>\n
public<\/span> class<\/span> Customer\r\n{\r\n public<\/span> int<\/span> Id { get; set; }\r\n public<\/span> string<\/span> Name { get; set; }\r\n}\r\n<\/pre>\nController:<\/p>\n
public<\/span> class<\/span> WebCustomersController : ApiController\r\n{\r\n CustomersContext context = new<\/span> CustomersContext();\r\n [Queryable(PageSize = 10, MaxExpansionDepth = 2)]\r\n public<\/span> IHttpActionResult Get()\r\n {\r\n return<\/span> Ok(context.Customers);\r\n }\r\n\r\n public<\/span> async Task<IHttpActionResult> Post([FromBody] Customer entity)\r\n {\r\n if<\/span> (entity == null<\/span>)\r\n {\r\n return<\/span> BadRequest(ModelState);\r\n }\r\n context.Customers.Add(entity);\r\n await context.SaveChangesAsync();\r\n return<\/span> CreatedAtRoute("api"<\/span>, new<\/span> { controller = "ApiCustomers"<\/span> }, entity);\r\n }\r\n\r\n public<\/span> async Task<IHttpActionResult> Put(int<\/span> id, [FromBody] Customer entity)\r\n {\r\n if<\/span> (entity == null<\/span>)\r\n {\r\n return<\/span> BadRequest(ModelState);\r\n }\r\n else<\/span> if<\/span> (id != entity.Id)\r\n {\r\n return<\/span> BadRequest("The key from the url must match the key of the entity in the body"<\/span>);\r\n }\r\n var originalCustomer = await context.Customers.FindAsync(id);\r\n if<\/span> (originalCustomer == null<\/span>)\r\n {\r\n return<\/span> NotFound();\r\n }\r\n else<\/span>\r\n {\r\n context.Entry(originalCustomer).CurrentValues.SetValues(entity);\r\n await context.SaveChangesAsync();\r\n }\r\n return<\/span> Content(HttpStatusCode.OK, entity);\r\n }\r\n\r\n public<\/span> async Task<IHttpActionResult> Delete(int<\/span> id)\r\n {\r\n Customer entity = await context.Customers.FindAsync(id);\r\n if<\/span> (entity == null<\/span>)\r\n {\r\n return<\/span> NotFound();\r\n }\r\n else<\/span>\r\n {\r\n context.Customers.Remove(entity);\r\n await context.SaveChangesAsync();\r\n return<\/span> StatusCode(HttpStatusCode.NoContent);\r\n }\r\n }\r\n}<\/pre>\nEntity framework context:<\/p>\n
public<\/span> class<\/span> CustomersContext : DbContext\r\n{\r\n static<\/span> CustomersContext()\r\n {\r\n Database.SetInitializer<CustomersContext>(new<\/span> CustomersContextInitializer());\r\n }\r\n\r\n protected<\/span> override<\/span> void<\/span> OnModelCreating(DbModelBuilder modelBuilder)\r\n {\r\n base<\/span>.OnModelCreating(modelBuilder);\r\n }\r\n\r\n private<\/span> class<\/span> CustomersContextInitializer : DropCreateDatabaseAlways<CustomersContext>\r\n {\r\n protected<\/span> override<\/span> void<\/span> Seed(CustomersContext context)\r\n {\r\n Fixture fixture = new<\/span> Fixture();\r\n IEnumerable<Customer> customers = fixture.CreateMany<Customer>(20).ToList();\r\n context.Customers.AddRange(customers);\r\n }\r\n }\r\n\r\n public<\/span> DbSet<Customer> Customers { get; set; }\r\n}\r\n<\/pre>\nNow that we have a running service with some data on it, and we have enabled batching support, we can move on to actually perform batch requests. The default Web API batch implementation is based on the mime\/multipart content type. It accepts mime\/multipart requests containing multiple HTTP Requests and processes all the requests sending a mime\/multipart response containing the individual responses. Let\u2019s start by creating some requests:<\/p>\n
Fixture fixture = new<\/span> Fixture();\r\nHttpClient client = new<\/span> HttpClient();\r\ndynamic listOfCustomers = JToken.Parse(await client.GetStringAsync("http:\/\/localhost:12345\/api\/WebCustomers"<\/span>));\r\ndynamic firstCustomer = listOfCustomers[0];\r\nfirstCustomer.Name = "Peter"<\/span>;\r\ndynamic secondCustomer = listOfCustomers[1];\r\nJsonMediaTypeFormatter formatter = new<\/span> JsonMediaTypeFormatter();\r\n\r\n\/\/Create a request to query for customers<\/span>\r\nHttpRequestMessage queryCustomers = new<\/span> HttpRequestMessage(HttpMethod.Get, "http:\/\/localhost:13245\/api\/WebCustomers"<\/span>);\r\n\/\/Create a message to add a customer<\/span>\r\nHttpRequestMessage addCustomer = new<\/span> HttpRequestMessage(HttpMethod.Post, "http:\/\/localhost:13245\/api\/WebCustomers"<\/span>);\r\naddCustomer.Content = new<\/span> ObjectContent<Customer>(fixture.Create<Customer>(), formatter);\r\n\/\/Create a message to update a customer<\/span>\r\nHttpRequestMessage updateCustomer = new<\/span> HttpRequestMessage(HttpMethod.Put, string<\/span>.Format("http:\/\/localhost:13245\/api\/WebCustomers\/{0}"<\/span>, firstCustomer.Id));\r\nupdateCustomer.Content = new<\/span> ObjectContent<dynamic>(firstCustomer, formatter);\r\n\/\/Create a message to remove a customer.<\/span>\r\nHttpRequestMessage removeCustomer = new<\/span> HttpRequestMessage(HttpMethod.Delete, string<\/span>.Format("http:\/\/localhost:13245\/api\/WebCustomers\/{0}"<\/span>, secondCustomer.Id));<\/pre>\nThe first block before the blank line only performs a query to get some customers that we can update and delete in a request later. At this point, we could just send four requests using HttpClient, and our service would just process the requests and send individual responses back.<\/p>\n
In order to batch those requests together into a single HTTP request, we need to encapsulate them into HttpMessageContent instances and add those instances to a MultipartContent instance. Here is the code to do that:<\/p>\n
\/\/Create the different parts of the multipart content<\/span>\r\nHttpMessageContent queryContent = new<\/span> HttpMessageContent(queryCustomers);\r\nHttpMessageContent addCustomerContent = new<\/span> HttpMessageContent(addCustomer);\r\nHttpMessageContent updateCustomerContent = new<\/span> HttpMessageContent(updateCustomer);\r\nHttpMessageContent removeCustomerContent = new<\/span> HttpMessageContent(removeCustomer);\r\n\r\n\/\/Create the multipart\/mixed message content<\/span>\r\nMultipartContent content = new<\/span> MultipartContent("mixed"<\/span>, "batch_"<\/span> + Guid.NewGuid().ToString());\r\ncontent.Add(queryContent);\r\ncontent.Add(addCustomerContent);\r\ncontent.Add(updateCustomerContent);\r\ncontent.Add(removeCustomerContent);<\/pre>\nIf you look at the code above, the multipart content needs to have a subtype of mixed, and a boundary which is a unique identifier that determines the separation between the different parts of the content.<\/p>\n
Now that we have created the multipart\/mixed content, the only last thing that we need to do in order to have a valid batch request is create the HTTP request and associate the content to it. We can do that as we see in the following fragment:<\/p>\n
\/\/Create the request to the batch service<\/span>\r\nHttpRequestMessage batchRequest = new<\/span> HttpRequestMessage(HttpMethod.Post, "http:\/\/localhost:12345\/api\/batch"<\/span>);\r\n\/\/Associate the content with the message<\/span>\r\nbatchRequest.Content = content;<\/pre>\nWith this last part, we are ready to send a batch request to the server and get a response. To do that, we just use an HttpClient instance and call SendAsync passing the request message to it and capture the associated response. If we just do that, the following request gets send and the following response comes back:<\/p>\n
Request:<\/p>\n
POST http:\/\/localhost:12345\/api\/batch HTTP\/1.1\r\nContent-Type: multipart\/mixed; boundary="batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e"\r\nHost: localhost:12345\r\nContent-Length: 857\r\nExpect: 100-continue\r\n\r\n--batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e\r\nContent-Type: application\/http; msgtype=request\r\n\r\nGET \/api\/WebCustomers HTTP\/1.1\r\nHost: localhost:13245\r\n\r\n\r\n--batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e\r\nContent-Type: application\/http; msgtype=request\r\n\r\nPOST \/api\/WebCustomers HTTP\/1.1\r\nHost: localhost:13245\r\nContent-Type: application\/json; charset=utf-8\r\n\r\n{"Id":129,"Name":"Name4752cbf0-e365-43c3-aa8d-1bbc8429dbf8"}\r\n--batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e\r\nContent-Type: application\/http; msgtype=request\r\n\r\nPUT \/api\/WebCustomers\/1 HTTP\/1.1\r\nHost: localhost:13245\r\nContent-Type: application\/json; charset=utf-8\r\n\r\n{"Id":1,"Name":"Peter"}\r\n--batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e\r\nContent-Type: application\/http; msgtype=request\r\n\r\nDELETE \/api\/WebCustomers\/2 HTTP\/1.1\r\nHost: localhost:13245\r\n\r\n\r\n--batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e--\r\n<\/pre>\nIf we look at the request above, we can see, as we have said before, that all the messages are separated with a boundary, which in this case is \u201cbatch_357647d1-a6b5-4e6a-aa73-edfc88d8866e\u201d. Also, we can see that every request message has a Content-Type of application\/http. This header is introduced by the HttpContent where we wrapped all our requests. If we wanted to, we could have added extra headers that we could read and use for handling the processing of the message in a custom batch handler.<\/p>\n
If we look at the response below we can clearly see that it follows the same pattern, with a multipart\/mixed content type, a boundary to separate the different parts of the multipart and a collection of responses encapsulated in HttpContent parts.<\/p>\n
Response:<\/p>\n
HTTP\/1.1 200 OK\r\nContent-Length: 1373\r\nContent-Type: multipart\/mixed; boundary="61cfbe41-7ea6-4771-b1c5-b43564208ee5"<\/span>\r\nServer: Microsoft-HTTPAPI\/2.0\r\nDate: Fri, 25 Oct 2013 06:30:14 GMT\r\n\r\n--61cfbe41-7ea6-4771-b1c5-b43564208ee5\r\nContent-Type: application\/http; msgtype=response\r\n\r\nHTTP\/1.1 200 OK\r\nContent-Type: application\/json; charset=utf-8\r\n\r\n[{"Id"<\/span>:1,"Name"<\/span>:"Namefc4b8794-943b-487a-9049-a8559232b9dd"<\/span>},{"Id"<\/span>:2,"Name"<\/span>:"Name244bbada-3e83-43c8-82f7-5b2c4d72f2ed"<\/span>},{"Id"<\/span>:3,"Name"<\/span>:"Nameec11d080-7f2d-47df-a483-7ff251cdda7a"<\/span>},{"Id"<\/span>:4,"Name"<\/span>:"Name14ff5a3d-ad92-41f6-b4f6-9b94622f4968"<\/span>},{"Id"<\/span>:5,"Name"<\/span>:"Name00f9e4cc-673e-4139-ba30-bfc273844678"<\/span>},{"Id"<\/span>:6,"Name"<\/span>:"Name01f6660c-d1de-4c05-8567-8ae2759c4117"<\/span>},{"Id"<\/span>:7,"Name"<\/span>:"Name60030a17-6316-427c-a744-b2fff6d9fe11"<\/span>},{"Id"<\/span>:8,"Name"<\/span>:"Namefa61eb4c-9f9e-47a2-8dc5-15d8afe33f2d"<\/span>},{"Id"<\/span>:9,"Name"<\/span>:"Name9b680c10-1727-43f5-83cf-c8eda3a63790"<\/span>},{"Id"<\/span>:10,"Name"<\/span>:"Name9e66d797-d3a9-44ec-814d-aecde8040ced"<\/span>}]\r\n--61cfbe41-7ea6-4771-b1c5-b43564208ee5\r\nContent-Type: application\/http; msgtype=response\r\n\r\nHTTP\/1.1 201 Created\r\nLocation: http:\/\/localhost:13245\/api\/ApiCustomers<\/span>\r\nContent-Type: application\/json; charset=utf-8\r\n\r\n{"Id"<\/span>:21,"Name"<\/span>:"Name4752cbf0-e365-43c3-aa8d-1bbc8429dbf8"<\/span>}\r\n--61cfbe41-7ea6-4771-b1c5-b43564208ee5\r\nContent-Type: application\/http; msgtype=response\r\n\r\nHTTP\/1.1 200 OK\r\nContent-Type: application\/json; charset=utf-8\r\n\r\n{"Id"<\/span>:1,"Name"<\/span>:"Peter"<\/span>}\r\n--61cfbe41-7ea6-4771-b1c5-b43564208ee5\r\nContent-Type: application\/http; msgtype=response\r\n\r\nHTTP\/1.1 204 No Content\r\n\r\n\r\n--61cfbe41-7ea6-4771-b1c5-b43564208ee5--<\/pre>\nFinally, now that we have sent and received a response we need to read it and extract all the individual responses from the content. For accomplishing this task, we can use the ReadAsMimeMultipartAsync and ReadAsHttpResponseMessageAsync methods on the Content property of the response.<\/p>\n
HttpResponseMessage response = await client.SendAsync(batchRequest);\r\n\/\/Reads the individual parts in the content and loads them in memory<\/span>\r\nMultipartMemoryStreamProvider responseContents = await response.Content.ReadAsMultipartAsync();\r\n\/\/Extracts each of the individual Http responses<\/span>\r\nHttpResponseMessage queryResponse = await responseContents.Contents[0].ReadAsHttpResponseMessageAsync();\r\nHttpResponseMessage addResponse = await responseContents.Contents[1].ReadAsHttpResponseMessageAsync();\r\nHttpResponseMessage updateResponse = await responseContents.Contents[2].ReadAsHttpResponseMessageAsync();\r\nHttpResponseMessage removeResponse = await responseContents.Contents[3].ReadAsHttpResponseMessageAsync();\r\n<\/pre>\nAnd with this, we have successfully sent and read a batch request to Web API. Let\u2019s look at how to do the same thing with Web API OData.<\/p>\n
Batch in OData<\/h3>\n
In order to use batch with OData services, the flow is very similar to the flow in Web API. We will be reusing the model and the backend from the above sample, and the only things we\u2019ll need are an OData model a route that defines the OData endpoint and a controller to handle the incoming requests. All of which can be shown below:<\/p>\n
Route:<\/p>\n
configuration.Routes.MapODataRoute("odata"<\/span>, "odata"<\/span>, GetModel(), new<\/span> DefaultODataBatchHandler(server));<\/pre>\nAs you can see from the fragment above, MapODataRoute accepts an ODataBatchHandler as a parameter. In this case, we are using the DefaultODataBatchHandler, but we could also use the UnbufferedODataBatchHandler.<\/p>\n
OData model:<\/p>\n
private<\/span> static<\/span> IEdmModel GetModel()\r\n{\r\n ODataModelBuilder builder = new<\/span> ODataConventionModelBuilder();\r\n builder.ContainerName = "CustomersContext"<\/span>;\r\n EntitySetConfiguration<Customer> customers = builder.EntitySet<Customer>("Customers"<\/span>);\r\n return<\/span> builder.GetEdmModel();\r\n}\r\n<\/pre>\nController:<\/p>\n
public<\/span> class<\/span> CustomersController : ODataController\r\n{\r\n CustomersContext context = new<\/span> CustomersContext();\r\n [Queryable(PageSize = 10, MaxExpansionDepth = 2)]\r\n public<\/span> IHttpActionResult Get()\r\n {\r\n return<\/span> Ok(context.Customers);\r\n }\r\n\r\n public<\/span> async Task<IHttpActionResult> Post([FromBody] Customer entity)\r\n {\r\n if<\/span> (entity == null<\/span>)\r\n {\r\n return<\/span> BadRequest(ModelState);\r\n }\r\n context.Customers.Add(entity);\r\n await context.SaveChangesAsync();\r\n return<\/span> Created(entity);\r\n }\r\n\r\n public<\/span> async Task<IHttpActionResult> Put([FromODataUri] int<\/span> key, [FromBody] Customer entity)\r\n {\r\n if<\/span> (entity == null<\/span>)\r\n {\r\n return<\/span> BadRequest(ModelState);\r\n }\r\n else<\/span> if<\/span> (key != entity.Id)\r\n {\r\n return<\/span> BadRequest("The key from the url must match the key of the entity in the body"<\/span>);\r\n }\r\n var originalCustomer = await context.Customers.FindAsync(key);\r\n if<\/span> (originalCustomer == null<\/span>)\r\n {\r\n return<\/span> NotFound();\r\n }\r\n else<\/span>\r\n {\r\n context.Entry(originalCustomer).CurrentValues.SetValues(entity);\r\n await context.SaveChangesAsync();\r\n }\r\n return<\/span> Updated(entity);\r\n }\r\n\r\n [AcceptVerbs("PATCH"<\/span>, "MERGE"<\/span>)]\r\n public<\/span> async Task<IHttpActionResult> Patch([FromODataUri] int<\/span> key, Delta<Customer> patch)\r\n {\r\n object<\/span> id;\r\n if<\/span> (patch == null<\/span>)\r\n {\r\n return<\/span> BadRequest("The entity is malformed"<\/span>);\r\n }\r\n else<\/span> if<\/span> (patch.TryGetPropertyValue("Id"<\/span>, out<\/span> id) && (int<\/span>)id != key)\r\n {\r\n return<\/span> BadRequest("The key from the url must match the key of the entity in the body"<\/span>);\r\n }\r\n Customer originalEntity = await context.Customers.FindAsync(key);\r\n if<\/span> (originalEntity == null<\/span>)\r\n {\r\n return<\/span> NotFound();\r\n }\r\n else<\/span>\r\n {\r\n patch.Patch(originalEntity);\r\n await context.SaveChangesAsync();\r\n }\r\n return<\/span> Updated(originalEntity);\r\n }\r\n\r\n\r\n public<\/span> async Task<IHttpActionResult> Delete([FromODataUri]int<\/span> key)\r\n {\r\n Customer entity = await context.Customers.FindAsync(key);\r\n if<\/span> (entity == null<\/span>)\r\n {\r\n return<\/span> NotFound();\r\n }\r\n else<\/span>\r\n {\r\n context.Customers.Remove(entity);\r\n await context.SaveChangesAsync();\r\n return<\/span> StatusCode(HttpStatusCode.NoContent);\r\n }\r\n }\r\n}<\/pre>\nWe could use HttpClient to send batch requests to our OData service, but it\u2019s much easier if we make use of the generated client built in through the Add Service Reference dialog in Visual Studio 2013.<\/p>\n
To do that, we can just start the service by pressing Ctrl+F5, then we only need to go to the References icon of the project Right Click, Add Service Reference and give it the metadata url of our service which in this case is http:\/\/localhost:12345\/odata\/$metadata<\/a>.<\/p>\n
![\"clip_image002\"](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2013\/11\/7242.clip_image002_thumb_1BFDD532.jpg\" "\\"clip_image002\\"")
<\/a><\/p>\n