ක්‍රෝම් භාවිතා කරමින් XML වෙනුවට JSON ආපසු ලබා දීමට ASP.NET වෙබ් API ලබා ගන්නේ කෙසේද?

ක්‍රෝම් හි නවතම ASP.NET වෙබ් API භාවිතා කරමින් මම XML දකිමි - JSON ඉල්ලීම සඳහා එය වෙනස් කරන්නේ කෙසේද, එවිට මට එය බ්‍රව්සරයේ නැරඹිය හැකිය. එය ඉල්ලීම් ශීර්ෂයන්හි කොටසක් පමණක් යැයි මම විශ්වාස කරමි, මම එය නිවැරදිද?

මම App_Start / WebApiConfig.csමගේ MVC වෙබ් API ව්‍යාපෘතියේ පන්තියේ පහත සඳහන් දෑ එකතු කරමි .

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

එමඟින් ඔබ බොහෝ විමසුම් වලින් JSON ලබා ගන්නා බව සහතික කරයි, නමුත් XMLඔබ යවන විට ඔබට ලබා ගත හැකියtext/xml .

ඔබ ප්රතිචාර ඇති කිරීමට අවශ්ය නම් Content-Typeලෙස application/jsonපරීක්ෂා කරන්න පහත ටොඩ් පිළිතුර .

NameSpaceභාවිතා System.Net.Http.Headersකරයි.

ඔබ මෙය කරන්නේ නම් ඔබට WebApiConfigපෙරනිමියෙන් JSON ලැබෙනු ඇත, නමුත් ඔබ text/xmlඉල්ලීම් Acceptශීර්ෂය ලෙස සමත් වුවහොත් XML ආපසු ලබා දීමට එය තවමත් ඉඩ දෙයි

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

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

ඔබ MVC ව්‍යාපෘති වර්ගය භාවිතා නොකරන්නේ නම් සහ ආරම්භ කිරීමට මෙම පන්තිය නොතිබුනේ නම්, එය ඒකාබද්ධ කරන්නේ කෙසේද යන්න පිළිබඳ විස්තර සඳහා මෙම පිළිතුර බලන්න .

RequestHeaderMapping භාවිතා කිරීම ඊටත් වඩා හොඳින් ක්‍රියා කරයි, මන්ද එය Content-Type = application/jsonප්‍රතිචාර ශීර්ෂය තුළ ද සකසා ඇති අතර එමඟින් ෆයර්ෆොක්ස් (JSONView ඇඩෝන සමඟ) ප්‍රතිචාරය JSON ලෙස සංයුති කිරීමට ඉඩ ලබා දේ.

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

මම ෆෙලිපේ ලියුසින්ගේ ප්‍රවේශයට වඩාත්ම කැමතියි - ඇත්ත වශයෙන්ම XML අවශ්‍ය සේවාදායකයින්ගෙන් අන්තර්ගත සාකච්ඡා නොසලකා හරිමින් බ්‍රව්සර් JSON ලබා ගැනීමට වග බලා ගන්න. මට නැතිවූ එකම කොටස වූයේ ප්‍රතිචාර ශීර්ෂයන්හි තවමත් අන්තර්ගත වර්ගය අඩංගු වීමයි: පෙළ / html. එය ගැටලුවක් වූයේ ඇයි? මොකද මම අන්තර්ගත වර්ගය පරීක්ෂා කරන JSON Formatter Chrome දිගුව භාවිතා කරන අතර , මා පුරුදු වී ඇති ලස්සන හැඩතල ගැන්වීම මට නොලැබේ. පෙළ / html ඉල්ලීම් පිළිගෙන යෙදුම / 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");
    }
}

එසේ ලියාපදිංචි වන්න:

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

MVC4 ක්ෂණික ඉඟිය # 3 - ASP.Net වෙබ් API වෙතින් XML ආකෘතිය ඉවත් කිරීම

දී Global.asaxරේඛාව එකතු කරන්න:

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

එසේ වැනි:

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

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

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

තුළ WebApiConfig.cs , අවසාන වූ එක් කරන්න ලියාපදිංචි ක්රියාව:

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

මූලාශ්රය .

තුළ Global.asax මම පහත කේතය භාවිතා කරනවා. 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"));
}

WebAPI හි අන්තර්ගත සාකච්ඡා දෙස බලන්න. මෙම ( 1 වන කොටස සහ 2 වන කොටස ) විශ්මයජනක ලෙස සවිස්තරාත්මක හා සවිස්තරාත්මක බ්ලොග් සටහන් එය ක්‍රියාත්මක වන ආකාරය පැහැදිලි කරයි.

