¿Cómo consigo que ASP.NET Web API devuelva JSON en lugar de XML usando Chrome?

Usando el más nuevo API web ASP.NETen Chrome Veo XML, ¿cómo puedo cambiarlo para solicitar? JSON para que pueda verlo en el navegador? Creo que es solo parte de los encabezados de la solicitud, ¿estoy en lo cierto?

preguntado el 23 de marzo de 12 a las 23:03

Aquí hay una discusión para hacer que la devolución de JSON sea solo el comportamiento predeterminado: github.com/aspnet/Mvc/issues/1765 -

29 Respuestas

Nota: lea los comentarios de esta respuesta, puede producir una vulnerabilidad XSS si está utilizando el manejo de errores predeterminado de WebAPI

Solo agrego lo siguiente en App_Start / WebApiConfig.cs clase en mi MVC API web proyecto.

config.Formatters.JsonFormatter.SupportedMediaTypes
    .Add(new MediaTypeHeaderValue("text/html") );

Eso asegura que obtenga JSON en la mayoría de las consultas, pero puede obtener XML Cuando lo envies text/xml.

Si necesita tener la respuesta Content-Type as application/json consulte La respuesta de Todd a continuación.

NameSpace esta usando System.Net.Http.Headers.

Respondido 27 ago 21, 02:08

Esta es una respuesta sorprendentemente pasada por alto, y aunque la pregunta original no estaba totalmente clara, esto convierte directamente a JSON en la respuesta predeterminada para un navegador web (que envía Aceptar: texto / html). Buen trabajo. - Gregmac

+1 De lejos la mejor respuesta. Me imagino que hay un montón de personas que optan por eliminar completamente XML solo porque no ven JSON en el navegador. - Derek Hunziker

Cuando hice esto, descubrí que los datos proporcionados por un tercero con etiquetas de rotura HTML terminaban con retornos de carro. Entonces, el JSON no era válido. Es mejor usar la respuesta aceptada si esto te afecta. - Punta de piedra

Tenga en cuenta que la respuesta Content-Type el encabezado seguirá siendo text/html. - Señor jefe

Esto es horrible. El encabezado del tipo de contenido de respuesta debe ser application / json. Esta "solución" lo convierte en texto / html. - Caminante del norte

Si haces esto en el WebApiConfig obtendrá JSON de forma predeterminada, pero aún le permitirá devolver XML si pasa text/xml como la solicitud Accept cabecera.

Nota: Esto elimina el soporte para application/xml

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );

        var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
        config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
    }
}

Si no está utilizando el tipo de proyecto MVC y, por lo tanto, no tenía esta clase para empezar, mira esta respuesta para obtener detalles sobre cómo incorporarlo.

Respondido 27 ago 21, 01:08

