Estoy tratando de llegar con un simple, fácil utilizar el patrón de diseño para el manejo de errores en una .net wcf service (específicamente un silverlight habilitado el servicio de wcf). Si una excepción se tira en el método de servicio de la aplicación de silverlight va a ver un CommunicationException afirmando que «en El servidor remoto devolvió un error: NotFound —>» y, posiblemente, una traza de la pila en función de su configuración, que es totalmente no es útil porque no se lo dirá a usted el error real, y por lo general el error real es de no «NotFound».

Leyendo en los servicios web y servicios de wcf y excepciones, Usted necesita para lanzar jabón/wcf estándar excepciones como FaultException o SoapException. Así que para un servicio wcf que usted necesita para envolver cada método en un intento de captura, la captura de cada una excepción, se envuelve en un FaultException y tirar. Al menos esa es mi entendimiento, me corrija si estoy equivocado.

Así que he creado mi patrón de diseño:

[ServiceContract(Namespace = "http://MyTest")]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class DataAccess
{
///<summary>
///Error class, handle converting an exception into a FaultException
///</summary>
[DataContractAttribute]
public class Error
{
private string strMessage_m;
private string strStackTrace_m;
public Error(Exception ex)
{
this.strMessage_m = ex.Message;
this.strStackTrace_m = ex.StackTrace;
}
[DataMemberAttribute]
public string Message
{
get { return this.strMessage_m; }
set { this.strMessage_m = value; }
}
[DataMemberAttribute]
public string StackTrace
{
get { return this.strStackTrace_m; }
set { this.strStackTrace_m = value; }
}
//Convert an exception into a FaultException
public static void Throw(Exception ex)
{
if (ex is FaultException)
{
throw ex;
}
else
{
throw new FaultException<Error>(new Error(ex));
}
}
}
[OperationContract]
[FaultContract(typeof(Error))]
public void TestException()
{
try
{
throw new Exception("test");
}
catch (Exception ex)
{
Error.Throw(ex);
}
}
}

Para hacer un cortocircuito largo de la historia, todavía no estoy recibiendo el error correcto en mi aplicación de silverlight. Yo inspeccionar el AsyncCompletedEventArgs.Objeto de Error y contiene un CommunicationException objeto con el error genérico. Me ayudan con un sencillo patrón de diseño para permitir que me tiro la excepción correcta desde el servicio y la facilidad de captura de la aplicación.

OriginalEl autor Jeremy | 2009-01-14

