Il servizio web ASMX che non restituisce JSON, può solo POST utilizzare content/x-www-form-urlencoded contentType

Question

Posso chiamare il mio webservice utilizzando jQuery SE il contentType = "application/x-www-form-urlencoded; charset = utf-8 "

Ciò, tuttavia, riportare il xML: <string>[myjson]</string>

Se provo POST al servizio utilizzando "application/json; charset = utf-8" ricevo un errore 500 con StackTrace vuoto e ExceptionType . La mia funzione di webservice non viene mai toccata, quindi non sono abbastanza sicuro di come eseguire il debug di questa situazione.

I miei metodi e classi sono decorati con gli attributi appropriati e sono impostati per utilizzare JSON come tipo di risposta (come i miei file wsdl e disco). Ho installato le estensioni Ajax e le voci richieste in web.config.

Questo è in una farm di SharePoint, ma non sono sicuro che faccia troppa differenza. Ho distribuito le modifiche di web.config su tutti i WFE e installato le estensioni ajax. Ancora una volta il servizio funziona, semplicemente non accetterà nulla se non il tipo di contenuto predefinito.

Non so cosa mi manca qui, ragazzi ...

mio ajax chiamata:

$.ajax({ 
type: "POST", 
url: "/_vti_bin/calendar.asmx/Test", 
dataType: "json", 
data: "{}", 
contentType: "application/json; charset=UTF-8", 
success: function(msg){ 
    alert(msg); 
    }, 
error: function(xhr, msg){ alert(msg + '\n' + xhr.responseText); } 
}); 

La mia classe webservice:

[WebService(Namespace = "http://namespace")] 
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)] 
[ScriptService()] 
public class CalendarService : WebService 
{ 
    [WebMethod] 
    [ScriptMethod(ResponseFormat = ResponseFormat.Json)] 
    public string Test() 
    { 
     return "Hello World"; 
    } 
} 

Answer 1

non è sicuro se potesse essere questo semplice ma sto usando jQuery per richiamare JSON dai miei metodi web.

la principale differenza che vedo è l'attributo della classe

[System.Web.Script.Services.ScriptService]

[WebService(Namespace = "http://MyNameSpace")] 
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)] 
    [System.Web.Script.Services.ScriptService] 
    public class Web : System.Web.Services.WebService{ 

     [WebMethod] 
     public string TestMethod(){ 
     return "Testing"; 
     } 

    } 

Devo presumere che si sta utilizzando la 3.5 framework perché è l'unico modo per esporre i metodi web JSON.

Le mie chiamate formano jQuery sembrano praticamente identiche, quindi nessun problema lì.

Answer 2

Sembra che sia necessario specificare json come formato di risposta nel tag scriptMethod. Questo è da vb.net, ma sono sicuro che si ottiene l'idea:

ResponseFormat: = ResponseFormat.Json

Answer 3

Se stai prove in IE, provare a rimuovere la dichiarazione charset dal attributo contentType (vale a dire che dovrebbe essere simile a questo:

contentType: "application/json", 

devo ancora scoprire perché, ma sembra IE per ottenere i suoi mutandoni in una torsione quando si effettua JSON chiama con la parte "charset=UTF-8".

Answer 4

penso che stai cercando il WebInvoke o WebGet attributo, esso consente di specificare Uri modello, tipo di carrozzeria, richiesta e responseformats, ad esempio:

[WebGet(ResponseFormat= WebMessageFormat.Json)] 

This link può aiutare . C'è un articolo simile per WebInvoke (usato principalmente per i post).

Answer 5

Io uso le chiamate JQuery AJAX JSON al servizio web ASMX piuttosto un po '. Funziona perfettamente su tutti i browser. Sto usando .NET 2.0 con le estensioni ASPJNET AJAX installate (in bundle in 3.5).

La mia classe ha gli stessi decoratori della tua. I miei metodi hanno solo il decoratore [WebMethod(EnableSession = true)]. Il mio web.config ha tuttavia la seguente voce nella sua sezione httpHandlers:

<add verb="*" path="*jsonservice.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> 

Il mio invito jquery appare come segue:

$.ajax({ 
    type: "POST", 
    contentType: "application/json; charset=utf-8", 
    url: "path/to/service/jsonservice.asmx/MethodName", 
    data: JSON.stringify(DTO), 
    dataType: "json", 
    success: function(rtrn) { alert("good"); }, 
    error: function(req, msg, err) { alert("bad"); } 
}); 

This article è la radice della mia conoscenza.

Answer 6

Ho questo lavoro in 2.0 utilizzando i servizi web, ma ho messo in atto la protezione dal file .d (vedi dataFiltro sotto). Sto anche restituendo una serie di oggetti. NOTA: la classe per l'oggetto è statica, altrimenti non funzionerebbe correttamente per me.

$.ajax({ 
     type: "POST", 
     contentType: "application/json; charset=utf-8", 
     data: "{}", 
     dataFilter: function(data) 
     { 
      var msg; 
      if (typeof (JSON) !== 'undefined' && 
       typeof (JSON.parse) === 'function') 
       msg = JSON.parse(data); 
      else 
       msg = eval('(' + data + ')'); 
      if (msg.hasOwnProperty('d')) 
       return msg.d; 
      else 
       return msg; 
     }, 
     url: "webservice/ModifierCodesService.asmx/GetModifierList", 
     success: function(msg) 
     { 
      LoadModifiers(msg); 
     }, 
     failure: function(msg) 
     { 
      $("#Result").text("Modifiers did not load"); 
     } 
    }); 

Ecco una snippett del mio servizio web:

...

[WebService(Namespace = "http://mynamespace.com/ModifierCodesService/")] 
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)] 
[System.ComponentModel.ToolboxItem(false)] 
[ScriptService] 
public class ModifierCodesService : System.Web.Services.WebService 
{ 

    /// <summary> 
    /// Get a list of Modifiers 
    /// </summary> 
    /// <returns></returns> 
    [WebMethod(EnableSession = true)] 
    public Modifier[] GetModifierList() 
    { 
     return GetModifiers(); 
    } 
     /// <summary> 
     /// Modifiers list from database 
     /// </summary> 
     /// <returns></returns> 
     private Modifier[] GetModifiers() 
     { 
      List<Modifier> modifier = new List<Modifier>(); 
      ModifierCollection matchingModifiers = ModifierList.GetModifierList(); 
      foreach (Modifier ModifierRow in matchingModifiers) 
      { 
       modifier.Add(new Modifier(ModifierRow.ModifierCode, ModifierRow.Description)); 
      } 
      return modifier.ToArray(); 
     } 
    } 

...

il codice oggetto:

public static class ModifierList 
    { 

     /// <summary> 
     /// Returns the Modifier Collection. 
     /// </summary> 
     /// <param name="prefix"></param> 
     /// <returns></returns> 
     public static ModifierCollection GetModifierList() 
     { 

Answer 7

ho combattuto con questo oggi con un'app per iPhone che comunica con un servizio Web .Net.

Ho scoperto che se ho cambiato il mio tipo di contenuto in application/jsonrequest è andato avanti senza problemi e sono stato in grado di elaborare i dati nel mio server web.

Solo per i sorrisi ho aggiunto la riga di cui sopra al mio web.config, ma non ha fatto funzionare l'applicazione/json.