Come posso ottenere l'API Web ASP.NET per restituire JSON anziché XML usando Chrome?


1220

Utilizzando la più recente API Web ASP.NET , in Chrome visualizzo XML: come posso modificarlo per richiedere JSON in modo da poterlo visualizzare nel browser? Credo che sia solo una parte delle intestazioni della richiesta, ho ragione?


8
C'è una discussione qui per rendere il ritorno di JSON solo il comportamento predefinito: github.com/aspnet/Mvc/issues/1765
Natan

Risposte:


1738

Ho appena aggiunto quanto segue in App_Start / WebApiConfig.csclasse nel mio progetto API Web MVC .

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

Questo ti assicura di ricevere JSON sulla maggior parte delle query, ma puoi ottenerlo XMLquando invii text/xml.

Se avete bisogno di avere la risposta Content-Type, come application/jsonsi prega di controllare la risposta di Todd di seguito .

NameSpacesta usando System.Net.Http.Headers.


115
Questa è una risposta sorprendentemente trascurata, e sebbene la domanda originale non fosse del tutto chiara, questo rende direttamente JSON la risposta predefinita per un browser web (che invia Accept: text / html). Buon lavoro.
Gregreg

16
+1 Di gran lunga la risposta migliore. Immagino che ci siano un sacco di persone che scelgono di rimuovere completamente XML solo perché non vedono JSON nel browser.
Derek Hunziker,

3
Quando ho fatto questo, ho scoperto che i dati forniti da una terza parte con tag di interruzione HTML in esso finivano con ritorni a capo. JSON non era quindi valido. Meglio usare la risposta accettata se questo ti riguarda.
Stonetip

23
Nota che l' Content-Typeintestazione della risposta sarà comunque text/html.
Mrchief,

78
Questo è orribile. L'intestazione del tipo di contenuto della risposta deve essere application / json. Questa "soluzione" lo rende text / html.
Meffect,

501

Se lo fai nel WebApiConfigotterrai JSON per impostazione predefinita, ma ti consentirà comunque di restituire XML se passi text/xmlcome Acceptintestazione della richiesta

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 non stai usando il tipo di progetto MVC e quindi non hai avuto questa classe per cominciare, vedi questa risposta per i dettagli su come incorporarlo.


