JSONP avec ASP.NET Web API

Ici est une version mise à jour de la JsonpMediaTypeFormatter pour une utilisation avec WebAPI RC:

public class JsonpMediaTypeFormatter : JsonMediaTypeFormatter
{
private string callbackQueryParameter;
public JsonpMediaTypeFormatter()
{
SupportedMediaTypes.Add(DefaultMediaType);
SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));
MediaTypeMappings.Add(new UriPathExtensionMapping("jsonp", DefaultMediaType));
}
public string CallbackQueryParameter
{
get { return callbackQueryParameter ?? "callback"; }
set { callbackQueryParameter = value; }
}
public override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContent content, TransportContext transportContext)
{
string callback;
if (IsJsonpRequest(out callback))
{
return Task.Factory.StartNew(() =>
{
var writer = new StreamWriter(stream);
writer.Write(callback + "(");
writer.Flush();
base.WriteToStreamAsync(type, value, stream, content, transportContext).Wait();
writer.Write(")");
writer.Flush();
});
}
else
{
return base.WriteToStreamAsync(type, value, stream, content, transportContext);
}
}
private bool IsJsonpRequest(out string callback)
{
callback = null;
if (HttpContext.Current.Request.HttpMethod != "GET")
return false;
callback = HttpContext.Current.Request.QueryString[CallbackQueryParameter];
return !string.IsNullOrEmpty(callback);
}
}

Certainement de Brian réponse est correcte, cependant, si vous utilisez déjà l'Json.Net formateur, qui vous donne assez json dates et les plus rapides de la sérialisation, alors vous ne pouvez pas ajouter un deuxième formateur pour jsonp, vous devez combiner les deux. C'est une bonne idée de l'utiliser de toute façon, comme Scott, Hanselman a affirmé que la libération de ASP.NET l'API Web va utiliser la Json.Net sérialiseur par défaut.

public class JsonNetFormatter : MediaTypeFormatter
{
private JsonSerializerSettings _jsonSerializerSettings;
private string callbackQueryParameter;
public JsonNetFormatter(JsonSerializerSettings jsonSerializerSettings)
{
_jsonSerializerSettings = jsonSerializerSettings ?? new JsonSerializerSettings();
//Fill out the mediatype and encoding we support
SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
Encoding = new UTF8Encoding(false, true);
//we also support jsonp.
SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));
MediaTypeMappings.Add(new UriPathExtensionMapping("jsonp", "application/json"));
}
public string CallbackQueryParameter
{
get { return callbackQueryParameter ?? "jsoncallback"; }
set { callbackQueryParameter = value; }
}
protected override bool CanReadType(Type type)
{
if (type == typeof(IKeyValueModel))
return false;
return true;
}
protected override bool CanWriteType(Type type)
{
return true;
}
protected override Task<object> OnReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders,
FormatterContext formatterContext)
{
//Create a serializer
JsonSerializer serializer = JsonSerializer.Create(_jsonSerializerSettings);
//Create task reading the content
return Task.Factory.StartNew(() =>
{
using (StreamReader streamReader = new StreamReader(stream, Encoding))
{
using (JsonTextReader jsonTextReader = new JsonTextReader(streamReader))
{
return serializer.Deserialize(jsonTextReader, type);
}
}
});
}
protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders,
FormatterContext formatterContext, TransportContext transportContext)
{
string callback;
var isJsonp = IsJsonpRequest(formatterContext.Response.RequestMessage, out callback);
//Create a serializer
JsonSerializer serializer = JsonSerializer.Create(_jsonSerializerSettings);
//Create task writing the serialized content
return Task.Factory.StartNew(() =>
{
using (JsonTextWriter jsonTextWriter = new JsonTextWriter(new StreamWriter(stream, Encoding)) { CloseOutput = false })
{
if (isJsonp)
{
jsonTextWriter.WriteRaw(callback + "(");
jsonTextWriter.Flush();
}
serializer.Serialize(jsonTextWriter, value);
jsonTextWriter.Flush();
if (isJsonp)
{
jsonTextWriter.WriteRaw(")");
jsonTextWriter.Flush();
}
}
});
}
private bool IsJsonpRequest(HttpRequestMessage request, out string callback)
{
callback = null;
if (request.Method != HttpMethod.Get)
return false;
var query = HttpUtility.ParseQueryString(request.RequestUri.Query);
callback = query[CallbackQueryParameter];
return !string.IsNullOrEmpty(callback);
}
}

