Your official information source from the .NET Web Development and Tools group at Microsoft.
Range requests is the ability in HTTP to request a part of a document based on one or more ranges. This can be used in scenarios where the client wants to recover from interrupted data transfers as a result of canceled requests or dropped connections. It can also be used in scenarios where a client requests only a subset of a larger representation, such as a single segment of a very large document for special processing. Ranges specify a start and an end given a unit. The unit can be anything but by far the most common is “bytes”. An example of a range request asking for the first 10 bytes is as follows:
GET /api/range HTTP/1.1 Host: localhost:50231 Range : bytes=0-9
An example asking for the first and last byte contains two ranges separated by comma as follows:
In this example the resource which we are doing range requests over contains the 26 letters of the English alphabet:
HTTP/1.1 200 OK Content-Length: 26 Content-Type: text/plain abcdefghijklmnopqrstuvwxyz
The response to a byte range request is a 206 (Partial Content) response. If only one range was requested then the response looks similar to a 200 (OK) response with the exception that it has a Content-Range header field indicating the range and the total length of the document:
HTTP/1.1 206 Partial Content Content-Length: 10 Content-Type: text/plain Content-Range: bytes 0-9/26 abcdefghij
Note that the Content-Length header indicates the bytes actually in the response and not the total size of the document requested.
If more than one ranges were requested then the response has the media type “multipart/byteranges” with a body part for each range:
HTTP/1.1 206 Partial Content Content-Length: 244 Content-Type: multipart/byteranges; boundary="57c2656a-9716-4ea0-9d3b-2f76cbac4885"
--57c2656a-9716-4ea0-9d3b-2f76cbac4885 Content-Type: text/plain Content-Range: bytes 0-0/26 a --57c2656a-9716-4ea0-9d3b-2f76cbac4885 Content-Type: text/plain Content-Range: bytes 25-25/26 z --57c2656a-9716-4ea0-9d3b-2f76cbac4885--
Range requests that don’t overlap with the extent of the resource result in a 416 (Requested Range Not Satisfiable) with a Content-Range header indicating the current extent of the resource.
HTTP/1.1 416 Requested Range Not Satisfiable Content-Range: bytes */26
In addition to using ranges as described above, range requests can be made conditional using an If-Range header field meaning “send me the following range but only if the ETag matches; otherwise send me the whole response.”
With the addition of the ByteRangeStreamContent class to ASP.NET Web API (available in latest nightly build, not RTM), it is now simpler to support byte range requests. The ByteRangeStreamContent class can also be used in scenarios supporting conditional If-Range requests although we don’t show this scenario in this blog.
The ByteRangeStreamContent is very similar to the already existing StreamContent in that it provides a view over a stream. ByteRangeStreamContent requires the stream to be seekable in order to provide one or more ranges over it. Common examples of seekable streams are FileStreams and MemoryStreams. In this blog we show an example using a MemoryStream but a FileStream or other seekable stream would work just as well.
Below is the sample controller. It is part of the ASP.NET Web API samples where the entire sample project is available in our git repository.
1: public class RangeController : ApiController
3: // Sample content used to demonstrate range requests
4: private static readonly byte _content = Encoding.UTF8.GetBytes("abcdefghijklmnopqrstuvwxyz");
6: // Content type for our body
7: private static readonly MediaTypeHeaderValue _mediaType = MediaTypeHeaderValue.Parse("text/plain");
9: public HttpResponseMessage Get()
11: // A MemoryStream is seekable allowing us to do ranges over it. Same goes for FileStream.
12: MemoryStream memStream = new MemoryStream(_content);
14: // Check to see if this is a range request (i.e. contains a Range header field)
15: // Range requests can also be made conditional using the If-Range header field. This can be
16: // used to generate a request which says: send me the range if the content hasn't changed;
17: // otherwise send me the whole thing.
18: if (Request.Headers.Range != null)
22: HttpResponseMessage partialResponse = Request.CreateResponse(HttpStatusCode.PartialContent);
23: partialResponse.Content = new ByteRangeStreamContent(memStream, Request.Headers.Range, _mediaType);
24: return partialResponse;
26: catch (InvalidByteRangeException invalidByteRangeException)
28: return Request.CreateErrorResponse(invalidByteRangeException);
33: // If it is not a range request we just send the whole thing as normal
34: HttpResponseMessage fullResponse = Request.CreateResponse(HttpStatusCode.OK);
35: fullResponse.Content = new StreamContent(memStream);
36: fullResponse.Content.Headers.ContentType = _mediaType;
37: return fullResponse;
The first thing to check is if the incoming request is a range request. If it is then we create a ByteRangeStreamContent and return that. Otherwise we create a StreamContent and return that. The ByteRangeStreamContent throws an InvalidByteRangeException is no overlapping ranges are found so we catch that and create a 416 (Requested Range Not Satisfiable) response.
Running the sample creates a set of range requests. We write the corresponding responses to the console as follows:
Full Content without ranges: 'abcdefghijklmnopqrstuvwxyz'
Range 'bytes=0-0' requesting the first byte: 'a'
Range 'bytes=-1' requesting the last byte: 'z'
Range 'bytes=4-' requesting byte 4 and up: 'efghijklmnopqrstuvwxyz'
Range 'bytes=0-0, -1' requesting first and last byte:
Content-Range: bytes 0-0/26
Content-Range: bytes 25-25/26
Range 'bytes=0-0, 12-15, -1' requesting first, mid four, and last byte:
Content-Range: bytes 0-0/26
Content-Range: bytes 12-15/26
Content-Range: bytes 25-25/26
Range 'bytes=100-' resulted in status code 'RequestedRangeNotSatisfiable' with
Content-Range header 'bytes */26'
Would this be an option for enabling paging in API requests that return lists of items ?
I think we're mixing up a couple of things here. I don't think it's wise for a controller to return a representation, even if you're going to return a block of bytes and it's really that form that will see its way to the client.
Livingston, no this is not the way to do paging. A better way is to use the [Queryable] attribute from the OData NuGet package which is currently out in preview. We will be posting a sample on how to do paging using the [Queryable] fairly soon.
i think its great mix solution to control ranges..
nice job. this is a good solution to massive downloads.
I think this is very useful in solving the progress bar problem, by requiring several partial contents to the server through multiple jquery ajax calls. An example showing this application might be vey usefull.
Thanks for to share this blog ASP.Net is very essential part for the url address which is send a message between user & server.
Could firewalls or other intermediaries block or remove Range header?