51
Solo per notare, il comportamento originale è corretto. Chrome richiede application/xmlcon una priorità di 0,9 e */*con una priorità di 0,8. Rimuovendo application/xmlsi rimuove la possibilità per l'API Web di restituire XML se il client lo richiede in modo specifico. ad es. se invii "Accetta: application / xml" riceverai comunque JSON.
porges

11
Sono io o la prima frase non è corretta? Il codice sembra rimuovere totalmente XML, non semplicemente modificare il valore predefinito.
NickG

6
@NickG: una soluzione trascurata qui e IMHO è un'opzione molto migliore (mantenendo application / xml) è la soluzione proposta da Felipe Leusin in basso in questa pagina. Utilizzando config.Formatters.XmlFormatter.SupportedMediaTypes.Add (new MediaTypeHeaderValue ("text / html"));
Cohen,

1
Quindi, come possiamo farlo tramite la configurazione web in modo da ottenere json per impostazione predefinita e XML se richiesto?
Kyle,

4
@La risposta di Leusin di seguito è in realtà più breve e funziona meglio.
Ken Smith,

314

L'uso di RequestHeaderMapping funziona ancora meglio, perché imposta anche l' Content-Type = application/jsonintestazione della risposta, che consente a Firefox (con il componente aggiuntivo JSONView) di formattare la risposta come JSON.

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

6
Questa è la soluzione più snella e semplice e Fiddler rileva anche il tipo di contenuto che viene restituito come josn.
Steve Johnson,

4
Bello! Dove consiglieresti di inserirlo nel codice?
Tim Abell,

9
Dovrebbe andare in WebApiConfig.cs
Animesh,

9
Ha funzionato per me. Ho dovuto aggiungere un usando System.Net.Http.Formatting;
bbsimonbb,

1
Collegamento per mia comodità: questa risposta gioca bene con un altro passo di installazione che di solito eseguo : stackoverflow.com/a/28337589/398630 .
BrainSlugs83,

309

Mi piace molto l'approccio di Felipe Leusin : assicurarsi che i browser ottengano JSON senza compromettere la negoziazione dei contenuti da parte dei clienti che desiderano effettivamente XML. L'unico pezzo mancante per me era che le intestazioni di risposta contenevano ancora tipo di contenuto: testo / html. Perché è stato un problema? Perché utilizzo l' estensione JSON Formatter per Chrome , che controlla il tipo di contenuto e non ottengo la formattazione graziosa a cui sono abituato. Ho risolto questo problema con un semplice formatter personalizzato che accetta richieste text / html e restituisce risposte 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");
    }
}

Registrati in questo modo:

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

24
Nel costruttore aggiungere this.SerializerSettings.Formatting = Formatting.Indented;se lo si desidera piuttosto stampato senza un'estensione del browser.
Alastair Maw,

10
perché vorresti che stampasse piuttosto sul filo?
Meffect,

8
La risposta di @dmit77 non è migliore (più concisa) di questa?
H.Wolper,

8
@eddiegroves non vuoi una bella stampa sul filo. Volete che il server invii la minima quantità di bit sul filo (cioè: nessuno spazio). Quindi vuoi che il browser lo formatta bene, con componenti aggiuntivi e così via. Javascript deve analizzare JSON di solito, perché renderlo più lento introducendo formattazioni non necessarie
meffect,

13
Per i googler che stanno cercando: non dimenticare di aggiungere using System.Net.Http.Formattingeusing Newtonsoft.Json
Berriel,

186

Suggerimento rapido MVC4 n. 3: rimozione del formatter XML dall'API Web ASP.Net

In Global.asaxaggiungi la riga:

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

così:

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

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

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

9
Funziona: molto meglio avere JSON come predefinito anziché XML.
Whitneyland,

5
ma puoi comunque restituire xml?
Thomas Stock

99
L'ho provato e non puoi. Quindi questo sta rimuovendo il supporto XML. State attenti, caro google
Thomas Stock

3
Se dai un'occhiata alla mia risposta di seguito, ciò consentirà di restituire xml se vuoi, ma consente al sito di rispondere con JSON al browser
Glenn Slaven

3
@GlennSlaven sì, la tua risposta dovrebbe essere quella contrassegnata come quella corretta.
Radu Florescu,

114

In WebApiConfig.cs , aggiungi alla fine della funzione Register :

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

Fonte .


XmlFormatter è nuovo in MVC4?
Glenn Slaven,

1
In MVC5, questo può essere fatto sostituendo config con GlobalConfiguration.Configuration
Steven

4
Per un progetto che deve supportare solo JSON e in nessuna circostanza è consentito emettere XML, questa è di gran lunga l'opzione migliore.
Luc C

1
config.Formatters.Add (config.Formatters.JsonFormatter);
Cas Bloem,

3
È terribile. - Ciò restituirà sempre JSON, qualunque cosa accada, anche se il client richiede specificamente XML nell'intestazione Content-Type.
BrainSlugs83

94

Nel Global.asax sto usando il codice qui sotto. Il mio URI per ottenere 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"));
}

2
Grande. Qual è il tuo metodo prevede un parametro? come localhost: 61044 / api / valori / getdate? json = true, data = 2012-08-01
LT.Nolo

che tipo di formato di dati API web restituiscono per impostazione predefinita. è json o webapi? grazie
Thomas

54

Dai un'occhiata alla negoziazione dei contenuti nella WebAPI. Questi post di blog ( Parte 1 e Parte 2 ) meravigliosamente dettagliati e completi spiegano come funziona.

In breve, hai ragione e devi solo impostare le intestazioni Accepto Content-Typerichiedere. Dato che la tua azione non è codificata per restituire un formato specifico, puoi impostare Accept: application/json.


6
"Così posso vederlo nel browser"
Spongman

1
@Spongman, sì, puoi. Ma usa un'estensione come REST Client: la maggior parte dei browser ne ha una simile. La digitazione diretta di url in un browser è 1. Troppo limitante (nessun controllo sulle intestazioni, impossibile pubblicare dati ecc.); 2. Inesatto: il browser non consuma l'API Web in quanto è destinato a essere consumato: non è possibile fare affidamento su di esso per testarlo correttamente. Quindi, ancora una volta, un buon componente aggiuntivo client REST lo risolverebbe.
Ivaylo Slavov,

45

Poiché la domanda è specifica di Chrome, puoi ottenere l' estensione Postman che ti consente di impostare il tipo di contenuto della richiesta.

Postino


In Firefox, vai su about: config, cerca accept.default e modifica il contenuto della network.http.accept.defaultconfigurazione in text/html,application/xhtml+xml,application/json;q=0.9,application/xml;q=0.8,*/*;q=0.7.
Bjartur Thorlacius,

