.Net WFC/service Web de gestion des exceptions modèle de conception

Ok, j'ai regardé dans le IErrorHandler idée. Je n'avais aucune idée que vous pourriez faire de cette façon, et c'est l'idéal car il vous permet d'éviter d'essayer de captures pour chaque méthode. Pouvez-vous faire cela dans les services web standard de trop? J'ai mis en place la façon suivante:

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

Service:

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

OriginalL'auteur Jeremy