Como faço para que a API da Web do ASP.NET retorne JSON em vez de XML usando o Chrome?

1220

Usando a API da Web mais recente do ASP.NET , no Chrome , estou vendo o XML - como posso alterá-lo para solicitar o JSON para que eu possa visualizá-lo no navegador? Eu acredito que é apenas parte dos cabeçalhos da solicitação, estou correto nisso?

naspinski
fonte
8
Há uma discussão aqui para tornar o retorno do JSON apenas o comportamento padrão: github.com/aspnet/Mvc/issues/1765
Natan

Respostas:

1738

Acabei de adicionar o seguinte na App_Start / WebApiConfig.csaula no meu projeto de MVC Web API .

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

Isso garante que você obtenha o JSON na maioria das consultas, mas poderá obtê- XMLlo quando enviar text/xml.

Se você precisa ter a resposta Content-Typecomo application/jsonpor favor, verifique a resposta de Todd abaixo .

NameSpaceestá usando System.Net.Http.Headers.

Felipe Leusin
fonte
115
Essa é uma resposta surpreendentemente ignorada e, embora a pergunta original não tenha sido totalmente clara, isso torna o JSON diretamente a resposta padrão para um navegador da Web (que envia Accept: text / html). Bom trabalho.
gregmac
16
+1 De longe, a melhor resposta. Eu imagino que há muitas pessoas que optam por remover completamente o XML apenas porque não vêem o JSON no navegador.
Derek Hunziker
3
Descobri quando fiz isso que os dados fornecidos por terceiros com tags de quebra de HTML terminaram com retornos de carro. O JSON era então inválido. Melhor usar a resposta aceita se isso afetar você.
Stonetip
23
Observe que o Content-Typecabeçalho da resposta ainda estará text/html.
Mrchief
78
Isto é horrível. O cabeçalho do tipo de conteúdo de resposta deve ser application / json. Esta "solução" torna texto / html.
meffect
501

Se você fizer isso no WebApiConfigJSON, obterá JSON por padrão, mas ainda permitirá que você retorne XML se você passar text/xmlcomo o Acceptcabeçalho da solicitação

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);
    }
}

Se você não estiver usando o tipo de projeto MVC e, portanto, não tiver essa classe, consulte esta resposta para obter detalhes sobre como incorporá-la.