කෙටියෙන් කිවහොත්, ඔබ නිවැරදියි, සහ ශීර්ෂයන් සැකසීමට Acceptහෝ Content-Typeඉල්ලීමට අවශ්‍යය . නිශ්චිත ආකෘතියක් ලබා දීම සඳහා ඔබේ ක්‍රියාව කේතනය කර නොමැති බැවින් ඔබට සැකසිය හැකිය Accept: application/json.

ප්‍රශ්නය ක්‍රෝම් විශේෂිත බැවින් ඔබට ඉල්ලීම් අන්තර්ගත වර්ගය සැකසීමට ඉඩ දෙන පෝස්ට්මන් දිගුව ලබා ගත හැකිය .

එක් ඉක්මන් විකල්පයක් වන්නේ MediaTypeMapping විශේෂීකරණය භාවිතා කිරීමයි. Application_Start සිද්ධියේදී QueryStringMapping භාවිතා කිරීම පිළිබඳ උදාහරණයක් මෙන්න:

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

දැන් යූආර්එල් හි මෙම අවස්ථාවේ දී විමසුමක් තිබේද? A = b, Json ප්‍රතිචාරය බ්‍රව්සරයේ පෙන්වනු ඇත.

මෙම කේතය json මගේ පෙරනිමිය බවට පත් කරන අතර මට XML ආකෘතියද භාවිතා කිරීමට ඉඩ දෙයි. මම එකතු කරන්නම් xml=true.

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

සියලු දෙනාටම ස්තුතියි!

ඔබගේ API පරීක්ෂා කිරීමට ඔබගේ බ්‍රව්සරය භාවිතා නොකරන්න.

ඒ වෙනුවට, CURL, හෝ ෆිද්ලර් වැනි ඔබගේ ඉල්ලීම සඳහන් කිරීමට ඉඩ දෙන HTTP ග්‍රාහකයක් භාවිතා කිරීමට උත්සාහ කරන්න.

මෙම ගැටළුව සමඟ ඇති ගැටළුව සේවාදායකයා තුළ මිස API තුළ නොවේ. බ්‍රව්සරයේ ඉල්ලීම අනුව වෙබ් API නිවැරදිව ක්‍රියා කරයි.

ඉහත පිළිතුරු බොහොමයක් පරිපූර්ණ අර්ථවත් කරයි. XML ආකෘතියෙන් දත්ත සංයුති කර ඇති බව ඔබ දකින බැවින්, එයින් අදහස් වන්නේ XML හැඩතල ගැන්වීම යෙදී ඇති බැවින්, ඔබට HttpConfiguration පරාමිතියෙන් XMLFormatter ඉවත් කිරීමෙන් JSON ආකෘතිය දැකිය හැකිය.

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

JSON පෙරනිමි ආකෘතිය බැවින්

ශීර්ෂයේ "ක්‍රෝම්" අඩංගු Accept: application/xmlවූ විට ඉවත් කිරීමට මම ගෝලීය ක්‍රියාකාරී පෙරණයක් භාවිතා කළෙමි User-Agent:

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

වැඩ කරන බවක් පෙනේ.

REST සේවාවන් සමඟ වැඩ කිරීමට Chrome යෙදුම "උසස් REST සේවාලාභියා" විශිෂ්ට බව මට පෙනී ගියේය. ඔබට application/jsonවෙනත් දේ අතර අන්තර්ගත වර්ගය සැකසිය හැකිය : උසස් REST සේවාදායකයා

නිවැරදි ආකෘතිය නැවත ලබා දීම මාධ්‍ය ආකාරයේ හැඩතල ගැන්වීම මඟින් සිදු කෙරේ. අනෙක් අය සඳහන් කළ පරිදි, ඔබට මෙය WebApiConfigපන්තියේදී කළ හැකිය:

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

        ...
    }
}

වැඩි විස්තර සඳහා, පරීක්ෂා කරන්න:

• ASP.NET වෙබ් API 2 හි මාධ්‍ය ආකෘති .
• ASP.NET වෙබ් API හි අන්තර්ගත සාකච්ඡා .

ඔබගේ ක්‍රියාවන් එක්ස්එම්එල් නැවත ලබා දෙන්නේ නම් (පෙරනිමියෙන් එය එසේ වේ) සහ ඔබට JSON ආපසු ලබා දීමට නිශ්චිත ක්‍රමයක් අවශ්‍ය නම්, ඔබට එය භාවිතා ActionFilterAttributeකර එම නිශ්චිත ක්‍රියාවට අදාළ කළ හැකිය .

පෙරහන් ගුණාංගය:

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

ක්‍රියාව සඳහා අයදුම් කිරීම:

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