JSONP ne fonctionne qu'avec des requête Http GET. Il y a un soutien de la SCRO dans asp.net l'api web qui fonctionne bien avec tous les verbes http.

Cette article peut vous être utile.

Voici une version mise à jour avec plusieurs améliorations, qui fonctionne avec la version RTM de l'Api Web.

• Sélectionne l'encodage correct, en fonction de la demande propre Accept-Encoding en-têtes. Le new StreamWriter() dans les exemples précédents, serait tout simplement d'utiliser l'UTF-8. L'appel à base.WriteToStreamAsync peut utiliser un autre encodage, entraînant une altération de sortie.
• Cartes JSONP demandes à la application/javascript Content-Type l'en-tête; l'exemple précédent serait sortie de JSONP, mais avec le application/json en-tête. Ce travail est réalisé dans le imbriqués Mapping classe (cf. Le meilleur type de contenu pour servir JSONP?)
• Renonce à la construction et de rinçage supplémentaire d'un StreamWriter et directement les octets et les écrit dans le flux de sortie.
• Au lieu d'attendre sur une tâche, utilisez la Task Parallel Library ContinueWith mécanisme à chaîne de plusieurs tâches.

Code:

public class JsonpMediaTypeFormatter : JsonMediaTypeFormatter
{
private string _callbackQueryParameter;
public JsonpMediaTypeFormatter()
{
SupportedMediaTypes.Add(DefaultMediaType);
SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/javascript"));
//need a lambda here so that it'll always get the 'live' value of CallbackQueryParameter.
MediaTypeMappings.Add(new Mapping(() => CallbackQueryParameter, "application/javascript"));
}
public string CallbackQueryParameter
{
get { return _callbackQueryParameter ?? "callback"; }
set { _callbackQueryParameter = value; }
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
TransportContext transportContext)
{
var callback = GetCallbackName();
if (!String.IsNullOrEmpty(callback))
{
//select the correct encoding to use.
Encoding encoding = SelectCharacterEncoding(content.Headers);
//write the callback and opening paren.
return Task.Factory.StartNew(() =>
{
var bytes = encoding.GetBytes(callback + "(");
writeStream.Write(bytes, 0, bytes.Length);
})
//then we do the actual JSON serialization...
.ContinueWith(t => base.WriteToStreamAsync(type, value, writeStream, content, transportContext))
//finally, we close the parens.
.ContinueWith(t =>
{
var bytes = encoding.GetBytes(")");
writeStream.Write(bytes, 0, bytes.Length);
});
}
return base.WriteToStreamAsync(type, value, writeStream, content, transportContext);
}
private string GetCallbackName()
{
if (HttpContext.Current.Request.HttpMethod != "GET")
return null;
return HttpContext.Current.Request.QueryString[CallbackQueryParameter];
}
#region Nested type: Mapping
private class Mapping : MediaTypeMapping
{
private readonly Func<string> _param; 
public Mapping(Func<string> discriminator, string mediaType)
: base(mediaType)
{
_param = discriminator;
}
public override double TryMatchMediaType(HttpRequestMessage request)
{
if (request.RequestUri.Query.Contains(_param() + "="))
return 1.0;
return 0.0;
}
}
#endregion
}

Je suis conscient de la "hackiness" de la Func<string> paramètre à l'intérieur du constructeur de la classe, mais c'était le moyen le plus rapide pour contourner le problème, il n'en résout, et depuis C# n'a statique à l'intérieur des classes, il ne peut pas voir le CallbackQueryParameter de la propriété. En passant la Func dans la lie de la propriété dans le lambda, donc Mapping sera en mesure d'accéder à plus tard, dans TryMatchMediaType. Si vous avez un moyen plus élégant, s'il vous plaît commentaire!

