Adding support for JSONP and URL-controlled format to ADO.NET Data Services
JSONP is a common way of making data accessible in client-side mashups even when the requests need to be cross-domain.
While the current version of the ADO.NET Data Services framework does not support this, it’s possible to build it on top. There are a couple of ways of doing this. Here is what’s probably the simplest way. There is some downsides to this approach, but overall is the most straightforward path to get there.
The default transport layer for Data Services is WCF, which has a many extensibility points across the stack. For the case of JSONP support, IDispatchMessageInspector comes in handy.
There are two things needed to support JSONP properly:
- The ability to control the response format. Data Services uses standard HTTP content type negotiation to select what representation of a given resource should be sent to the client (e.g. JSON, Atom). That requires that the caller can set the Accept request header, which is not possible when doing the JSONP trick (which basically just uses <script> tags). We need to add the ability to use the query string in the URL to select format. (e.g. /People(1)/Friends?$orderby=Name& $format=json).
- A new option to wrap the response in a callback if such callback was provided in the request (also in the query string). For example /People(1)/Friends?$orderby=Name&$format=json& $callback=loaded.
What we’ll do is register a message inspector and adjust the request/response when we see these new options coming in.
In order to support the $format=json option we can intercept the message before it gets dispatched to the Astoria runtime, at the IDispatchMessageInspector.AfterReceivedRequest method. If we see the query string option then we’ll a) strip it out from the URL so Data Services does not generate an error and b) change the “Accept” header to “application/json”, so the rest of the system just thinks that the client asked for a JSON response in the first place.
For the second part, where we need to wrap the response into a Javascript call if the $callback option was used, we have the IDispatchMessageInspector.BeforeSendReply method which gives us the perfect spot to rewrite the response. One unfortunate side-effect of this is that the response will get buffered and re-encoded; that said, in many cases this won’t make any noticeable difference.
Finally, we need to register the interceptor with WCF’s dispatchers. For that we create an attribute that implements IServiceBehavior, so we get called during service initialization. When we get called we can register our message interceptor.
The net effect is that if you include this code in your project, you just need to add a single attribute to your Data Service to make it support JSONP:
[JSONPSupportBehavior]
public class SampleService : DataService<ContactsData>
{
// your service code here...
}
Once that's in place you can use JSONP by adding $format and $callback to URLs, for example:
https://<host>/SampleService.svc/People?$format=json&$callback=cb
Of course, you can still use all the other Data Services URL options in addition to these.
The implementation and a small sample service are available at MSDN code gallery, here:
https://code.msdn.microsoft.com/DataServicesJSONP
-pablo