Exception Handler für ServiceClientBase

Question

Ich möchte alle von meinem Service-Client geworfen behandeln. Gibt es einen guten Weg, dies jetzt zu tun?

Zum Beispiel übergebe ich eine einzelne ServiceClientBase um eine Windows Forms App. Ich gebe einen API-Schlüssel an den Server in einem HTTP-Header. Für jede Anfrage, dass der API-Schlüssel nicht gültig ist, möchte ich ein Meldungsfeld anzeigen, das dem Benutzer mitteilt, dass die Anfrage nicht autorisiert war und sie den API-Schlüssel setzen sollten. Aber ich diesen Code nicht überall will:

try 
{ 
    _client.Get(new ReqDto()); 
} 
catch (WebServiceException ex) 
{ 
    if(ex.StatusCode == 401) 
     Util.ShowUnauthorizedMessageBox(); 
} 

So etwas wäre schön:

_client.WebServiceExceptionHandler += TheHandler; 

Ich weiß, dass es die lokalen Antwortfilter, die ich in einhaken kann, aber ich brauche die materialisierte WebServiceException .

Ich freue mich auf ServiceClientBase.cs, um zu sehen, was ich tun kann, aber ich würde jede Hilfe zu schätzen wissen. Vielen Dank.

Answer 1

Wenn ich dies eher als Designfrage und nicht als API-Frage anspreche, dann ist die Antwort, Ihren Service-Client zu verpacken. Persönlich habe ich etwas Ähnliches getan, damit ich Service-Ausnahmen auf dem Client protokollieren kann.

Dies könnte ein Ausgangspunkt sein:

public class MyServiceClient : IDisposable 
{ 
    public ServiceClientBase ServiceClient { get; set; } 

    string _serviceUri; 
    public string ServiceUri 
    { 
     get { return _serviceUri; } 
     set { _serviceUri = value; ServiceUriChanged(); } 
    } 

    public MyServiceClient() 
    { 
     ServiceUri = "http://127.0.0.1:8080"; 
    } 

    public void Dispose() 
    { 
     ServiceClient.Dispose(); 
    } 

    public TResponse Get<TResponse>(IReturn<TResponse> request) 
    { 
     try 
     { 
      return ServiceClient.Get(request); 
     } 
     catch (WebServiceException ex) 
     { 
      if(ex.StatusCode == 401) 
       Util.ShowUnauthorizedMessageBox(); 
     } 
    } 

    void ServiceUriChanged() 
    { 
     if (ServiceClient != null) 
      ServiceClient.Dispose(); 
     ServiceClient = new JsonServiceClient(ServiceUri); 
    } 
} 

Im Laufe der Zeit Sie weitere Vorteile dieser zusätzlichen Dereferenzierungsebene, wie das Hinzufügen von lokalen Caching, die Protokollierung aller Anfragen & Antworten [auf eine Debug-Konsole] finden. Und sobald es in Ihrem gesamten Client-Code verwendet wird, ist es ziemlich billig zu warten.

Soweit die API geht, glaube ich nicht, dass es bietet was Sie wollen. Persönlich war ich damit zufrieden (vor allem, da die Schnittstelle IReturn<T> hilft, Funktionen wie die zu konsolidieren, die Sie wollen). Aber, wenn Sie nicht damit zufrieden sind, dann sind Sie eine Pull-Anfrage weg von einem Dialog mit Demis zu verbessern. (- =

Answer 2

Dies ist ein bisschen zu spät zum Spiel, aber ich lief in die gleiche Sache begann so in die Quelle zu graben. Es gibt eigentlich eine einfache Lösung, überschreiben die HandleResponseException Methode in was auch immer ServiceClient Sie sind mit Direct aus den Kommentaren.

 /// <summary> 
     /// Called by Send method if an exception occurs, for instance a System.Net.WebException because the server 
     /// returned an HTTP error code. Override if you want to handle specific exceptions or always want to parse the 
     /// response to a custom ErrorResponse DTO type instead of ServiceStack's ErrorResponse class. In case ex is a 
     /// <c>System.Net.WebException</c>, do not use 
     /// <c>createWebRequest</c>/<c>getResponse</c>/<c>HandleResponse&lt;TResponse&gt;</c> to parse the response 
     /// because that will result in the same exception again. Use 
     /// <c>ThrowWebServiceException&lt;YourErrorResponseType&gt;</c> to parse the response and to throw a 
     /// <c>WebServiceException</c> containing the parsed DTO. Then override Send to handle that exception. 
     /// </summary> 

ich persönlich so etwas wie die folgenden auf meine Überschreibung der JsonServiceClient

protected override bool HandleResponseException<TResponse>(Exception ex, object request, string requestUri, Func<System.Net.WebRequest> createWebRequest, Func<System.Net.WebRequest, System.Net.WebResponse> getResponse, out TResponse response) 
    { 
     Boolean handled; 
     response = default(TResponse); 
     try 
     { 
      handled = base.HandleResponseException(ex, request, requestUri, createWebRequest, getResponse, out response); 
     } 
     catch (WebServiceException webServiceException) 
     { 
      if(webServiceException.StatusCode > 0) 
       throw new HttpException(webServiceException.StatusCode, webServiceException.ErrorMessage); 
      throw; 
     } 
     return handled; 
    } 

tue