O meglio ancora, solo text/html,application/xhtml+xml;q=1.0,*/*;q=0.7per evitare che host buggy come Bitbucket servano accidentalmente il tuo browser JSON al posto di HTML.
Bjartur Thorlacius,


35

Un'opzione rapida è utilizzare la specializzazione MediaTypeMapping. Ecco un esempio dell'uso di QueryStringMapping nell'evento Application_Start:

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

Ora, ogni volta che l'URL contiene la stringa di query? A = b in questo caso, la risposta Json verrà mostrata nel browser.


2
Questo è stato molto utile. Puoi anche usare UriPathExtensionMapping invece di QueryStringMapping se vuoi usare path.to/item.json
nuzzolilo il

32

Questo codice rende json il mio valore predefinito e mi consente di utilizzare anche il formato XML. Aggiungerò semplicemente il xml=true.

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

Grazie a tutti!


1
Questa è la risposta più flessibile (e attualmente dovrebbe essere la configurazione predefinita). Per aggiungere a questa risposta, JSON è l'impostazione predefinita, incluso dal browser. Per visualizzare XML, aggiungi la stringa di query
:? Xml

Ho provato una serie di strategie. Aveva un semplice test sia per XML che per JSON e questo ha funzionato fuori dagli schemi
pat capozzi il

23

Non utilizzare il browser per testare l'API.

Invece, prova a utilizzare un client HTTP che ti consente di specificare la tua richiesta, come CURL o persino Fiddler.

Il problema con questo problema è nel client, non nell'API. L'API Web si comporta correttamente, in base alla richiesta del browser.


30
Perché non usare il browser? È uno strumento ovvio per questo.
Anders Lindén,

4
Penso che il punto qui sia corretto e importante: non dovremmo correggere una parte funzionante dell'applicazione (l'infrastruttura WebAPI MVC) se il problema è causato dal client. Il vero caso d'uso di un'API deve essere utilizzato correttamente (fornendo le intestazioni corrette), che è la responsabilità dell'applicazione. Non sono d'accordo con lo scartare completamente il browser, tuttavia, per i test, ci sono molti strumenti per quasi tutti i browser (per cominciare, estensioni simili a quelle del client).
Ivaylo Slavov,

6
Questo dovrebbe probabilmente essere un commento.
bonh,

17

La maggior parte delle risposte sopra ha perfettamente senso. Dato che stai vedendo che i dati sono formattati in formato XML, ciò significa che viene applicato il formattatore XML, quindi puoi vedere il formato JSON semplicemente rimuovendo XMLFormatter dal parametro HttpConfiguration come

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

poiché JSON è il formato predefinito


12

Ho usato un filtro di azione globale per rimuovere Accept: application/xmlquando l' User-Agentintestazione 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();
    }
}

Sembra funzionare.


11

Ho trovato l'app Chrome "Advanced REST Client" eccellente per lavorare con i servizi REST. È possibile impostare Content-Type su application/jsontra le altre cose: client REST avanzato


10

La restituzione del formato corretto viene eseguita dal formattatore del tipo di supporto. Come altri hanno già detto, puoi farlo in 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"));

        ...
    }
}

Per di più, controlla:

Nel caso in cui le tue azioni restituiscano XML (che è il caso per impostazione predefinita) e hai bisogno solo di un metodo specifico per restituire JSON, puoi quindi utilizzare un ActionFilterAttributee applicarlo a quell'azione specifica.

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

Applicando all'azione:

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

Nota che puoi omettere la parola Attributesulla decorazione dell'azione e usare solo [JsonOutput]invece di [JsonOutputAttribute].


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

3
Mentre questo codice può rispondere alla domanda, fornire un contesto aggiuntivo riguardo a come e / o perché risolve il problema migliorerebbe il valore a lungo termine della risposta. Si prega di leggere questo stackoverflow.com/help/how-to-answer
SR

6

secondo l'ultima versione di ASP.net WebApi 2,

sotto WebApiConfig.cs, questo funzionerà

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

6

Non mi è chiaro perché ci sia tutta questa complessità nella risposta. Sicuramente ci sono molti modi in cui puoi farlo, con QueryStrings, header e opzioni ... ma quello che credo sia la migliore pratica è semplice. Richiedi un semplice URL (es:) http://yourstartup.com/api/carse in cambio ottieni JSON. Ottieni JSON con l'intestazione della risposta corretta:

Content-Type: application/json

Nel cercare una risposta a questa stessa domanda, ho trovato questa discussione e ho dovuto continuare perché questa risposta accettata non funziona esattamente. Ho trovato una risposta che ritengo troppo semplice per non essere la migliore:

Imposta il formattatore WebAPI predefinito

Aggiungerò il mio consiglio anche qui.

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

Ho una domanda su da dove provengano i valori predefiniti (almeno quelli che sto vedendo). Sono impostazioni predefinite .NET o forse create altrove (da qualcun altro nel mio progetto). Comunque, spero che questo aiuti.


5

Ecco una soluzione simile a quella di jayson.centeno e di altre risposte, ma utilizzando l'estensione integrata di 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 soluzione era principalmente orientata al supporto del formato $ per OData nelle prime versioni di WebApi, ma si applica anche all'implementazione non OData e restituisce l' Content-Type: application/json; charset=utf-8intestazione nella risposta.

Ti consente di virare &$format=jsono &$format=xmlalla fine del tuo uri durante i test con un browser. Non interferisce con altri comportamenti previsti quando si utilizza un client non browser in cui è possibile impostare le proprie intestazioni.


5

Puoi usare come di seguito:

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

Se stai creando un'app WebAPI per il solo passaggio di messaggi JSON, considera questa risposta.
allen1,

4

Basta aggiungere quelle due righe di codice sulla classe WebApiConfig

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


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

3

Basta cambiare in App_Start/WebApiConfig.csquesto modo:

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

Rimuovere un formatter non è generalmente una buona idea, stai rimuovendo la funzionalità.
naspinski,

In realtà in questo caso, funziona bene per me, anche molti altri suggeriscono un modo come questo. L'ho imparato dal libro myview.rahulnivi.net/building-spa-angular-mvc-5 !
vaheeds,

2

Da MSDN Creazione di un'applicazione a pagina singola con ASP.NET e AngularJS (circa 41 minuti).

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

Dovrebbe essere attuale, l'ho provato e ha funzionato.


2

È trascorso del tempo da quando questa domanda è stata posta (e ha risposto) ma un'altra opzione è quella di sovrascrivere l'intestazione Accept sul server durante l'elaborazione della richiesta utilizzando un MessageHandler come di seguito:

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

Dove someOtherConditionpuò essere qualsiasi cosa, incluso il tipo di browser, ecc. Questo sarebbe per i casi condizionali in cui solo a volte vogliamo sovrascrivere la negoziazione dei contenuti predefinita. Altrimenti, come per altre risposte, rimuoveresti semplicemente un formattatore non necessario dalla configurazione.

Dovrai registrarlo ovviamente. Puoi farlo sia a livello globale:

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

o percorso per percorso:

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

E poiché si tratta di un gestore di messaggi, verrà eseguito sia a livello di richieste che di risposte della pipeline in modo molto simile a un HttpModule. Quindi potresti facilmente riconoscere l'override con un'intestazione personalizzata:

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

2

Ecco il modo più semplice che ho usato nelle mie applicazioni. Aggiungi sotto 3 righe di codice App_Start\\WebApiConfig.csin Registerfunzione

    var formatters = GlobalConfiguration.Configuration.Formatters;

    formatters.Remove(formatters.XmlFormatter);

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

L'API Web Asp.net serializzerà automaticamente l'oggetto di ritorno su JSON e come application/jsonviene aggiunto nell'intestazione in modo che il browser o il destinatario capisca che stai restituendo il risultato JSON.


1

WebApiConfig è il luogo in cui è possibile configurare se si desidera eseguire l'output in json o xml. per impostazione predefinita è xml. nella funzione di registro possiamo usare HttpConfiguration Formatters per formattare l'output. System.Net.Http.Headers => MediaTypeHeaderValue ("text / html") è necessario per ottenere l'output nel formato json. inserisci qui la descrizione dell'immagine


1

Usando la risposta di Felipe Leusin per anni, dopo un recente aggiornamento delle librerie di base e di Json.Net, mi sono imbattuto in System.MissingMethodException: SupportedMediaTypes. La soluzione nel mio caso, si spera utile per gli altri che sperimentano la stessa inaspettata eccezione, è installare System.Net.Http. Apparentemente NuGet lo rimuove in alcune circostanze. Dopo un'installazione manuale, il problema è stato risolto.


-3

Sono stupito di vedere così tante risposte che richiedono la codifica di cambiare un caso d'uso singola (GET) in un'API invece di usare uno strumento adeguato ciò che deve essere installato una sola volta e può essere utilizzato per qualsiasi API (parte propria o 3 °) e tutti casi d'uso.

Quindi la buona risposta è:

  1. Se desideri richiedere solo json o altro tipo di contenuto, installa Requestly o uno strumento simile e modifica l'intestazione Accept.
  2. Se vuoi usare anche POST e avere json, xml, ecc. Ben formattati, usa un'estensione di test API appropriata come Postman o ARC .

Alcuni preferiscono fare le cose senza aggiungere troppa forma sotto forma di strumenti e librerie extra.
tno2007,

È ancora sbagliato apportare modifiche all'API solo perché qualcuno sta utilizzando lo strumento sbagliato per il lavoro. Un browser Web non è progettato per testare le API, nemmeno per visualizzare l'output delle API ma per visualizzare i documenti. È ancora peggio se qualcuno pensa che uno strumento di tester API sia gonfio anziché parte del toolkit obbligatorio per qualsiasi sviluppatore di API, e onestamente aggiungerei anche gli sviluppatori front-end perché devono interagire e sperimentare anche con le API. Probabilmente non è anche sufficiente perché il browser senza componenti aggiuntivi non consente di impostare intestazioni, pubblicare su un'API o persino ispezionare le intestazioni di risposta.
user3285954

Capisco quello che stai dicendo e non ti sbagli. Ma proprio fuori tema, il motivo per cui stai venendo meno votato è il tono con cui rispondi alla domanda. Sembri molto combattivo e ti imbatti in quello sviluppatore che pensa di sapere tutto, ed è molto sgradevole. Sono certo che sei un grande sviluppatore, a giudicare dalle tue risposte. Ma devi imparare, soprattutto in un ambiente professionale di QA come questo, a rivolgersi e convincere le persone in un modo più amichevole e più umano. Forse, prima dai la risposta che vogliono, poi spiega un modo migliore e motiva perché è meglio.
tno2007,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.