Glenn Slaven
fonte
51
Apenas para observar, o comportamento original está correto. Solicitações do Chrome application/xmlcom uma prioridade de 0,9 e */*com uma prioridade de 0,8. Ao remover, application/xmlvocê remove a capacidade da API da Web retornar XML, se o cliente solicitar isso especificamente. por exemplo, se você enviar "Accept: application / xml", você ainda receberá JSON.
PORGES
11
Sou eu ou a primeira frase está incorreta? O código parece remover totalmente o XML, não simplesmente alterar o padrão.
NickG
6
@ NickG: uma solução que é negligenciada aqui e o IMHO é uma opção muito melhor (manter application / xml) é a solução proposta por Felipe Leusin mais abaixo nesta página. Usando config.Formatters.XmlFormatter.SupportedMediaTypes.Add (new MediaTypeHeaderValue ("text / html"));
Cohen
1
Então, como fazemos isso via web config para obtermos json por padrão e XML, se solicitado?
Kyle
4
A resposta do @Felipse Leusin abaixo é realmente mais curta e funciona melhor.
Ken Smith
314

O uso do RequestHeaderMapping funciona ainda melhor, porque também define o Content-Type = application/jsoncabeçalho de resposta, o que permite ao Firefox (com o complemento JSONView) formatar a resposta como JSON.

GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings
.Add(new System.Net.Http.Formatting.RequestHeaderMapping("Accept", 
                              "text/html",
                              StringComparison.InvariantCultureIgnoreCase,
                              true, 
                              "application/json"));
dmit77
fonte
6
Essa é a solução mais enxuta e simples e o Fiddler também detecta o tipo de conteúdo que está sendo retornado como josn.
9788 Steve Jobs
4
Agradável! Onde você sugeriria colocar isso no código?
Tim Abell
9
Deve ir no WebApiConfig.cs
Animesh
9
Trabalhou para mim. Eu precisava adicionar um usando System.Net.Http.Formatting;
precisa saber é o seguinte
1
Vinculando para minha própria conveniência: Esta resposta funciona bem com outra etapa de configuração que normalmente realizo: stackoverflow.com/a/28337589/398630 .
precisa saber é o seguinte
309

Eu gosto mais da abordagem de Felipe Leusin - certifique-se de que os navegadores obtenham JSON sem comprometer a negociação de conteúdo de clientes que realmente desejam XML. A única peça que faltava para mim era que os cabeçalhos de resposta ainda continham o tipo de conteúdo: text / html. Por que isso foi um problema? Porque eu uso a extensão JSON Formatter Chrome , que inspeciona o tipo de conteúdo, e não recebo a formatação bonita com a qual estou acostumado. Corrigi isso com um formatador simples e personalizado que aceita solicitações de texto / html e retorna respostas application / 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");
    }
}

Registre-se assim:

config.Formatters.Add(new BrowserJsonFormatter());
Todd Menier
fonte
24
No construtor, adicione this.SerializerSettings.Formatting = Formatting.Indented;se você deseja que ele seja impresso sem uma extensão do navegador.
Alastair Maw
10
por que você quer que ela imprima por cima do fio?
meffect
8
Não é @ dmit77 's Resposta melhor (mais conciso) do que este?
H.Wolper
8
@eddiegroves você não quer uma impressão bonita sobre o fio. Você deseja que o servidor envie a menor quantidade de bits pela conexão (ou seja: sem espaços). Então você quer que o navegador o formate bem, com complementos e coisas do tipo. Javascript precisa analisar o JSON normalmente, por que torná-lo mais lento através da introdução desnecessária formatação
meffect
13
Para os Googlers que estão procurando: não se esqueça de fazer using System.Net.Http.Formattingeusing Newtonsoft.Json
Berriel
186

Dica rápida do MVC4 nº 3 - Removendo o formatador XML da API da Web do ASP.Net

Em Global.asaxadicionar a linha:

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

igual a:

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

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

    BundleTable.Bundles.RegisterTemplateBundles();
    GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
}
Yakir Manor
fonte
9
Funciona - muito melhor ter JSON como padrão em vez de XML.
precisa saber é o seguinte
5
mas você ainda pode retornar xml então?
Thomas Stock
99
Eu testei e você não pode. Portanto, esta é a remoção de suporte XML .. Ye ser avisado, queridos google pessoas
Thomas Stock
3
Se você tiver uma olhada na minha resposta abaixo, isso permitirá que xml ainda ser devolvido se você quiser, mas permite que respondem site com JSON para o navegador
Glenn Slaven
3
@ GlennSlaven, sim, sua resposta deve ser a marcada como a correta.
Radu florescu 14/10/12
114

No WebApiConfig.cs , adicione ao final da função Register :

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

Fonte .

Michael Vashchinsky
fonte
O XmlFormatter é novo no MVC4?
Glenn Slaven
1
No MVC5, isso pode ser feito substituindo a configuração pelo GlobalConfiguration.Configuration
Steven
4
Para um projeto que deve suportar apenas JSON e, sob nenhuma circunstância, é permitido emitir XML, essa é de longe a melhor opção.
Luc C
1
config.Formatters.Add (config.Formatters.JsonFormatter);
precisa saber é o seguinte
3
Isso é terrível. - Isso sempre retornará JSON, não importa o que aconteça, mesmo se o cliente solicitar especificamente XML no cabeçalho Content-Type.
BrainSlugs83
94

No Global.asax , estou usando o código abaixo. Meu URI para obter JSON é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"));
}
Diganta Kumar
fonte
2
Muito bom. Qual é o seu método espera um parâmetro? Como localhost: 61044 / api / values ​​/ getdate? json = true, date =
01/08/2012
que tipo de formato de API de dados da Web retorna por padrão. é json ou webapi? graças
Thomas
54

Veja a negociação de conteúdo na WebAPI. Esses posts ( parte 1 e parte 2 ) maravilhosamente detalhados e detalhados explicam como funciona.

Em resumo, você está certo e só precisa definir os cabeçalhos Acceptou Content-Typesolicitar. Como sua ação não está codificada para retornar um formato específico, você pode configurá-lo Accept: application/json.

Aaron Daniels
fonte
6
"para que eu possa visualizá-lo no navegador"
Spongman 05/03
1
@ Spongman, sim você pode. Mas use uma extensão como o Cliente REST - a maioria dos navegadores tem uma como essa. A digitação direta de url em um navegador é 1. Limitada demais (sem controle sobre cabeçalhos, não é possível postar dados e etc); 2. Incorreto - O navegador não consome a API da Web como se destina a ser consumida - você não pode confiar nela testando-a corretamente. Portanto, novamente, um bom complemento de cliente REST consertaria isso.
Ivaylo Slavov
45

Como a pergunta é específica do Chrome, você pode obter a extensão Postman, que permite definir o tipo de conteúdo da solicitação.

Carteiro

Chris S
fonte
No Firefox, basta acessar about: config, procurar accept.default e alterar o conteúdo da network.http.accept.defaultconfiguração para text/html,application/xhtml+xml,application/json;q=0.9,application/xml;q=0.8,*/*;q=0.7.
Bjartur Thorlacius
Ou melhor ainda, apenas text/html,application/xhtml+xml;q=1.0,*/*;q=0.7para evitar que hosts com erros, como o Bitbucket, atendam acidentalmente o JSON do navegador em vez de HTML.
Bjartur Thorlacius
O URL está morto. Um novo é chrome.google.com/webstore/detail/postman/… .
Falcon Momot
35

Uma opção rápida é usar a especialização MediaTypeMapping. Aqui está um exemplo do uso de QueryStringMapping no evento Application_Start:

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

Agora, sempre que o URL contiver a string de consulta? A = b, nesse caso, a resposta Json será mostrada no navegador.

suhair
fonte
2
Isso foi muito útil. Você também pode usar UriPathExtensionMapping vez de QueryStringMapping se você quiser usar path.to/item.json
nuzzolilo
32

Esse código faz do json meu padrão e me permite usar o formato XML também. Vou apenas acrescentar o xml=true.

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

Obrigado a todos!

jayson.centeno
fonte
1
Essa é a resposta mais flexível (e realmente deve ser a configuração padrão atualmente). Para adicionar a esta resposta, JSON é o padrão, inclusive do navegador. Para visualizar XML, adicione a string de consulta:? Xml = true
raider33 30/03
Tentei várias estratégias. Teve um teste simples para XML e JSON e isso funcionou
imediatamente
23

Não use seu navegador para testar sua API.

Em vez disso, tente usar um cliente HTTP que permita especificar sua solicitação, como CURL ou mesmo o Fiddler.

O problema com esse problema está no cliente, não na API. A API da web se comporta corretamente, de acordo com a solicitação do navegador.

dmyoko
fonte
30
Por que não usar o navegador? É uma ferramenta óbvia para isso.
Anders Lindén
4
Acho que o ponto aqui é correto e importante - não devemos sobrecarregar uma parte funcional do aplicativo (a infraestrutura MVC WebAPI) se o problema for causado pelo cliente. O caso de uso real de uma API deve ser usado corretamente (fornecendo cabeçalhos corretos), que é de responsabilidade do aplicativo. Mas eu discordo de descartar completamente o navegador - para testar, existem muitas ferramentas para praticamente qualquer navegador (extensões do tipo Rest Client, para começar).
Ivaylo Slavov
6
Provavelmente isso deve ser um comentário.
Bonh 14/05
17

A maioria das respostas acima faz todo sentido. Como você vê dados sendo formatados no formato XML, isso significa que o formatador XML é aplicado, portanto, você pode ver o formato JSON apenas removendo o XMLFormatter do 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();
        }

já que JSON é o formato padrão

Pavan Kumar
fonte
12

Usei um filtro de ação global para remover Accept: application/xmlquando o User-Agentcabeçalho contém "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
fonte
11

Achei o aplicativo Chrome "Advanced REST Client" excelente para trabalhar com serviços REST. Você pode definir o Tipo de conteúdo para, application/jsonentre outras coisas: Cliente REST avançado

Mike Rowley
fonte
10

O retorno do formato correto é feito pelo formatador de tipo de mídia. Como outros mencionados, você pode fazer isso na WebApiConfigclasse:

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 mais, verifique:

Caso suas ações estejam retornando XML (que é o caso por padrão) e você precise apenas de um método específico para retornar JSON, poderá usar um ActionFilterAttributee aplicá-lo a essa ação 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ção:

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

Observe que você pode omitir a palavra Attributena decoração da ação e usar apenas em [JsonOutput]vez de [JsonOutputAttribute].

Empilhados
fonte
7
        config.Formatters.Remove(config.Formatters.XmlFormatter);
Gaurav Dubey
fonte
3
Embora esse código possa responder à pergunta, fornecer um contexto adicional sobre como e / ou por que resolve o problema melhoraria o valor a longo prazo da resposta. Por favor, leia este stackoverflow.com/help/how-to-answer
SR
6

conforme a versão mais recente do ASP.net WebApi 2,

abaixo WebApiConfig.cs, isso vai funcionar

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

Não está claro para mim por que existe toda essa complexidade na resposta. Claro, existem várias maneiras de fazer isso, com QueryStrings, cabeçalhos e opções ... mas o que eu acredito ser a melhor prática é simples. Você solicita uma URL simples (ex:) http://yourstartup.com/api/carse, em troca, obtém JSON. Você obtém o JSON com o cabeçalho de resposta adequado:

Content-Type: application/json

Ao procurar uma resposta para essa mesma pergunta, encontrei esse tópico e tive que continuar porque essa resposta aceita não funciona exatamente. Eu encontrei uma resposta que considero simples demais para não ser a melhor:

Defina o formatador WebAPI padrão

Vou adicionar minha dica aqui também.

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());
}

Eu tenho uma pergunta de onde vêm os padrões (pelo menos os que estou vendo). Eles são padrões do .NET ou talvez criados em outro lugar (por outra pessoa no meu projeto). De qualquer forma, espero que isso ajude.

usuario
fonte
5

Aqui está uma solução semelhante à de jayson.centeno e outras respostas, mas usando a extensão interna 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
 }

A solução foi voltada principalmente para o suporte ao formato $ para OData nas primeiras versões do WebApi, mas também se aplica à implementação não OData e retorna o Content-Type: application/json; charset=utf-8cabeçalho na resposta.

Ele permite a aderência &$format=jsonou &$format=xmlo final da sua uri ao testar com um navegador. Ele não interfere com outro comportamento esperado ao usar um cliente que não é do navegador, onde você pode definir seus próprios cabeçalhos.

mdisibio
fonte
5

Você pode usar como abaixo:

GlobalConfiguration.Configuration.Formatters.Clear();
GlobalConfiguration.Configuration.Formatters.Add(new JsonMediaTypeFormatter());
Akshay Kapoor
fonte
Se você estiver criando um aplicativo WebAPI apenas para transmitir mensagens JSON, considere esta resposta.
allen1
4

Basta adicionar essas duas linhas de código na sua classe 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
fonte
3

Você acabou de mudar o App_Start/WebApiConfig.csseguinte:

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
fonte
A remoção de um formatador geralmente não é uma boa ideia, você está removendo a funcionalidade.
naspinski
Na verdade, neste caso, funciona bem para mim, também muitos outros sugerem uma maneira como esta. Eu aprendi com o livro myview.rahulnivi.net/building-spa-angular-mvc-5 !
vaheeds
2

Do MSDN Criando um aplicativo de página única com ASP.NET e 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();
    }

Deve ser atual, eu tentei e funcionou.

lko
fonte
2

Algum tempo se passou desde que essa pergunta foi feita (e respondida), mas outra opção é substituir o cabeçalho Accept no servidor durante o processamento da solicitação usando um MessageHandler, como abaixo:

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);
    }
}

Onde someOtherConditionpode haver qualquer coisa, incluindo o tipo de navegador, etc. Isso seria para casos condicionais em que apenas às vezes queremos substituir a negociação de conteúdo padrão. Caso contrário, como em outras respostas, você simplesmente removeria um formatador desnecessário da configuração.

Você precisará registrá-lo, é claro. Você pode fazer isso globalmente:

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

ou em uma rota por rota:

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

E como esse é um manipulador de mensagens, ele será executado nas extremidades de solicitação e resposta do pipeline, como um HttpModule. Assim, você pode reconhecer facilmente a substituição com um cabeçalho 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;
    }
}
arriscar
fonte
2

Aqui está a maneira mais fácil que eu usei em meus aplicativos. Adicione abaixo de 3 linhas de código App_Start\\WebApiConfig.csem Registerfunção

    var formatters = GlobalConfiguration.Configuration.Formatters;

    formatters.Remove(formatters.XmlFormatter);

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

A API da web do Asp.net serializa automaticamente o objeto retornado para JSON e, conforme application/jsoné adicionado no cabeçalho, para que o navegador ou o destinatário entenda que você está retornando o resultado JSON.

Vikas Bansal
fonte
1

WebApiConfig é o local em que você pode configurar se deseja gerar em json ou xml. por padrão, é xml. na função de registro, podemos usar os Formadores de Configuração Http para formatar a saída. System.Net.Http.Headers => MediaTypeHeaderValue ("text / html") é necessário para obter a saída no formato json. insira a descrição da imagem aqui

rocky_pps
fonte
1

Usando a resposta de Felipe Leusin por anos, após uma recente atualização das principais bibliotecas e do Json.Net, encontrei um System.MissingMethodException: SupportedMediaTypes. A solução no meu caso, espero que útil para outras pessoas que enfrentam a mesma exceção inesperada, é instalar System.Net.Http. Aparentemente, o NuGet o remove em algumas circunstâncias. Após uma instalação manual, o problema foi resolvido.

Charles Burns
fonte
-3

Estou surpreso ao ver tantas respostas exigindo que a codificação altere um único caso de uso (GET) em uma API, em vez de usar uma ferramenta adequada, que deve ser instalada uma vez e pode ser usada para qualquer API (própria ou de terceiros) e todas casos de uso.

Portanto, a boa resposta é:

  1. Se você deseja solicitar apenas json ou outro tipo de conteúdo, instale Requestly ou uma ferramenta semelhante e modifique o cabeçalho Accept.
  2. Se você deseja usar o POST também e possui json, xml etc. bem formatados, use uma extensão de teste de API adequada, como Postman ou ARC .
user3285954
fonte
Alguns preferem fazer as coisas sem adicionar inchaço na forma de ferramentas e bibliotecas extras.
tno2007 24/02
Ainda é errado fazer alterações na API apenas porque alguém está usando a ferramenta errada para o trabalho. Um navegador da web não foi projetado para testar APIs, nem mesmo para exibir a saída das APIs, mas para exibir documentos. É ainda pior se alguém achar que uma ferramenta testadora de API é inchada em vez de fazer parte do kit de ferramentas obrigatório para qualquer desenvolvedor de API, e sinceramente eu adicionaria desenvolvedores de front-end também porque eles precisam interagir e experimentar também com APIs. Provavelmente também não é suficiente, porque o navegador sem suplementos não permite definir cabeçalhos, publicar em uma API ou até mesmo inspecionar cabeçalhos de resposta.
user3285954 24/02
Entendo o que você está dizendo e não está errado. Mas apenas fora do tópico, a razão pela qual você recebe votos negativos é o tom em que você responde à pergunta. Você parece muito combativo e aparece como aquele desenvolvedor que acha que sabe tudo, e isso é muito desagradável. Estou certo de que você é um ótimo desenvolvedor, a julgar pelas suas respostas. Mas você deve aprender, especialmente em um ambiente profissional de controle de qualidade como esse, a abordar e convencer as pessoas de uma maneira mais amigável e humana. Talvez, primeiro dê a resposta que eles querem, depois explique uma maneira melhor e motive por que é melhor.
tno2007 25/02