¿Cómo obtengo la API web ASP.NET para devolver JSON en lugar de XML usando Chrome?

1220

Utilizando la API web ASP.NET más reciente , en Chrome veo XML: ¿cómo puedo cambiarlo para solicitar JSON para poder verlo en el navegador? Creo que es solo parte de los encabezados de solicitud, ¿estoy en lo cierto?

naspinski
fuente
8
Aquí hay una discusión para hacer que devolver JSON sea solo el comportamiento predeterminado: github.com/aspnet/Mvc/issues/1765
Natan

Respuestas:

1738

Solo agrego lo siguiente en App_Start / WebApiConfig.csclase en mi proyecto MVC Web API .

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

Eso asegura que obtenga JSON en la mayoría de las consultas, pero puede obtenerlo XMLcuando envía text/xml.

Si es necesario tener la respuesta Content-Typeque application/jsonpor favor verifica la respuesta de Todd a continuación .

NameSpaceestá utilizando System.Net.Http.Headers.

Felipe Leusin
fuente
115
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
16
+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
3
Cuando hice esto, descubrí que los datos proporcionados por un tercero con etiquetas de interrupción HTML terminaron con retornos de carro. El JSON era entonces inválido. Es mejor usar la respuesta aceptada si esto te afecta.
Stonetip
23
Tenga en cuenta que el Content-Typeencabezado de la respuesta seguirá siendo text/html.
Mrchief
78
Esto es horrible El encabezado del tipo de contenido de respuesta debe ser application / json. Esta "solución" lo convierte en texto / html.
meffect
501

Si hace esto en el WebApiConfig, obtendrá JSON de forma predeterminada, pero aún le permitirá devolver XML si pasa text/xmlcomo Acceptencabezado de solicitud

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 comenzar, consulte esta respuesta para obtener detalles sobre cómo incorporarlo.