Solo para notar, el comportamiento original es correcto. Solicitudes de Chrome application/xml con una prioridad de 0.9 y */* con una prioridad de 0.8. Mediante la eliminación application/xml elimina la capacidad de la API web para devolver XML si el cliente lo solicita específicamente. por ejemplo, si envía "Aceptar: aplicación / xml", posible recibir JSON. - porges

¿Soy yo o la primera oración es incorrecta? El código parece eliminar totalmente el XML, no simplemente cambiar el predeterminado. - NickG

@NickG: una solución que se pasa por alto aquí y en mi humilde opinión es una opción mucho mejor (mantener la aplicación / xml) es la solución propuesta por Felipe Leusin más abajo en esta página. Usando config.Formatters.XmlFormatter.SupportedMediaTypes.Add (new MediaTypeHeaderValue ("texto / html")); - Cohen

Entonces, ¿cómo lo hacemos a través de la configuración web para obtener json de forma predeterminada y XML si se solicita? - Kyle

La respuesta de @Felipse Leusin a continuación es en realidad más corta y funciona mejor. - Ken Smith

El uso de RequestHeaderMapping funciona incluso mejor, porque también establece el Content-Type = application/json en el encabezado de la respuesta, lo que permite a Firefox (con el complemento JSONView) formatear la respuesta como JSON.

GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings
.Add(new System.Net.Http.Formatting.RequestHeaderMapping("Accept", 
                              "text/html",
                              StringComparison.InvariantCultureIgnoreCase,
                              true, 
                              "application/json"));

Respondido el 19 de junio de 18 a las 13:06

Esta es la solución más ajustada y simple y Fiddler también detecta el tipo de contenido que se devuelve como josn. - Steve Johnson

¡Bonito! ¿Dónde sugeriría poner esto en el código? - tim abel

Debería ir en WebApiConfig.cs - Animesh

Trabajó para mi. Necesitaba agregar un utilizando System.Net.Http.Formatting; - bbsimonbb

Y para ser claros, esto solo cambia el valor predeterminado. Siempre puede obtener JSON o XML simplemente incluyendo el encabezado "Aceptar" correspondiente. - Filósofos

Me gusta El enfoque de Felipe Leusin lo mejor: asegúrese de que los navegadores obtengan JSON sin comprometer la negociación de contenido de los clientes que realmente desean XML. La única pieza que me faltaba era que los encabezados de respuesta todavía contenían content-type: text / html. ¿Por qué fue eso un problema? Porque yo uso el Extensión JSON Formatter Chrome, que inspecciona el tipo de contenido, y no obtengo el formato bonito al que estoy acostumbrado. Lo arreglé con un formateador personalizado simple que acepta solicitudes de texto / html y devuelve respuestas de aplicaciones / json:

public class BrowserJsonFormatter : JsonMediaTypeFormatter
{
    public BrowserJsonFormatter() {
        this.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
        this.SerializerSettings.Formatting = Formatting.Indented;
    }

    public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType) {
        base.SetDefaultContentHeaders(type, headers, mediaType);
        headers.ContentType = new MediaTypeHeaderValue("application/json");
    }
}

Regístrese así:

config.Formatters.Add(new BrowserJsonFormatter());

contestado el 23 de mayo de 17 a las 13:05

En el constructor agregue this.SerializerSettings.Formatting = Formatting.Indented; si lo desea con una bonita impresión sin una extensión de navegador. - Fauces de Alastair

¿Por qué querrías que se imprimiera sobre el cable? - Caminante del norte

¿No es @ dmit77? Respuesta mejor (más conciso) que este? - H. Wolper

@eddiegroves, no quieres un estampado bonito sobre el cable. Quiere que el servidor envíe la menor cantidad de bits a través del cable (es decir, sin espacios). Entonces desea que el navegador lo formatee bien, con complementos y demás. Javascript necesita analizar el JSON por lo general, ¿por qué hacerlo más lento al introducir un formato innecesario? Caminante del norte

Para los googlers que buscan: no olvide agregar using System.Net.Http.Formatting y using Newtonsoft.Json - Berriel

Consejo rápido n.º 4 de MVC3: eliminación del formateador XML de la API web ASP.Net

In Global.asax agregue la línea:

GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();

al igual que:

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);

    BundleTable.Bundles.RegisterTemplateBundles();
    GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
}

Respondido 06 ago 13, 14:08

Funciona: mucho mejor si JSON es el predeterminado en lugar de XML. - Whitneyland

pero ¿puedes devolver xml entonces? - Tomas Stock

Lo probé y no puedes. Así que esto está eliminando la compatibilidad con XML ... Tengan cuidado, queridos usuarios de Google: Tomas Stock

Si echa un vistazo a mi respuesta a continuación, esto permitirá que xml se devuelva si lo desea, pero permite que el sitio responda con JSON al navegador: Glenn Slaven

@GlennSlaven sí, tu respuesta debería ser la marcada como la correcta. - radu florescu

En la columna WebApiConfig.cs, agregue al final de la Regístrese función:

// Remove the XML formatter
config.Formatters.Remove(config.Formatters.XmlFormatter);

Fuente.

Respondido el 08 de diciembre de 16 a las 20:12

En MVC5, esto se puede hacer reemplazando config con GlobalConfiguration.Configuration - Steven

Para un proyecto que solo debe admitir JSON y bajo ninguna circunstancia se le puede permitir emitir XML, esta es, con mucho, la mejor opción. - Lucas C

config.Formatters.Add (config.Formatters.JsonFormatter); - cas bloem

Eso es terrible. - Esto siempre devolverá JSON pase lo que pase, incluso si el cliente solicita específicamente XML en el encabezado Content-Type. - BrainSlugs83

Los proyectos que no prueben la versión XML de la API tan a fondo como su versión JSON deben optar por esto. Los objetos se serializan de manera diferente por los diferentes formateadores según el enlace que Michael incluyó. Por ejemplo: los formateadores XML no serializan campos de solo lectura, mientras que el formateador JSON sí. - cdiggins

En la columna global.asax Estoy usando el siguiente código. Mi URI para obtener JSON es http://www.digantakumar.com/api/values?json=true

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();

    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);

    GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings.Add(new  QueryStringMapping("json", "true", "application/json"));
}

Respondido el 08 de diciembre de 16 a las 20:12

Muy buena. ¿Cuál es su método para esperar un parámetro? me gusta localhost: 61044 / api / values ​​/ getdate? json = true, date = 2012-08-01 - LT.Nolo

Eche un vistazo a la negociación de contenido en WebAPI. Estos (Parte & Parte) publicaciones de blog maravillosamente detalladas y completas explican cómo funciona.

En resumen, tiene razón y solo necesita configurar el Accept or Content-Type Solicitar encabezados. Dado que su acción no está codificada para devolver un formato específico, puede establecer Accept: application/json.

respondido 09 nov., 12:19

"para que pueda verlo en el navegador" - hombre esponja

@Spongman, sí puedes. Pero use una extensión como REST Client; la mayoría de los navegadores tienen una similar. La escritura directa de URL en un navegador es 1. Demasiado limitante (no hay control sobre los encabezados, no se pueden publicar datos, etc.); 2. Incorrecto: el navegador no consume la API web como está destinado a ser consumido; no puede confiar en que lo pruebe correctamente. Entonces, nuevamente, un buen complemento de cliente REST solucionaría eso. - Ivailo Slavov

Como la pregunta es específica de Chrome, puede obtener la Extensión cartero que le permite establecer el tipo de contenido de la solicitud.

Cartero

Respondido el 27 de Septiembre de 13 a las 11:09

En Firefox, simplemente vaya a about: config, busque accept.default y cambie el contenido del network.http.accept.default configuración a text/html,application/xhtml+xml,application/json;q=0.9,application/xml;q=0.8,*/*;q=0.7. - Bjartur Thorlacio

