Шаблон разработки обработки исключений.Net WFC/Web service

Хорошо, я изучил идею IErrorHandler. Я понятия не имел, что Вы могли сделать это этот путь, и это прекрасно, потому что это позволяет Вам избежать выгод попытки для каждого метода. Можно ли сделать это в стандартных веб-сервисах также? Я реализовал его следующий путь:

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

Сервис:

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