Glenn Slaven
fuente
51
Solo para tener en cuenta, el comportamiento original es correcto. Las solicitudes de Chrome application/xmltienen una prioridad de 0.9 y */*una prioridad de 0.8. Al eliminar application/xml, elimina la capacidad de la API web de devolver XML si el cliente lo solicita específicamente. por ejemplo, si se envía "Accept: application / xml" le sigue recibir JSON.
Porges
11
¿Soy yo o la primera oración es incorrecta? El código parece eliminar totalmente XML, no simplemente cambiar el valor predeterminado.
NickG
66
@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. Utilizando config.Formatters.XmlFormatter.SupportedMediaTypes.Add (new MediaTypeHeaderValue ("text / html"));
Cohen
1
Entonces, ¿cómo lo hacemos a través de la configuración web para obtener json por defecto y XML si se solicita?
Kyle
44
La respuesta de @Felipse Leusin a continuación es en realidad más corta y funciona mejor.
Ken Smith
314

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

GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings
.Add(new System.Net.Http.Formatting.RequestHeaderMapping("Accept", 
                              "text/html",
                              StringComparison.InvariantCultureIgnoreCase,
                              true, 
                              "application/json"));
dmit77
fuente
66
Esta es la solución más simple y sencilla y Fiddler también detecta el tipo de contenido que se devuelve como josn.
Steve Johnson
44
¡Agradable! ¿Dónde sugerirías poner esto en el código?
Tim Abell
99
Debería ir en WebApiConfig.cs
Animesh
99
Trabajó para mi. Necesitaba agregar un uso de System.Net.Http.Formatting;
bbsimonbb
1
Vinculación para mi propia conveniencia: esta respuesta funciona muy bien con otro paso de configuración que suelo realizar: stackoverflow.com/a/28337589/398630 .
BrainSlugs83
309

Me gusta más el enfoque de Felipe Leusin : asegúrese de que los navegadores obtengan JSON sin comprometer la negociación de contenido de los clientes que realmente desean XML. Lo único que me faltaba era que los encabezados de respuesta todavía contenían tipo de contenido: texto / html. ¿Por qué fue eso un problema? Porque uso la 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 aplicación / 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());
Todd Menier
fuente
24
En el constructor, agregue this.SerializerSettings.Formatting = Formatting.Indented;si desea que esté bien impreso sin una extensión de navegador.
Alastair Maw
10
¿por qué querrías que se imprima bien por cable?
meffect
8
¿No es la respuesta de @ dmit77 mejor (más concisa) que esta?
H.Wolper
8
@eddiegroves, no quieres una bonita impresión sobre el cable. Desea que el servidor envíe la menor cantidad de bits a través del cable (es decir, sin espacios). Luego, desea que el navegador lo formatee bien, con complementos y demás. JavaScript tiene que analizar el JSON por lo general, ¿por qué lo hacen más lenta la introducción de formato innecesaria
meffect
13
Para los googlers que están buscando: no olviden agregar using System.Net.Http.Formattingyusing Newtonsoft.Json
Berriel
186

MVC4 Consejo rápido # 3: eliminar el formateador XML de la API web ASP.Net

En Global.asaxagregar 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();
}
Mansión Yakir
fuente
99
Funciona: mucho mejor tener JSON como predeterminado en lugar de XML.
whitneyland
55
pero ¿puedes devolver xml entonces?
Thomas Stock
99
Lo probé y no puedes. Así que esto está eliminando el soporte de XML ... Se les advirtió, querida gente de Google
Thomas Stock
3
Si echa un vistazo a mi respuesta a continuación, esto permitirá que se devuelva xml si lo desea, pero permite que el sitio responda con JSON al navegador
Glenn Slaven,
3
@GlennSlaven, sí, su respuesta debe ser la marcada como la correcta.
radu florescu
114

En WebApiConfig.cs , agregue al final de la función Registrar :

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

Fuente .

Michael Vashchinsky
fuente
¿XmlFormatter es nuevo en MVC4?
Glenn Slaven
1
En MVC5, esto se puede hacer reemplazando config con GlobalConfiguration.Configuration
Steven
44
Para un proyecto que debe admitir solo JSON y en ningún caso se puede permitir que emita XML, esta es, con mucho, la mejor opción.
Luc C
1
config.Formatters.Add (config.Formatters.JsonFormatter);
Cas Bloem
3
Eso es terrible. - Esto siempre devolverá JSON sin importar qué, incluso si el cliente solicita específicamente XML en el encabezado Content-Type.
BrainSlugs83
94

En Global.asax estoy usando el código a continuación. Mi URI para obtener JSON eshttp://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"));
}
Diganta Kumar
fuente
2
Muy buena. ¿Cuál es su método esperar un parámetro? como localhost: 61044 / api / values ​​/ getdate? json = true, date = 2012-08-01
LT.Nolo
qué tipo de formato de datos devuelve la API web de forma predeterminada. es json o webapi? gracias
Thomas
54

Eche un vistazo a la negociación de contenido en WebAPI. Estas ( Parte 1 y Parte 2 ) publicaciones de blog maravillosamente detalladas y exhaustivas explican cómo funciona.

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

Aaron Daniels
fuente
66
"para que pueda verlo en el navegador"
Spongman
1
@Spongman, sí puedes. Pero use una extensión como REST Client: la mayoría de los navegadores tienen una similar. El tipeo directo de url en un navegador es 1. Demasiado limitante (sin control sobre los encabezados, no se pueden publicar datos, etc.); 2. Incorrecto: el navegador no consume la API web, ya que está destinada a ser consumida; no puede confiar en que la pruebe correctamente. Entonces, de nuevo, un buen complemento de cliente REST solucionaría eso.
Ivaylo Slavov
45

Como la pregunta es específica de Chrome, puede obtener la extensión Postman que le permite configurar el tipo de contenido de la solicitud.

Cartero

Chris S
fuente
En Firefox, simplemente vaya a about: config, busque accept.default y cambie el contenido de la network.http.accept.defaultconfiguración a text/html,application/xhtml+xml,application/json;q=0.9,application/xml;q=0.8,*/*;q=0.7.
Bjartur Thorlacius
O mejor aún, solo text/html,application/xhtml+xml;q=1.0,*/*;q=0.7para evitar que los hosts con errores como Bitbucket sirvan accidentalmente a su navegador JSON en lugar de HTML.
Bjartur Thorlacius
La URL está muerta. Una nueva es chrome.google.com/webstore/detail/postman/… .
Falcon Momot
35

Una opción rápida es utilizar la especialización MediaTypeMapping. Aquí hay 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.

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

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!

jayson.centeno
fuente
1
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 una cadena de consulta:?
Xml
Intenté una serie de estrategias. Tenía una prueba simple para XML y JSON y esto funcionó de
inmediato
23

No use 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, de acuerdo con la solicitud del navegador.

dmyoko
fuente
30
¿Por qué no usar el navegador? Es una herramienta obvia para ello.
Anders Lindén
44
Creo que el punto aquí es correcto e importante: no debemos sobreescribir una parte funcional de la aplicación (la infraestructura MVC WebAPI) si el problema es causado por el cliente. El caso de uso real para una Api se debe usar correctamente (mediante el suministro de encabezados correctos), que es responsabilidad de la aplicación. Sin embargo, no estoy de acuerdo con descartar por completo el navegador: para probar, hay muchas herramientas para casi cualquier navegador (para empezar, las extensiones similares a Rest Client).
Ivaylo Slavov
66
Esto probablemente debería ser un comentario.
bonh
17

La mayoría de las respuestas anteriores tiene mucho sentido. Como ve que los datos se formatean en formato XML, eso significa que se aplica el formateador XML, así que puede ver el formato JSON simplemente eliminando el 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

pavan kumar
fuente
12

Utilicé un filtro de acción global para eliminar Accept: application/xmlcuando el User-Agentencabezado 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.

Roger Lipscombe
fuente
11

La aplicación Chrome "Advanced REST Client" me pareció excelente para trabajar con los servicios REST. Puede establecer el tipo de contenido application/jsonentre otras cosas: cliente REST avanzado

Mike Rowley
fuente
10

El formateador de tipo medio devuelve el formato correcto. Como otros mencionaron, puedes hacer esto en la WebApiConfigclase:

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 más información, consulte:

En caso de que sus acciones devuelvan XML (que es el caso por defecto) y necesita solo un método específico para devolver JSON, puede usar un ActionFilterAttributey 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);
    }
}

Aplicando 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 Attributeen la decoración de la acción y usar solo en [JsonOutput]lugar de [JsonOutputAttribute].

Apilado
fuente
7
        config.Formatters.Remove(config.Formatters.XmlFormatter);
Gaurav Dubey
fuente
3
Si bien este código puede responder la pregunta, proporcionar un contexto adicional sobre cómo y / o por qué resuelve el problema mejoraría el valor a largo plazo de la respuesta. Lea este stackoverflow.com/help/how-to-answer
SR
6

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

debajo WebApiConfig.cs, esto funcionará

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

No me queda claro por qué hay toda esta complejidad en la respuesta. Claro que hay muchas maneras de hacer esto, con QueryStrings, encabezados y opciones ... pero lo que creo que es la mejor práctica es simple. Solicitas una URL simple (ej http://yourstartup.com/api/cars.:) y a cambio obtienes JSON. Obtiene 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 seguir porque esta respuesta aceptada no funciona exactamente. Encontré una respuesta que creo que es demasiado simple para no ser la mejor:

Establecer el formateador predeterminado de WebAPI

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 valores predeterminados de .NET, o tal vez creados en otro lugar (por alguien más en mi proyecto)? De todos modos, espero que esto ayude.

Mella
fuente
5

Aquí hay una solución similar a la de jayson.centeno y otras respuestas, pero usando la extensión integrada 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 se orientó 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 OData y devuelve el Content-Type: application/json; charset=utf-8encabezado en la respuesta.

Le permite virar &$format=jsono &$format=xmlal final de su uri cuando prueba con un navegador. No interfiere con otros comportamientos esperados cuando se utiliza un cliente que no es del navegador donde puede configurar sus propios encabezados.

mdisibio
fuente
5

Puedes usar lo siguiente:

GlobalConfiguration.Configuration.Formatters.Clear();
GlobalConfiguration.Configuration.Formatters.Add(new JsonMediaTypeFormatter());
Akshay Kapoor
fuente
Si está creando una aplicación WebAPI para simplemente pasar mensajes JSON, considere esta respuesta.
allen1
4

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

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


          ............................
      }
}
MD Sabbir Ahamed
fuente
3

Simplemente cambias App_Start/WebApiConfig.csasí:

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}"
       );
    }
vaheeds
fuente
Eliminar un formateador generalmente no es una buena idea, está eliminando la funcionalidad.
naspinski
En realidad, en este caso, funciona bien para mí, también muchos otros sugieren una forma como esta. ¡Lo aprendí del libro myview.rahulnivi.net/building-spa-angular-mvc-5 !
vaheeds
2

Desde MSDN Creación de una aplicación de página única con ASP.NET y AngularJS (aproximadamente 41 minutos).

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 ser actual, lo probé y funcionó.

lko
fuente
2

Ha pasado un tiempo desde que se hizo esta pregunta (y se respondió), pero otra opción es anular el encabezado Aceptar en el servidor durante el procesamiento de la solicitud utilizando 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);
    }
}

Donde someOtherConditionpuede haber cualquier cosa, incluido el tipo de navegador, etc. Esto sería para casos condicionales donde 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. Puedes 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 manejador de mensajes, se ejecutará tanto en el final de la solicitud como en el de respuesta de forma similar a un HttpModule. Para que pueda 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;
    }
}
rismo
fuente
2

Aquí está la forma más fácil que he usado en mis aplicaciones. Agregar a continuación 3 líneas de código App_Start\\WebApiConfig.csen Registerfunció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 devuelto a JSON y, a medida que application/jsonse agregue en el encabezado, el navegador o el receptor comprenderán que está devolviendo el resultado JSON.

Vikas Bansal
fuente
1

WebApiConfig es el lugar donde puede configurar si desea generar en json o xml. por defecto 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. ingrese la descripción de la imagen aquí

rocky_pps
fuente
1

Utilizando la respuesta de Felipe Leusin durante años, después de una actualización reciente de las bibliotecas principales y de Json.Net, me encontré con System.MissingMethodException: SupportedMediaTypes. La solución en mi caso, con suerte útil para otros que experimenten 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ó.

Charles Burns
fuente
-3

Me sorprende ver tantas respuestas que requieren codificación para cambiar un solo caso de uso (GET) en una API en lugar de usar una herramienta adecuada que debe instalarse una vez y puede usarse para cualquier API (propia o de terceros) y todo casos de uso

Entonces la buena respuesta es:

  1. Si solo desea solicitar json u otro tipo de contenido, instale Requestly o una herramienta similar y modifique el encabezado Aceptar.
  2. Si también quiere usar POST y tiene un formato json, xml, etc. bien formateado, use una extensión de prueba API adecuada como Postman o ARC .
usuario3285954
fuente
Algunos prefieren hacer cosas sin agregar hinchazón en forma de herramientas y bibliotecas adicionales.
tno2007
Todavía es incorrecto realizar cambios en la API solo porque alguien está usando la herramienta incorrecta para el trabajo. Un navegador web no está diseñado para probar las API, ni siquiera para ver el resultado de las API sino para ver los documentos. Es aún peor si alguien piensa que una herramienta de prueba de API está llena en lugar de ser parte del kit de herramientas obligatorio para cualquier desarrollador de API, y sinceramente, también agregaría desarrolladores front-end porque también necesitan interactuar y experimentar con API. Probablemente tampoco sea suficiente porque el navegador sin complementos no permite configurar encabezados, publicar en una API o incluso inspeccionar encabezados de respuesta.
user3285954
Entiendo lo que dices y no te equivocas. Pero solo fuera de tema, la razón por la que te votan en contra es el tono en el que respondes la pregunta. Suenas muy combativo y te encuentras como ese desarrollador que cree que lo sabe todo, y eso es muy desagradable. Estoy seguro de que eres un gran desarrollador, a juzgar por tus respuestas. Pero debe aprender, especialmente en un entorno de control de calidad profesional como este, para abordar y convencer a las personas de una manera más amigable y humana. Quizás, primero den la respuesta que desean, luego expliquen una mejor manera y motiven por qué es mejor.
tno2007