Bagaimana cara mendapatkan ASP.NET Web API untuk mengembalikan JSON dan bukan XML menggunakan Chrome?

Menggunakan ASP.NET Web API yang lebih baru , di Chrome saya melihat XML - bagaimana saya bisa mengubahnya untuk meminta JSON sehingga saya bisa melihatnya di browser? Saya yakin itu hanya bagian dari header permintaan, apakah saya benar dalam hal itu?

Saya hanya menambahkan yang berikut di App_Start / WebApiConfig.cskelas dalam proyek API Web MVC saya .

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

Itu memastikan Anda mendapatkan JSON pada sebagian besar kueri, tetapi Anda bisa mendapatkannya XMLsaat Anda mengirim text/xml.

Jika Anda perlu memiliki respon Content-Typesebagai application/jsonsilahkan cek jawaban Todd bawah .

NameSpacesedang menggunakan System.Net.Http.Headers.

Jika Anda melakukan ini di WebApiConfigAnda akan mendapatkan JSON secara default, tetapi masih akan memungkinkan Anda untuk mengembalikan XML jika Anda lulus text/xmlsebagai Acceptheader permintaan

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

Jika Anda tidak menggunakan jenis proyek MVC dan karena itu tidak memiliki kelas ini untuk memulai, lihat jawaban ini untuk detail tentang cara memasukkannya.

Menggunakan RequestHeaderMapping berfungsi lebih baik, karena ia juga mengatur Content-Type = application/jsonheader respons, yang memungkinkan Firefox (dengan add-on JSONView) untuk memformat respons sebagai JSON.

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

Saya suka pendekatan Felipe Leusin yang terbaik - pastikan browser mendapatkan JSON tanpa mengurangi negosiasi konten dari klien yang benar-benar menginginkan XML. Satu-satunya bagian yang hilang bagi saya adalah bahwa header respons masih berisi tipe konten: teks / html. Mengapa itu menjadi masalah? Karena saya menggunakan ekstensi Chrome JSON Formatter , yang memeriksa tipe konten, dan saya tidak mendapatkan format cantik seperti biasa. Saya memperbaikinya dengan pemformat kustom sederhana yang menerima permintaan teks / html dan mengembalikan respons aplikasi / 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");
    }
}

Daftarkan seperti ini:

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

MVC4 Tip Cepat # 3 – Menghapus Formatter XML dari ASP.Net Web API

Di Global.asaxtambahkan baris:

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

seperti itu:

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

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

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

Di WebApiConfig.cs , tambahkan ke akhir fungsi Daftar :

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

Sumber .

Di Global.asax saya menggunakan kode di bawah ini. URI saya untuk mendapatkan JSON adalahhttp://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"));
}

Lihatlah negosiasi konten di WebAPI. Ini ( Bagian 1 & Bagian 2 ) posting blog sangat rinci dan menyeluruh menjelaskan cara kerjanya.

Singkatnya, Anda benar, dan hanya perlu mengatur Acceptatau Content-Typememinta tajuk. Mengingat Aksi Anda tidak dikodekan untuk mengembalikan format tertentu, Anda dapat mengatur Accept: application/json.

Karena pertanyaannya adalah khusus Chrome, Anda bisa mendapatkan ekstensi tukang pos yang memungkinkan Anda mengatur jenis konten permintaan.

Salah satu opsi cepat adalah menggunakan spesialisasi MediaTypeMapping. Berikut adalah contoh penggunaan QueryStringMapping dalam acara Application_Start:

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

Sekarang setiap kali url berisi querystring? A = b dalam hal ini, respons Json akan ditampilkan di browser.

Kode ini menjadikan json sebagai standar saya dan memungkinkan saya untuk menggunakan format XML juga. Saya hanya akan menambahkan xml=true.

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

Terimakasih semuanya!

Jangan gunakan browser Anda untuk menguji API Anda.

Alih-alih, coba gunakan klien HTTP yang memungkinkan Anda menentukan permintaan Anda, seperti CURL, atau bahkan Fiddler.

Masalah dengan masalah ini ada di klien, bukan di API. API web berperilaku dengan benar, sesuai dengan permintaan browser.

Sebagian besar jawaban di atas masuk akal. Karena Anda melihat data diformat dalam format XML, itu artinya formatter XML diterapkan, jadi Anda dapat melihat format JSON hanya dengan menghapus XMLFormatter dari parameter HttpConfiguration seperti

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

karena JSON adalah format default

Saya menggunakan filter tindakan global untuk menghapus Accept: application/xmlketika User-Agentheader berisi "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();
    }
}

Tampaknya bekerja.

Saya menemukan aplikasi Chrome "Klien Lanjutan REST" sangat bagus untuk bekerja dengan layanan REST. Anda dapat mengatur Jenis-Konten untuk application/jsonantara lain: Klien REST Lanjutan

Mengembalikan format yang benar dilakukan oleh formatter tipe media. Seperti yang disebutkan orang lain, Anda dapat melakukan ini di WebApiConfigkelas:

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

        ...
    }
}

Untuk lebih lanjut, periksa:

• Pemformat Media di ASP.NET Web API 2 .
• Negosiasi Konten di ASP.NET Web API .

Jika tindakan Anda mengembalikan XML (yang merupakan kasus secara default) dan Anda hanya perlu metode khusus untuk mengembalikan JSON, Anda kemudian dapat menggunakan ActionFilterAttribute dan menerapkannya ke tindakan tertentu.

Atribut filter:

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

Berlaku untuk tindakan:

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