Attributeක්‍රියාකාරී සැරසිලිවල ඇති වචනය අතහැර දමා [JsonOutput]ඒ වෙනුවට භාවිතා කළ හැකි බව සලකන්න [JsonOutputAttribute].

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

ASP.net WebApi 2 හි නවතම අනුවාදයට අනුව,

යටතේ WebApiConfig.cs, මෙය ක්‍රියාත්මක වනු ඇත

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

පිළිතුරේ මේ සියලු සංකීර්ණතා ඇත්තේ මන්දැයි මට පැහැදිලි නැත. QueryStrings, ශීර්ෂ සහ විකල්ප සමඟ ඔබට මෙය කළ හැකි ක්‍රම රාශියක් ඇති බව සහතිකයි ... නමුත් හොඳම පුහුණුව ලෙස මා විශ්වාස කරන දේ සරලයි. ඔබ සරල URL එකක් ඉල්ලා සිටින අතර (උදා http://yourstartup.com/api/cars:) ඔබට JSON ලැබෙනු ඇත. නිසි ප්‍රතිචාර ශීර්ෂය සමඟ ඔබට JSON ලැබේ:

Content-Type: application/json

මෙම ප්‍රශ්නයටම පිළිතුරක් සෙවීමේදී, මට මෙම ත්‍රෙඩ් එක හමු වූ අතර, පිළිගත් පිළිතුර හරියටම ක්‍රියාත්මක නොවන නිසා ඉදිරියට යාමට සිදුවිය. හොඳම පිළිතුර නොවීමට තරම් සරල යැයි මට හැඟෙන පිළිතුරක් මට හමු විය:

සුපුරුදු WebAPI ආකෘතිය සකසන්න

මම මගේ ඉඟිය ද මෙහි එක් කරන්නෙමි.

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

පෙරනිමි (අවම වශයෙන් මා දකින ඒවා) පැමිණෙන්නේ කොහෙන්දැයි මට ප්‍රශ්නයක් තිබේ. ඒවා .NET පෙරනිමි ද, නැතහොත් වෙනත් තැනක ද නිර්මාණය කර තිබේද (මගේ ව්‍යාපෘතියේ වෙනත් අයෙකු විසින්). කෙසේ වෙතත්, මෙය උපකාරී වේ යැයි සිතමු.

මෙන්න jayson.centeno සහ වෙනත් පිළිතුරු වලට සමාන විසඳුමක් , නමුත් සිට සාදන ලද දිගුව භාවිතා කිරීම 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
 }

විසඳුම මූලික වශයෙන් වෙබ්අපී හි මුල් නිකුතුවලදී ඔඩාටා සඳහා සහය දැක්වීමේ ආකෘතියට යොමු විය, නමුත් එය ඔඩාටා නොවන ක්‍රියාත්මක කිරීම සඳහා ද අදාළ වන අතර Content-Type: application/json; charset=utf-8 වන අතර ප්‍රතිචාරයේ ශීර්ෂකය .

බ්‍රව්සරයක් සමඟ පරීක්‍ෂා කිරීමේදී ඔබේ යූරි සමඟ ගැටීමට &$format=jsonහෝ &$format=xmlඅවසානයට එය ඉඩ දෙයි . ඔබට ඔබේම ශීර්ෂයන් සැකසිය හැකි බ්‍රව්සර් නොවන සේවාදායකයකු භාවිතා කරන විට එය අපේක්ෂිත වෙනත් හැසිරීම් වලට බාධා නොකරයි.

ඔබට පහත පරිදි භාවිතා කළ හැකිය:

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

එම කේත පේළි දෙක ඔබේ WebApiConfig පන්තියට එක් කරන්න

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


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

ඔබ මේ App_Start/WebApiConfig.csආකාරයට වෙනස් කරන්න :

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

MSDN සිට ASP.NET සහ AngularJS සමඟ තනි පිටු යෙදුමක් තැනීම (මිනිත්තු 41 ක් පමණ).

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

එය වර්තමාන විය යුතුය, මම එය උත්සාහ කර එය ක්‍රියාත්මක විය.

මෙම ප්‍රශ්නය ඇසීමෙන් (සහ පිළිතුරු දී) යම් කාලයක් ගත වී ඇති නමුත් තවත් විකල්පයක් වන්නේ පහත දැක්වෙන පරිදි MessageHandler භාවිතා කරමින් ඉල්ලීම් සැකසීමේදී සේවාදායකයේ පිළිගැනීමේ ශීර්ෂය අභිබවා යාමයි:

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

