web-API-und MVC-exception handling

Sind wir derzeit wieder die Entwicklung unserer web forms-system in den web-API-und MVC (dies ist eine neue Technologie für uns)
Bisher scheint alles ok zu sein, aber wir werden kämpfen, um zurück zu senden Fehlern von Web-API-Anwendung, um die MVC-Anwendung. Wir erkennen, dass wir brauchen, um alle Ausnahmen erfassen und diese verwandeln sich in HTTP-Antworten

Web-API, Produkt-controller sieht wie folgt aus:

public HttpResponseMessage GetProducts()
    {
        BAProduct c = new BAProduct();
        var d = c.GetProducts();
         if (d == null)
            return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "This is a custom error message");
        else
            return Request.CreateResponse(HttpStatusCode.OK, d);
    }

Dem MVC-Anwendung aufrufen, wird die web-API mit folgendem code:-

public T Get<T>()

               using (HttpClient client = new HttpClient())
                    {
                        client.BaseAddress = new Uri(Config.API_BaseSite);

                        client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                        HttpResponseMessage response = client.GetAsync("api/myapplicaton/products").Result;
                        response.EnsureSuccessStatusCode();
                        T res = response.Content.ReadAsAsync<T>().Result;
                        return (T)res;
                    }
            }

Was wir versuchen zu erreichen ist, wenn eine HTTP-Fehlermeldung empfangen wird, von der web-API innerhalb der MVC-Anwendung, die Benutzer entweder weitergeleitet, um eine benutzerdefinierte Fehlerseite, oder zeigen Sie die benutzerdefinierte Fehlermeldung in der aktuellen Ansicht (je nach schwere des Fehlers).
Das Problem, das wir haben ist, dass:-

Wie wir den Zugriff auf die benutzerdefinierte Fehlermeldung, die haben wir zurück geschickt? ( aus der Beispiel-code wäre dies "Dies ist eine benutzerdefinierte Fehlermeldung", haben Wir durch jedes Attribut im res und kann nicht sehen, diese Nachricht)
Je nach status-code, wie wir erfassen diese und leiten Sie Benutzer, um individuelle Fehler-Seiten, d.h. die Seite 404, 500-Seite und anzeigen der benutzerdefinierten response-Nachricht, die gesendet wurde, zurück.
wir haben seit der globalen.asax route
```
protected void Application_Error(object sender, EventArgs e)
{
    Exception exception = Server.GetLastError();
    Response.Clear();
    HttpException httpException = exception as HttpException;
```

jedoch unsere httpExecption ist immer NULL

Wir haben gesucht etc, und als der noch, nicht finden können, was gegebenenfalls
hoffentlich kann mir jemand weisen uns in die richtige Richtung.

InformationsquelleAutor Simon | 2013-12-29

12

Der Grund, warum Ihr httpException-Instanz null ist, weil die response.EnsureSuccessStatusCode(); Methode nicht geworfen ein HttpException das ist, was Sie versuchen, zu wirken, zu. Es wirft ein HttpRequestException was anders ist, hat aber keinen einfachen Weg, um weitere details (wie dem status-code für Beispiel).

Als alternative zu dem Aufruf dieser Methode, die Sie testen könnten IsSuccessStatusCode boolean-Eigenschaft, und werfen ein HttpException selbst:
```
public T Get()
{
    using (HttpClient client = new HttpClient())
    {
        client.BaseAddress = new Uri(Config.API_BaseSite);

        client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
        HttpResponseMessage response = client.GetAsync("api/myapplicaton/products").Result;
        if (!response.IsSuccessStatusCode)
        {
            string responseBody = response.Content.ReadAsStringAync().Result;
            throw new HttpException((int)response.StatusCode, responseBody);
        }

        T res = response.Content.ReadAsAsync<T>().Result;
        return (T)res;
    }
}
```
Diese HttpException könnte jetzt gefangen werden in Ihrem Application_Error und je nach status-code gehen Sie mit der Handhabung:
```
protected void Application_Error()
{
    var exception = Server.GetLastError();
    var httpException = exception as HttpException;
    Response.Clear();
    Server.ClearError();

    var routeData = new RouteData();
    routeData.Values["controller"] = "Errors";
    routeData.Values["action"] = "Http500";
    routeData.Values["exception"] = exception;

    Response.StatusCode = 500;
    Response.TrySkipIisCustomErrors = true;

    if (httpException != null)
    {
        Response.StatusCode = httpException.GetHttpCode();
        switch (Response.StatusCode)
        {
            case 403:
                routeData.Values["action"] = "Http403";
                break;
            case 404:
                routeData.Values["action"] = "Http404";
                break;

            //TODO: Add other cases if you want to handle
            //different status codes from your Web API
        }
    }

    IController errorsController = new ErrorsController();
    var rc = new RequestContext(new HttpContextWrapper(Context), routeData);
    errorsController.Execute(rc);
}
```
In diesem Beispiel gehe ich davon aus, dass Sie eine ErrorsController mit den jeweiligen Aktionen (Http500, Http403, Http404, ...). Die jeweilige Aktion aufgerufen werden, die je nach status-code und Sie können wieder unterschiedliche Ansichten.

UPDATE:

Möchten Sie vielleicht, um zu erfassen zusätzliche Artefakte der HTTP-Anforderung wie die reason phrase, so dass Sie hängen Sie es in Ihrem Fehler-Seite. In diesem Fall können Sie einfach schreiben Sie Ihre eigene Ausnahme, die enthalten die Informationen, die Sie benötigen:
```
public class ApiException : Exception
{
    public HttpStatusCode StatusCode { get; set; }
    public string Reason { get; set; }
    public string ResponseBody { get; set; }
}
```
dass Sie werfen könnte:
```
if (!response.IsSuccessStatusCode)
{
    throw new ApiException    
    {
        StatusCode = response.StatusCode,
        Reason = response.ReasonPhrase,
        ResponseBody = response.Content.ReadAsStringAync().Result,
    };
}
```
und arbeiten Sie dann mit dieser benutzerdefinierte Ausnahme in Ihrem Application_Error.
- Hi, danke für die schnelle Antwort, Es war sehr hilfreich, gerade getestet und das hat es uns nun, den Benutzer zu der entsprechenden Fehler-Seite, allerdings, wie ist es möglich, die benutzerdefinierte Fehlermeldung in der createErrorResponse? dies ist nur möglich mit dem update, das Sie Hinzugefügt haben? wenn ja, was ist der Punkt hinzufügen diese Nachricht in? danke nochmal
- Was passiert, wenn du es getestet? War die Application_Error erreicht? War die ErrorsController ausgeführt? Wie hast du das definieren der entsprechenden error-Seite? Hast du auch definieren ein ErrorsController? Sollten Sie keine benutzerdefinierten Fehler definiert in Ihrem web.config, da in diesem Beispiel alle die Behandlung erfolgt in Application_Error. Es wird überspringen, benutzerdefinierte Fehlerseiten, die Sie haben könnten, definiert.
- Hi, danke für die schnelle Antwort, Es war sehr hilfreich, gerade getestet und das hat es uns nun, den Benutzer zu der entsprechenden Fehler-Seite, allerdings, wie ist es möglich, die benutzerdefinierte Fehlermeldung in der createErrorResponse? dies ist nur möglich mit dem update, das Sie Hinzugefügt haben? wenn ja, was ist der Punkt hinzufügen diese Nachricht in? danke nochmal
- Wenn Sie HttpException dann die benutzerdefinierte Fehlermeldung in der ex.Message. Wenn Sie die ApiException dann wird es im ex.Reason. Der Zweck der Verwendung einer ApiException ist, dass es Ihnen ermöglicht zu erfassen, die Reaktion des Körpers in Ergänzung zu den Grund. Im HTTP-Protokoll Sie können status-code (200, ...), Grund (so etwas wie eine Beschreibung für den status-code) und der response-body.
- Tatsächlich habe ich einen Fehler gemacht. Es scheint, dass die CreateErrorResponse - Methode serialisiert die Nachricht als Teil der Antwort der Körper-und nicht als Grund. Ich update meine Antwort. Könnten Sie throw new HttpException((int)response.StatusCode, response.Content.ReadAsStringAync().Result); um der Lage sein, um übergeben Sie die Antwort Körper als message der exception. Und dann rufen Sie es mit ex.Message.
- Danke, ich verstehe das Konzept auf die APIException (dies könnte in einem gemeinsamen Projekt zwischen der API und MVC), und davon ausgehen, dass ResponseBody könnte, enthalten die vollständigen Angaben zu den Fehlern. Was ich bin immer noch am kämpfen mit (ich bin wohl albern) ist, wie die Fehlermeldung ("Dies ist eine benutzerdefinierte Nachricht") von der createErrorResponse innerhalb der MVC-rufen. dh. if (!Antwort.IsSuccessStatusCode) { throw new HttpException((int)Antwort.StatusCode, Antwort.ReasonPhrase); } Ist es ein Weg, um die benutzerdefinierte Nachricht aus dem response-Objekt
- Haben Sie Lesen Sie meinen vorherigen Kommentar? Lesen Sie es sorgfältig wieder auf. Sollten Sie verwenden throw new HttpException((int)response.StatusCode, response.Content.ReadAsStringAync().Result);. Und anschließend in die Application_Error verwenden ex.Message die Fehlermeldung zu bekommen. Auch der Zweck der ApiException ist überhaupt nicht geteilt werden zwischen dem Web-API-und MVC-Anwendung. Diese Klasse ist nur in der MVC-Anwendung. Ihre Web-API nicht wissen nichts über es. Es wird verwendet, um transport-nützliche Informationen über den Fehler zu Application_Error event, die sonst nicht verfügbar sein.
- Ich verstehe. Das ist genial, funktioniert perfekt, wie schon erwähnt, wir sind neu in der MVC, so ich danke Ihnen für Ihre Zeit und den Patienten.
- ErrorsController Umsetzung finden Sie unter link ---- stackoverflow.com/a/5229581/1129978
InformationsquelleAutor Darin Dimitrov

Einen hervorragenden Beitrag zur Lösung des obigen Problems ist hier

Es hat im wesentlichen zwei Hauptschritte-

Schritt-1 : Deserialisiert den Inhalt in der HTTP-Fehler-Ergebnisse, z.B.

var httpErrorObject = response.Content.ReadAsStringAsync().Result;

//Create an anonymous object to use as the template for deserialization:
var anonymousErrorObject = 
    new { message = "", ModelState = new Dictionary<string, string[]>() };

//Deserialize:
var deserializedErrorObject = 
    JsonConvert.DeserializeAnonymousType(httpErrorObject, anonymousErrorObject);

Schritt 2: Hinzufügen Fehler im ModelState Wörterbücher Client-Seite

foreach (var error in apiEx.Errors)
{
     ModelState.AddModelError("", error);
}