Perhatikan bahwa Anda dapat menghilangkan kata Attributepada dekorasi aksi dan menggunakan hanya [JsonOutput]sebagai gantinya [JsonOutputAttribute].

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

sesuai versi terbaru ASP.net WebApi 2,

di bawah WebApiConfig.cs, ini akan berhasil

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

Tidak jelas bagi saya mengapa ada semua kompleksitas dalam jawabannya. Tentu ada banyak cara Anda bisa melakukan ini, dengan QueryStrings, header, dan opsi ... tapi apa yang saya yakini sebagai praktik terbaik itu sederhana. Anda meminta URL polos (mis .:) http://yourstartup.com/api/carsdan sebagai imbalannya Anda mendapatkan JSON. Anda mendapatkan JSON dengan tajuk respons yang tepat:

Content-Type: application/json

Dalam mencari jawaban untuk pertanyaan yang sama ini, saya menemukan utas ini, dan harus terus maju karena jawaban yang diterima ini tidak bekerja dengan tepat. Saya memang menemukan jawaban yang saya rasa terlalu sederhana untuk tidak menjadi yang terbaik:

Atur formatter WebAPI default

Saya akan menambahkan tip saya di sini juga.

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

Saya memang memiliki pertanyaan tentang dari mana asalnya (setidaknya yang saya lihat) berasal. Apakah mereka. NET default, atau mungkin dibuat di tempat lain (oleh orang lain di proyek saya). Bagaimanapun, semoga ini membantu.

Berikut adalah solusi yang mirip dengan jayson.centeno dan jawaban lainnya, tetapi menggunakan ekstensi bawaan dari 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
 }

Solusi ini terutama diarahkan untuk mendukung $ format untuk OData di rilis awal WebApi, tetapi juga berlaku untuk implementasi non-OData, dan mengembalikan Content-Type: application/json; charset=utf-8 header dalam respons.

Hal ini memungkinkan Anda untuk menempelkan &$format=jsonatau &$format=xmlke akhir uri Anda saat menguji dengan browser. Itu tidak mengganggu perilaku yang diharapkan lainnya saat menggunakan klien non-browser tempat Anda dapat mengatur tajuk Anda sendiri.

Anda bisa menggunakan seperti di bawah ini:

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

Cukup tambahkan dua baris kode di kelas WebApiConfig Anda

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


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

Anda baru saja mengubah App_Start/WebApiConfig.csseperti ini:

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

Dari MSDN, Membangun Aplikasi Halaman Tunggal dengan ASP.NET dan AngularJS (sekitar 41 menit).

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

Seharusnya saat ini, saya mencobanya dan berhasil.

Beberapa waktu telah berlalu sejak pertanyaan ini ditanyakan (dan dijawab) tetapi opsi lain adalah menimpa header Terima di server selama pemrosesan permintaan menggunakan MessageHandler seperti di bawah ini:

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

Di mana someOtherConditionbisa apa saja termasuk tipe peramban, dll. Ini akan menjadi kasus bersyarat di mana hanya kadang-kadang kita ingin mengganti negosiasi konten default. Kalau tidak sesuai jawaban lain, Anda hanya akan menghapus formatter yang tidak perlu dari konfigurasi.

Anda harus mendaftarkannya, tentu saja. Anda dapat melakukan ini secara global:

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

atau berdasarkan rute dengan rute:

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

Dan karena ini adalah penangan pesan, pesan itu akan berjalan baik pada permintaan dan respons ujung pipa seperti sebuah HttpModule. Jadi, Anda dapat dengan mudah mengakui penggantian dengan tajuk khusus:

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

Ini adalah cara termudah yang saya gunakan dalam aplikasi saya. Tambahkan diberikan di bawah 3 baris kode App_Start\\WebApiConfig.csdalam Registerfungsi

    var formatters = GlobalConfiguration.Configuration.Formatters;

    formatters.Remove(formatters.XmlFormatter);

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

Asp.net web API akan secara otomatis membuat serial objek Anda yang kembali ke JSON dan seperti yang application/jsonditambahkan di header sehingga browser atau penerima akan memahami bahwa Anda mengembalikan hasil JSON.

WebApiConfig adalah tempat di mana Anda dapat mengkonfigurasi apakah Anda ingin menghasilkan json atau xml. secara default xml. dalam fungsi register kita dapat menggunakan HttpConfiguration Formatters untuk memformat output. System.Net.Http.Headers => MediaTypeHeaderValue ("text / html") diperlukan untuk mendapatkan output dalam format json.

Menggunakan jawaban Felipe Leusin selama bertahun-tahun, setelah pembaruan terbaru dari perpustakaan inti dan Json.Net, saya bertemu dengan System.MissingMethodException: SupportedMediaTypes. Solusi dalam kasus saya, semoga bermanfaat bagi orang lain yang mengalami pengecualian tak terduga yang sama, adalah menginstal System.Net.Http. NuGet tampaknya menghapusnya dalam beberapa keadaan. Setelah instalasi manual, masalah terselesaikan.

Saya heran melihat begitu banyak balasan yang memerlukan pengkodean untuk mengubah penggunaan tunggal (GET) dalam satu API alih-alih menggunakan alat yang tepat apa yang harus diinstal sekali dan dapat digunakan untuk API apa pun (milik sendiri atau pihak ketiga) dan semua gunakan kasing.

Jadi jawabannya adalah:

1. Jika Anda hanya ingin meminta json atau jenis konten lain, instal Requestly atau alat serupa dan ubah tajuk Terima.
2. Jika Anda ingin menggunakan POST juga dan telah dengan baik memformat json, xml, dll. Gunakan ekstensi pengujian API yang tepat seperti Postman atau ARC .