someOtherConditionබ්‍රව්සර් වර්ගය ඇතුළු ඕනෑම දෙයක් විය හැක්කේ කොතැනද? මෙය කොන්දේසි සහිත අවස්ථා සඳහා වන අතර සමහර විට අපට සුපුරුදු අන්තර්ගත සාකච්ඡා අභිබවා යාමට අවශ්‍ය වේ. වෙනත් පිළිතුරු වලට අනුව, ඔබ වින්‍යාසයෙන් අනවශ්‍ය හැඩතල ගැන්වීමක් ඉවත් කරයි.

ඔබට එය ඇත්ත වශයෙන්ම ලියාපදිංචි කිරීමට අවශ්‍ය වනු ඇත. ඔබට මෙය ගෝලීයව කළ හැකිය:

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

හෝ මාර්ග පදනමින් මාර්ගයක:

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

මෙය පණිවුඩ හසුරුවන්නෙකු බැවින් එය නල මාර්ගයේ ඉල්ලීම සහ ප්‍රතිචාර කෙළවර යන දෙකෙහිම ක්‍රියාත්මක වේ HttpModule. එබැවින් අභිරුචි ශීර්ෂයක් සමඟ අභිබවා යාම ඔබට පහසුවෙන් හඳුනාගත හැකිය:

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

මෙන්න මම මගේ යෙදුම්වල භාවිතා කර ඇති පහසුම ක්‍රමයයි. ක්‍රියාකාරීත්වයේ කේත පේළි 3 ක් පහත දක්වා App_Start\\WebApiConfig.csඇතRegister

    var formatters = GlobalConfiguration.Configuration.Formatters;

    formatters.Remove(formatters.XmlFormatter);

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

Asp.net වෙබ් API මඟින් ඔබ ආපසු එන වස්තුව JSON වෙත ස්වයංක්‍රීයව අනුක්‍රමණය කරනු ඇති application/jsonඅතර එය ශීර්ෂයට එකතු කර ඇති බැවින් ඔබ JSON ප්‍රති .ලය ලබා දෙන බව බ්‍රව්සරයට හෝ ලබන්නාට වැටහෙනු ඇත .

WebApiConfig යනු ඔබට json හෝ xml වලින් ප්‍රතිදානය කිරීමට අවශ්‍යද යන්න වින්‍යාසගත කළ හැකි ස්ථානයයි. පෙරනිමියෙන් එය xml වේ. රෙජිස්ටර් ශ්‍රිතයේදී අපට ප්‍රතිදානය සංයුති කිරීමට HttpConfiguration Formatters භාවිතා කළ හැකිය. System.Net.Http.Headers => jSon ආකෘතියෙන් ප්‍රතිදානය ලබා ගැනීම සඳහා MediaTypeHeaderValue ("text / html") අවශ්‍ය වේ.

වසර ගණනාවක සිට ෆෙලිපේ ලියුසින්ගේ පිළිතුර භාවිතා කරමින් , මූලික පුස්තකාල සහ ජේසන්.නෙට් යාවත්කාලීන කිරීමෙන් පසුව, මම System.MissingMethodException: SupportedMediaTypes වෙත දිව ගියෙමි . මගේ නඩුවේ විසඳුම, එකම අනපේක්ෂිත ව්‍යතිරේකය අත්විඳින අනෙක් අයට ප්‍රයෝජනවත් වනු ඇත, ස්ථාපනය System.Net.Httpකිරීමයි. NuGet සමහර තත්වයන් යටතේ එය ඉවත් කරයි. අතින් ස්ථාපනය කිරීමෙන් පසුව, ගැටළුව විසඳනු ලැබීය.

මම තනි භාවිතය නඩුව (ලබා ගන්න) වෙනස් කිරීමට කේතනය අවශ්ය බොහෝ පිළිතුරු දැකීමට පුදුමයට පත් වෙනවා එක් වරක් ස්ථාපනය කිරීමට සහ සඳහා භාවිතා කළ හැකි දේ නිසි මෙවලම භාවිතා කර වෙනුවට API ඕනෑම API (තමාගේම හෝ 3 වන පාර්ශ්ව), සියලු නඩු භාවිතා කරන්න.

එබැවින් හොඳ පිළිතුර නම්:

1. ඔබ පමණක් ඉල්ලීම json හෝ වෙනත් අන්තර්ගතයන් වර්ගය කිරීමට අවශ්ය නම් ස්ථාපනය Requestly හෝ ඒ හා සමාන මෙවලමක් හා පිළිගන්න ශීර්ෂ වෙනස්.
2. ඔබට POST භාවිතා කිරීමට අවශ්‍ය නම් සහ මනාව හැඩගස්වා ඇති json, xml යනාදිය අවශ්‍ය නම් Postman හෝ ARC වැනි නිසි API පරීක්ෂණ දිගුවක් භාවිතා කරන්න .