johperl, Thomas. La réponse donnée par Peter Moberg ci-dessus doit être correcte pour la version RC comme le JsonMediaTypeFormatter qu'il hérite de utilise le NewtonSoft sérialiseur Json déjà, et donc ce qu'il a devrait fonctionner avec toutes les modifications.

Cependant, pourquoi sur la terre sont des gens toujours à l'aide des paramètres, où vous pouviez juste faire ce qui suit

public override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext transportContext)
{
var isJsonpRequest = IsJsonpRequest();
if(isJsonpRequest.Item1)
{
return Task.Factory.StartNew(() =>
{
var writer = new StreamWriter(stream);
writer.Write(isJsonpRequest.Item2 + "(");
writer.Flush();
base.WriteToStreamAsync(type, value, stream, contentHeaders, transportContext).Wait();
writer.Write(")");
writer.Flush();
});
}
return base.WriteToStreamAsync(type, value, stream, contentHeaders, transportContext);
}
private Tuple<bool, string> IsJsonpRequest()
{
if(HttpContext.Current.Request.HttpMethod != "GET")
return new Tuple<bool, string>(false, null);
var callback = HttpContext.Current.Request.QueryString[CallbackQueryParameter];
return new Tuple<bool, string>(!string.IsNullOrEmpty(callback), callback);
}

Pour ceux d'entre vous qui sont à l'aide de la HttpSelfHostServer cette section de code suivant ne fonctionnera pas sur HttpContext.Actuel, car il n'existe pas sur l'auto serveur hôte.

private Tuple<bool, string> IsJsonpRequest()
{
if(HttpContext.Current.Request.HttpMethod != "GET")
return new Tuple<bool, string>(false, null);
var callback = HttpContext.Current.Request.QueryString[CallbackQueryParameter];
return new Tuple<bool, string>(!string.IsNullOrEmpty(callback), callback);
}

Cependant, vous pouvez intercepter l'auto hôte "contexte" par cette substitution.

public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
{
_method = request.Method;
_callbackMethodName =
request.GetQueryNameValuePairs()
.Where(x => x.Key == CallbackQueryParameter)
.Select(x => x.Value)
.FirstOrDefault();
return base.GetPerRequestFormatterInstance(type, request, mediaType);
}

La demande.Méthode vous donnera "GET", "POST", etc. et le GetQueryNameValuePairs pouvez récupérer l' ?rappel paramètre. Donc mon code révisé ressemble:

private Tuple<bool, string> IsJsonpRequest()
{
if (_method.Method != "GET")
return new Tuple<bool, string>(false, null);
return new Tuple<bool, string>(!string.IsNullOrEmpty(_callbackMethodName), _callbackMethodName);
}

Espère que cela aide certains d'entre vous. De cette façon, vous n'avez pas nécessairement besoin d'un HttpContext cale.

C.

Si le contexte est Web Api, le remerciant et en se référant à 010227leo's réponse, vous devez tenir compte de WebContext.Current valeur qui va être null.

J'ai donc mis à jour son code de cette fonction:

public class JsonCallbackAttribute
: ActionFilterAttribute
{
private const string CallbackQueryParameter = "callback";
public override void OnActionExecuted(HttpActionExecutedContext context)
{
var callback = context.Request.GetQueryNameValuePairs().Where(item => item.Key == CallbackQueryParameter).Select(item => item.Value).SingleOrDefault();
if (!string.IsNullOrEmpty(callback))
{
var jsonBuilder = new StringBuilder(callback);
jsonBuilder.AppendFormat("({0})", context.Response.Content.ReadAsStringAsync().Result);
context.Response.Content = new StringContent(jsonBuilder.ToString());
}
base.OnActionExecuted(context);
}
}