O mejor aún, solo text/html,application/xhtml+xml;q=1.0,*/*;q=0.7 para evitar que hosts con errores como Bitbucket sirvan accidentalmente JSON de su navegador en lugar de HTML. - Bjartur Thorlacio

La URL está muerta. Uno nuevo es chrome.google.com/webstore/detail/postman/…. - Halcón momot

Una opción rápida es utilizar la especialización MediaTypeMapping. A continuación, se muestra un ejemplo del uso de QueryStringMapping en el evento Application_Start:

GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings.Add(new QueryStringMapping("a", "b", "application/json"));

Ahora, siempre que la URL contenga la cadena de consulta? A = b en este caso, la respuesta de Json se mostrará en el navegador.

respondido 27 mar '12, 06:03

Esto fue muy útil. También puede usar UriPathExtensionMapping en lugar de QueryStringMapping si desea usar path.to/item.json - nuzzolilo

Este código hace que json sea mi predeterminado y también me permite usar el formato XML. Solo agregaré el xml=true.

GlobalConfiguration.Configuration.Formatters.XmlFormatter.MediaTypeMappings.Add(new QueryStringMapping("xml", "true", "application/xml"));
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));

¡Gracias a todos!

Respondido 11 Jul 16, 16:07

Esta es la respuesta más flexible (y realmente debería ser la configuración predeterminada en estos días). Para agregar a esta respuesta, JSON es el predeterminado, incluso desde el navegador. Para ver XML, agregue la cadena de consulta:? Xml = true - raider33

Probé varias estrategias. Tuve una prueba simple para XML y JSON y esto funcionó de inmediato: Pat Capozzi

No utilice su navegador para probar su API.

En su lugar, intente utilizar un cliente HTTP que le permita especificar su solicitud, como CURL o incluso Fiddler.

El problema con este problema está en el cliente, no en la API. La API web se comporta correctamente, según la solicitud del navegador.

Respondido 25 Abr '14, 22:04

¿Por qué no utilizar el navegador? Es una herramienta obvia para ello. - anders lindén

Creo que el punto aquí es correcto e importante: no debemos corregir una parte funcional de la aplicación (la infraestructura MVC WebAPI) si el problema es causado por el cliente. El caso de uso real de una API es que se use correctamente (proporcionando encabezados correctos), que es responsabilidad de la aplicación. Sin embargo, no estoy de acuerdo con descartar completamente el navegador; para probar, hay muchas herramientas para casi cualquier navegador (para empezar, extensiones similares a Rest Client). - Ivailo Slavov

Probablemente debería ser un comentario. - Oye

La mayoría de las respuestas anteriores tiene mucho sentido. Dado que está viendo que los datos se formatean en formato XML, eso significa que se aplica el formateador XML, de modo que puede ver el formato JSON simplemente eliminando XMLFormatter del parámetro HttpConfiguration como

public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );                
            config.Formatters.Remove(config.Formatters.XmlFormatter);                
            config.EnableSystemDiagnosticsTracing();
        }

ya que JSON es el formato predeterminado

Respondido 13 Abr '17, 07:04

Usé un filtro de acción global para eliminar Accept: application/xml cuando User-Agent el encabezado contiene "Chrome":

internal class RemoveXmlForGoogleChromeFilter : IActionFilter
{
    public bool AllowMultiple
    {
        get { return false; }
    }

    public async Task<HttpResponseMessage> ExecuteActionFilterAsync(
        HttpActionContext actionContext,
        CancellationToken cancellationToken,
        Func<Task<HttpResponseMessage>> continuation)
    {
        var userAgent = actionContext.Request.Headers.UserAgent.ToString();
        if (userAgent.Contains("Chrome"))
        {
            var acceptHeaders = actionContext.Request.Headers.Accept;
            var header =
                acceptHeaders.SingleOrDefault(
                    x => x.MediaType.Contains("application/xml"));
            acceptHeaders.Remove(header);
        }

        return await continuation();
    }
}

Parece funcionar.

Respondido el 23 de junio de 13 a las 15:06

El formateador de tipo de medio realiza la devolución del formato correcto. Como otros mencionaron, puede hacer esto en el WebApiConfig clase:

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        ...

        // Configure Web API to return JSON
        config.Formatters.JsonFormatter
        .SupportedMediaTypes.Add(new System.Net.Http.Headers.MediaTypeHeaderValue("text/html"));

        ...
    }
}

Para obtener más información, consulte:

En caso de que sus acciones devuelvan XML (que es el caso de forma predeterminada) y solo necesita un método específico para devolver JSON, puede usar un ActionFilterAttribute y aplicarlo a esa acción específica.

Atributo de filtro:

public class JsonOutputAttribute : ActionFilterAttribute
{
    public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
    {
        ObjectContent content = actionExecutedContext.Response.Content as ObjectContent;
        var value = content.Value;
        Type targetType = actionExecutedContext.Response.Content.GetType().GetGenericArguments()[0];

        var httpResponseMsg = new HttpResponseMessage
        {
            StatusCode = HttpStatusCode.OK,
            RequestMessage = actionExecutedContext.Request,
            Content = new ObjectContent(targetType, value, new JsonMediaTypeFormatter(), (string)null)
        };

        actionExecutedContext.Response = httpResponseMsg;
        base.OnActionExecuted(actionExecutedContext);
    }
}

Aplicar a la acción:

[JsonOutput]
public IEnumerable<Person> GetPersons()
{
    return _repository.AllPersons(); // the returned output will be in JSON
}

Tenga en cuenta que puede omitir la palabra Attribute en la decoración de la acción y use solo [JsonOutput] en lugar de [JsonOutputAttribute].

Respondido el 09 de diciembre de 16 a las 16:12

Encontré la aplicación de Chrome "Advanced REST Client" excelente para trabajar con servicios REST. Puede establecer el tipo de contenido en application/json entre otras cosas: Cliente REST avanzado

Respondido el 30 de Septiembre de 15 a las 08:09

según la última versión de ASP.net WebApi 2,

bajo WebApiConfig.cs , esto funcionará

config.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);
config.Formatters.Add(GlobalConfiguration.Configuration.Formatters.JsonFormatter);

Respondido 27 Oct 16, 11:10

        config.Formatters.Remove(config.Formatters.XmlFormatter);

Respondido 01 Jul 17, 05:07

Si bien este código puede responder a la pregunta, proporcionar un contexto adicional sobre cómo y / o por qué resuelve el problema mejoraría el valor de la respuesta a largo plazo. Por favor lee esto stackoverflow.com/help/how-to-answer - SR

No me queda claro por qué hay toda esta complejidad en la respuesta. Seguro que hay muchas formas de hacer esto, con QueryStrings, encabezados y opciones ... pero lo que creo que es la mejor práctica es simple. Solicita una URL simple (por ejemplo: http://yourstartup.com/api/cars) y, a cambio, obtienes JSON. Obtienes JSON con el encabezado de respuesta adecuado:

Content-Type: application/json

Al buscar una respuesta a esta misma pregunta, encontré este hilo y tuve que continuar porque esta respuesta aceptada no funciona exactamente. Encontré una respuesta que creo que es demasiado simple para no ser la mejor:

Establecer el formateador WebAPI predeterminado

Agregaré mi consejo aquí también.

WebApiConfig.cs

namespace com.yourstartup
{
  using ...;
  using System.Net.Http.Formatting;
  ...
  config.Formatters.Clear(); //because there are defaults of XML..
  config.Formatters.Add(new JsonMediaTypeFormatter());
}

Tengo una pregunta de dónde provienen los valores predeterminados (al menos los que estoy viendo). ¿Son los valores predeterminados de .NET o quizás los creó en otro lugar (por otra persona en mi proyecto)? De todos modos, espero que esto ayude.

contestado el 23 de mayo de 17 a las 11:05

Puede utilizar de la siguiente manera:

GlobalConfiguration.Configuration.Formatters.Clear();
GlobalConfiguration.Configuration.Formatters.Add(new JsonMediaTypeFormatter());

Respondido 11 Abr '18, 11:04

Si está creando una aplicación WebAPI para simplemente pasar mensajes JSON, considere esta respuesta. - allen1

Aquí hay una solución similar a jayson.centeno's y otras respuestas, pero usando la extensión incorporada de System.Net.Http.Formatting.

public static void Register(HttpConfiguration config)
{
    // add support for the 'format' query param
    // cref: http://blogs.msdn.com/b/hongyes/archive/2012/09/02/support-format-in-asp-net-web-api.aspx
    config.Formatters.JsonFormatter.AddQueryStringMapping("$format", "json", "application/json");
    config.Formatters.XmlFormatter.AddQueryStringMapping("$format", "xml", "application/xml");

    // ... additional configuration
 }

La solución estaba orientada principalmente a admitir el formato $ para OData en las primeras versiones de WebApi, pero también se aplica a la implementación que no es de OData y devuelve el Content-Type: application/json; charset=utf-8 encabezado en la respuesta.

Te permite virar &$format=json or &$format=xml al final de su uri al realizar la prueba con un navegador. No interfiere con otros comportamientos esperados cuando se utiliza un cliente que no es un navegador en el que puede configurar sus propios encabezados.

contestado el 23 de mayo de 17 a las 13:05

Simplemente agregue esas dos líneas de código en su WebApiConfig clase

public static class WebApiConfig
{
     public static void Register(HttpConfiguration config)
     {
          //add this two line 
          config.Formatters.Clear();
          config.Formatters.Add(new JsonMediaTypeFormatter());


          ............................
      }
}

respondido 10 nov., 16:11

Solo cambia el App_Start/WebApiConfig.cs Me gusta esto:

public static void Register(HttpConfiguration config)
    {
        // Web API configuration and services

        // Web API routes
        config.MapHttpAttributeRoutes();
        //Below formatter is used for returning the Json result.
        var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
        config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
        //Default route
        config.Routes.MapHttpRoute(
           name: "ApiControllerOnly",
           routeTemplate: "api/{controller}"
       );
    }

Respondido 08 Feb 16, 05:02

Eliminar un formateador generalmente no es una buena idea, está eliminando una funcionalidad. - naspinski

De hecho, en este caso, a mí me funciona bien, también muchos otros sugieren una forma como esta. Lo he aprendido de myview.rahulnivi.net/building-spa-angular-mvc-5 ¡libro! - vaheeds

De MSDN Construyendo una aplicación de página única con ASP.NET y AngularJS (unos 41 minutos en).

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // ... possible routing etc.

        // Setup to return json and camelcase it!
        var formatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
        formatter.SerializerSettings.ContractResolver =
            new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver();
    }

Debería estar actualizado, lo probé y funcionó.

Respondido el 30 de Septiembre de 14 a las 20:09

Ha pasado algún tiempo desde que se hizo (y se respondió) esta pregunta, pero otra opción es anular el encabezado Accept en el servidor durante el procesamiento de la solicitud usando un MessageHandler como se muestra a continuación:

public class ForceableContentTypeDelegationHandler : DelegatingHandler
{
    protected async override Task<HttpResponseMessage> SendAsync(
                HttpRequestMessage request,
                CancellationToken cancellationToken)
    {
        var someOtherCondition = false;
        var accHeader = request.Headers.GetValues("Accept").FirstOrDefault();
        if (someOtherCondition && accHeader.Contains("application/xml"))
        {
            request.Headers.Remove("Accept");
            request.Headers.Add("Accept", "application/json");
        }
        return await base.SendAsync(request, cancellationToken);
    }
}

Dónde someOtherCondition puede ser cualquier cosa, incluido el tipo de navegador, etc. Esto sería para casos condicionales en los que solo a veces queremos anular la negociación de contenido predeterminada. De lo contrario, según otras respuestas, simplemente eliminaría un formateador innecesario de la configuración.

Deberá registrarlo, por supuesto. Puede hacer esto globalmente:

  public static void Register(HttpConfiguration config) {
      config.MessageHandlers.Add(new ForceableContentTypeDelegationHandler());
  }

o ruta por ruta:

config.Routes.MapHttpRoute(
   name: "SpecialContentRoute",
   routeTemplate: "api/someUrlThatNeedsSpecialTreatment/{id}",
   defaults: new { controller = "SpecialTreatment" id = RouteParameter.Optional },
   constraints: null,
   handler: new ForceableContentTypeDelegationHandler()
);

Y dado que este es un controlador de mensajes, se ejecutará tanto en los extremos de solicitud como de respuesta de la canalización de manera muy similar a un HttpModule. Por lo tanto, podría reconocer fácilmente la anulación con un encabezado personalizado:

public class ForceableContentTypeDelegationHandler : DelegatingHandler
{
    protected async override Task<HttpResponseMessage> SendAsync(
                HttpRequestMessage request,
                CancellationToken cancellationToken)
    {
        var wasForced = false;
        var someOtherCondition = false;
        var accHeader = request.Headers.GetValues("Accept").FirstOrDefault();
        if (someOtherCondition && accHeader.Contains("application/xml"))
        {
            request.Headers.Remove("Accept");
            request.Headers.Add("Accept", "application/json");
            wasForced = true;
        }

        var response =  await base.SendAsync(request, cancellationToken);
        if (wasForced){
          response.Headers.Add("X-ForcedContent", "We overrode your content prefs, sorry");
        }
        return response;
    }
}

Respondido el 06 de diciembre de 15 a las 07:12

Esta es la forma más sencilla que he usado en mis aplicaciones. Agregue las siguientes 3 líneas de código en App_Start\\WebApiConfig.cs in Register función

    var formatters = GlobalConfiguration.Configuration.Formatters;

    formatters.Remove(formatters.XmlFormatter);

    config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));

La API web de Asp.net serializará automáticamente su objeto de retorno a JSON y como el application/json se agrega en el encabezado para que el navegador o el receptor comprendan que está devolviendo el resultado JSON.

contestado el 28 de mayo de 16 a las 11:05

Usar Felipe LeusínLa respuesta durante años, después de una actualización reciente de las bibliotecas centrales y de Json.Net, me encontré con un System.MissingMethodException: SupportedMediaTypes. La solución en mi caso, con suerte útil para otros que experimentan la misma excepción inesperada, es instalar System.Net.Http. NuGet aparentemente lo elimina en algunas circunstancias. Después de una instalación manual, el problema se resolvió.

Respondido 13 Abr '18, 20:04

WebApiConfig es el lugar donde puede configurar si desea generar en json o xml. De forma predeterminada, es xml. En la función de registro, podemos usar HttpConfiguration Formatters para formatear la salida.

System.Net.Http.Headers => MediaTypeHeaderValue("text/html") es necesario para obtener la salida en formato json.

enter image description here

Respondido el 17 de Septiembre de 20 a las 04:09

Estoy asombrado de ver tantas respuestas que requieren codificación para cambiar un caso de uso único (GET) en . API en lugar de usar una herramienta adecuada, lo que debe instalarse una vez y puede usarse para cualquier API (propia o de terceros) y todos los casos de uso.

Entonces la buena respuesta es:

  1. Si solo desea solicitar la instalación de json u otro tipo de contenido Solicitadamente o una herramienta similar y modifique el encabezado Aceptar.
  2. Si también desea usar POST y tiene un json, xml, etc. bien formateado, use una extensión de prueba de API adecuada como Cartero or ARC.

respondido 30 nov., 17:23

Algunos prefieren hacer cosas sin agregar hinchazón en forma de herramientas y bibliotecas adicionales. - tno2007

Sigue siendo incorrecto realizar cambios en la API solo porque alguien está utilizando la herramienta incorrecta para el trabajo. Un navegador web no está diseñado para probar API, ni siquiera para ver el resultado de las API, sino para ver documentos. Es incluso peor si alguien piensa que una herramienta de prueba de API es abultada en lugar de ser parte del kit de herramientas obligatorio para cualquier desarrollador de API, y honestamente, también agregaría desarrolladores frontales porque también necesitan interactuar y experimentar con API. Probablemente tampoco sea suficiente porque el navegador sin complementos no permite establecer encabezados, publicar en una API o incluso inspeccionar encabezados de respuesta. - user3285954

Entiendo lo que dices y no te equivocas. Pero fuera de tema, la razón por la que se le rechaza es el tono en el que responde la pregunta. Suenas muy combativo y te pareces a ese desarrollador que cree que lo sabe todo, y eso es muy desagradable. Estoy seguro de que es un gran desarrollador, a juzgar por sus respuestas. Pero debe aprender, especialmente en un entorno de control de calidad profesional como este, a dirigirse y convencer a las personas de una manera más amigable y humana. Quizás, primero dé la respuesta que quieren, luego explique una mejor manera y motive por qué es mejor. - tno2007

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.