WCF servicio JSON devuelto XML de Falla

Question

estoy corriendo un ServiceHost para probar uno de mis servicios y todo funciona bien hasta que lanzo un FaultException - Bang consigo XML no JSON

mi contrato de servicio - preciosa

/// <summary> 
    /// <para>Get category by id</para> 
    /// </summary> 
    [OperationContract(AsyncPattern = true)] 
    [FaultContract(typeof(CategoryNotFound))] 
    [FaultContract(typeof(UnexpectedExceptionDetail))] 
    IAsyncResult BeginCategoryById(
     CategoryByIdRequest request, 
     AsyncCallback callback, object state); 

    CategoryByIdResponse EndCategoryById(IAsyncResult result); 

anfitrión Set-up - deliciosos yum

var host = new ServiceHost(serviceType, new Uri(serviceUrl)); 
host.AddServiceEndpoint(
    serviceContract, 
    new WebHttpBinding(), "") 
     .Behaviors.Add(
      new WebHttpBehavior 
          { 
           DefaultBodyStyle = WebMessageBodyStyle.Bare, 
           DefaultOutgoingResponseFormat = WebMessageFormat.Json, 
           FaultExceptionEnabled = true 
          }); 

host.Open(); 

Ésta es la llamada - oo vientre dolor

var request = WebRequest.Create(serviceUrl + "/" + serviceName); 
request.Method = "POST"; 
request.ContentType = "application/json; charset=utf-8"; 
request.ContentLength = 0; 

try 
{ 
    // receive response 
    using (var response = request.GetResponse()) 
    { 
     var responseStream = response.GetResponseStream(); 

     // convert back into referenced object for verification 
     var deserialiser = new DataContractJsonSerializer(typeof (TResponseData)); 
     return (TResponseData) deserialiser.ReadObject(responseStream); 
    } 
} 
catch (WebException wex) 
{ 
    var response = wex.Response; 

    using (var responseStream = response.GetResponseStream()) 
    { 
     // convert back into fault 
     //var deserialiser = new DataContractJsonSerializer(typeof(FaultException<CategoryNotFound>)); 
     //var fex = (FaultException<CategoryNotFound>)deserialiser.ReadObject(responseStream); 

     var text = new StreamReader(responseStream).ReadToEnd(); 
     var fex = new Exception(text, wex);  

     Logger.Error(fex); 
     throw fex; 
    } 
} 

el texto var contiene el error correcto, pero serializado como Xml ¿Qué he hecho mal aquí?

Answer 1

La respuesta es poner en práctica un comportamiento IErrorHandler y apoyar

me encontré con este excelente mensaje por iainjmitchell

http://iainjmitchell.com/blog/?p=142

Answer 2

Esto probablemente no le dará la parte de "por qué". Echa un vistazo a this question. Te permite tomar y reformatear las fallas antes de que salgan como respuesta. Esto al menos JSensezará tus respuestas lo suficiente como para ponerte en marcha. this también tiene una idea similar detrás de él.

Answer 3

Según MSDN documentation for DataContractJsonSerializer:

"Si se produce un error durante la serialización de una respuesta saliente en el servidor o la operación de respuesta se produce una excepción por alguna otra razón, es posible que no nos devuelve al cliente como un fallo "

Además, y esto es mera especulación, pero casi parece que este serializador se serializa en XML y luego lo convierte en JSON. Entonces, cuando ocurre su falla, ¿se interrumpe a mitad del proceso? Por otra parte, podría estar totalmente equivocado.

Buena suerte.

Answer 4

No entiendo por qué está utilizando WebRequest para realizar llamadas a un servicio WCF. ¿Hay una razón específica para esto? ¿Cómo sabes cuando manejas ese WebException que será un FaultException<CategoryNotFound>?
Si utiliza un proxy de servicio, y su servicio arroja FaultException<T>, es probablemente mejor para escribir su try-catch así:

try 
{ 
    //Do service call 
} 
catch (FaultException<CategoryNotFound> fe) 
{ 
    //handle CategoryNotFound 
} 
catch (FaultException<UnexpectedExceptionDetail> fe) 
{ 
    //handle UnexpectedExceptionDetail 
} 
catch (FaultException exc) 
{ 
    //stuf 
} 
catch(Exception general){ 
    //all other stuff that might blow up 
} 

Answer 5

que puede presentar felizmente la solución. Tuve exactamente el mismo problema y después de jugar un poco con la configuración de comportamiento de mi punto final, descubrí el elemento de configuración necesario. La solución es forzar WCF usen el formato seleccionado (JSON):

<behavior name="ExtendedJSONBehavior"> 
    <webHttp defaultOutgoingResponseFormat="Json" defaultBodyStyle="Wrapped" automaticFormatSelectionEnabled="false"/> 
</behavior> 

Como se puede ver, la clave era la "automaticFormatSelectionEnabled" atributo.

Diviértete con WCF nuevo

Answer 6

//由于调用 ProvideFault 时，客户端处于阻塞状态,不要在这里进行长时间的操作 
public void ProvideFault(Exception error, MessageVersion version, ref Message msg) 
{ 
    //避免敏感信息泄漏,例如:数据库配置, error包含的错误信息应该记录到服务器的日志中,不能显示给客户端 
    // FaultException<int> e = new FaultException<int>(123, error.Message); 
    DateTime now = DateTime.Now; 
    time = now.ToString("yyyyMMddHHmmssfff", DateTimeFormatInfo.InvariantInfo);// "" + now.Year.ToString() + now.Month.ToString() + now.Day.ToString() + now.Hour.ToString() + now.Minute.ToString() + now.Second.ToString() + now.Millisecond.ToString(); 
    string errorMsg = "服务内部错误_" + time; 
    // FaultException fe = new FaultException(errorMsg); 
    // MessageFault mf = fe.CreateMessageFault(); 
    // msg = Message.CreateMessage(version, mf, fe.Action); 

    //The fault to be returned 
    msg = Message.CreateMessage(version, "", errorMsg, new DataContractJsonSerializer(typeof(string))); 

    // tell WCF to use JSON encoding rather than default XML 
    WebBodyFormatMessageProperty wbf = new WebBodyFormatMessageProperty(WebContentFormat.Json); 

    // Add the formatter to the fault 
    msg.Properties.Add(WebBodyFormatMessageProperty.Name, wbf); 

    //Modify response 
    HttpResponseMessageProperty rmp = new HttpResponseMessageProperty(); 

    // return custom error code, 400. 
    rmp.StatusCode = System.Net.HttpStatusCode.InternalServerError; 
    rmp.StatusDescription = "Bad request"; 

    //Mark the jsonerror and json content 
    rmp.Headers[HttpResponseHeader.ContentType] = "application/json"; 
    rmp.Headers["jsonerror"] = "true"; 

    //Add to fault 
    msg.Properties.Add(HttpResponseMessageProperty.Name, rmp); 
}