3 Comentarios

  1. 6

    Yo sugeriría usted para centralizar el manejo de errores de su servicio WCF en lugar de poner try/catch en cada método. Para hacer esto se puede implementar el IErrorHandler interfaz:

    public class ErrorHandler : IErrorHandler
    {
    public bool HandleError(Exception error)
    {
    return true;
    }
    public void ProvideFault(Exception error, MessageVersion version, ref Message msg)
    {
    DataAccessFaultContract dafc = new DataAccessFaultContract(error.Message);
    var fe = new FaultException<DataAccessFaultContract>(dafc);
    Message fault = fe.CreateMessageFault();
    string ns = "http://www.example.com/services/FaultContracts/DataAccessFault";
    msg = Message.CreateMessage(version, fault, ns);
    }
    }

    La ProvideFault método es llamado cada vez que uno de sus OperationContract lanza una excepción. Se va a convertir la excepción en un personalizados, FaultContract y enviarlo al cliente. De esta manera usted no necesita poner try/catch en cada método. También puede enviar un diferente FaultContract dependiendo de la excepción.

    En el lado del cliente que usted necesita para ponerse FaultException<DataAccessFaultContract> cada vez que se llama a un método del servicio web.

    Ok, entonces, ¿qué hacemos con el ErrorHandler clase? ¿Cómo se puede asociar a tu servicio?

    OriginalEl autor Darin Dimitrov

  2. 5

    Ok, me miró a los IErrorHandler idea. Yo no tenía idea de que podría hacerlo de esta manera, y es perfecta porque le permite evitar tratar de capturas para cada método. Puedes hacer esto en el estándar de servicios web? He implementado de la siguiente manera:

    ///<summary>
    ///Services can intercept errors, perform processing, and affect how errors are reported using the 
    ///IErrorHandler interface. The interface has two methods that can be implemented: ProvideFault and
    ///HandleError. The ProvideFault method allows you to add, modify, or suppress a fault message that 
    ///is generated in response to an exception. The HandleError method allows error processing to take 
    ///place in the event of an error and controls whether additional error handling can run.
    ///
    ///To use this class, specify it as the type in the ErrorBehavior attribute constructor.
    ///</summary>
    public class ServiceErrorHandler : IErrorHandler
    {
    ///<summary>
    ///Default constructor
    ///</summary>
    public ServiceErrorHandler()
    {
    }
    ///<summary>
    ///Specifies a url of the service
    ///</summary>
    ///<param name="strUrl"></param>
    public ServiceErrorHandler(string strUrl, bool bHandled)
    {
    this.strUrl_m = strUrl;
    this.bHandled_m = bHandled;
    }
    ///<summary>
    ///HandleError. Log an error, then allow the error to be handled as usual. 
    ///Return true if the error is considered as already handled
    ///</summary>
    ///<param name="error"></param>
    ///<returns></returns>
    public virtual bool HandleError(Exception exError)
    {
    System.Diagnostics.EventLog evt = new System.Diagnostics.EventLog("Application", ".", "My Application");
    evt.WriteEntry("Error at " + this.strUrl_m + ":\n" + exError.Message, System.Diagnostics.EventLogEntryType.Error);
    return this.bHandled_m;
    }
    ///<summary>
    ///Provide a fault. The Message fault parameter can be replaced, or set to
    ///null to suppress reporting a fault.
    ///</summary>
    ///<param name="error"></param>
    ///<param name="version"></param>
    ///<param name="msg"></param>
    public virtual void ProvideFault(Exception exError,
    System.ServiceModel.Channels.MessageVersion version,
    ref System.ServiceModel.Channels.Message msg)
    {
    //Any custom message here
    /*
    DataAccessFaultContract dafc = new DataAccessFaultContract(exError.Message);
    System.ServiceModel.FaultException fe = new System.ServiceModel.FaultException<DataAccessFaultContract>(dafc);
    System.ServiceModel.Channels.MessageFault fault = fe.CreateMessageFault();
    string ns = "http://www.example.com/services/FaultContracts/DataAccessFault";
    msg = System.ServiceModel.Channels.Message.CreateMessage(version, fault, ns);
    */
    }
    private string strUrl_m;
    ///<summary>
    ///Specifies a url of the service, displayed in the error log
    ///</summary>
    public string Url
    {
    get
    {
    return this.strUrl_m;
    }
    }
    private bool bHandled_m;
    ///<summary>
    ///Determines if the exception should be considered handled
    ///</summary>
    public bool Handled
    {
    get
    {
    return this.bHandled_m;
    }
    }
    }
    ///<summary>
    ///The ErrorBehaviorAttribute exists as a mechanism to register an error handler with a service. 
    ///This attribute takes a single type parameter. That type should implement the IErrorHandler 
    ///interface and should have a public, empty constructor. The attribute then instantiates an 
    ///instance of that error handler type and installs it into the service. It does this by 
    ///implementing the IServiceBehavior interface and then using the ApplyDispatchBehavior 
    ///method to add instances of the error handler to the service.
    ///
    ///To use this class specify the attribute on your service class.
    ///</summary>
    public class ErrorBehaviorAttribute : Attribute, IServiceBehavior
    {
    private Type typeErrorHandler_m;
    public ErrorBehaviorAttribute(Type typeErrorHandler)
    {
    this.typeErrorHandler_m = typeErrorHandler;
    }
    public ErrorBehaviorAttribute(Type typeErrorHandler, string strUrl, bool bHandled)
    : this(typeErrorHandler)
    {
    this.strUrl_m = strUrl;
    this.bHandled_m = bHandled;
    }
    public virtual void Validate(ServiceDescription description, ServiceHostBase serviceHostBase)
    {
    return;
    }
    public virtual void AddBindingParameters(ServiceDescription description, ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters)
    {
    return;
    }
    protected virtual IErrorHandler CreateTypeHandler()
    {
    IErrorHandler typeErrorHandler;
    try
    {
    typeErrorHandler = (IErrorHandler)Activator.CreateInstance(this.typeErrorHandler_m, this.strUrl_m, bHandled_m);
    }
    catch (MissingMethodException e)
    {
    throw new ArgumentException("The ErrorHandler type specified in the ErrorBehaviorAttribute constructor must have a public constructor with string parameter and bool parameter.", e);
    }
    catch (InvalidCastException e)
    {
    throw new ArgumentException("The ErrorHandler type specified in the ErrorBehaviorAttribute constructor must implement System.ServiceModel.Dispatcher.IErrorHandler.", e);
    }
    return typeErrorHandler;
    }
    public virtual void ApplyDispatchBehavior(ServiceDescription description, ServiceHostBase serviceHostBase)
    {
    IErrorHandler typeErrorHandler = this.CreateTypeHandler();            
    foreach (ChannelDispatcherBase channelDispatcherBase in serviceHostBase.ChannelDispatchers)
    {
    ChannelDispatcher channelDispatcher = channelDispatcherBase as ChannelDispatcher;
    channelDispatcher.ErrorHandlers.Add(typeErrorHandler);
    }
    }
    private string strUrl_m;
    ///<summary>
    ///Specifies a url of the service, displayed in the error log
    ///</summary>
    public string Url
    {
    get
    {
    return this.strUrl_m;
    }
    }
    private bool bHandled_m;
    ///<summary>
    ///Determines if the ServiceErrorHandler will consider the exception handled
    ///</summary>
    public bool Handled
    {
    get
    {
    return this.bHandled_m;
    }
    }
    }

    Servicio:

    [ServiceContract(Namespace = "http://example.come/test")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    [ErrorBehavior(typeof(ServiceErrorHandler),"ExceptonTest.svc",false)]
    public class ExceptonTest
    {
    [OperationContract]
    public void TestException()
    {   
    throw new Exception("this is a test!");
    }
    }
    Sólo como sugerencia, por favor no llene su código con comentarios. Ya que permite la combinación de código y el texto, utilice eso para que la gente no tenga que desplazarse a través de un relativamente pequeño bloque de código para ver lo que estás haciendo.

    OriginalEl autor Jeremy

  3. -6

    Para los perezosos (como yo):

    using System.ServiceModel;  
    using System.ServiceModel.Dispatcher;  
    using System.ServiceModel.Description;

    OriginalEl autor user295878

Dejar respuesta

Please enter your comment!
Please enter your name here