DbEntityValidationException - Wie kann ich leicht erkennen, was den Fehler verursacht hat?

Ich habe ein Projekt mit Entity Framework. Beim Aufruf SaveChanges auf meine DbContext bekomme ich folgende exception:

System.Daten.Entität.Die Validierung.DbEntityValidationException: Validierung
fehlgeschlagen für eine oder mehrere Entitäten. Siehe 'EntityValidationErrors' - Eigenschaft
für weitere details.

Dies ist alles schön und gut, aber ich will nicht, um einen debugger anfügen jedes mal, wenn diese Ausnahme Auftritt. Mehr über, in Produktionsumgebungen kann ich nicht einfach einen debugger Anhängen, so dass ich gehen auf große Längen zu reproduzieren diesen Fehler.

Wie kann ich sehen, die versteckte details in der DbEntityValidationException?

InformationsquelleAutor der Frage Martin Devillers | 2013-04-04

c#entity-framework

396

Die einfachste Lösung ist das überschreiben SaveChanges auf Ihre Entitäten-Klasse. Sie können fangen die DbEntityValidationException, wickeln Sie die tatsächlichen Fehler und erstellen Sie eine neue DbEntityValidationException mit der verbesserten Nachricht.
1. Erstellen Sie eine partielle Klasse, die neben Ihrer SomethingSomething.Kontext.cs-Datei.
2. Verwenden Sie den code an der Unterseite von diesem post.
3. Das ist es. Ihre Umsetzung wird automatisch die überschriebenen SaveChanges ohne Refactoring-arbeiten.
Ihre Ausnahme-Nachricht wird nun wie folgt Aussehen:

System.Daten.Entität.Die Validierung.DbEntityValidationException: Validierung
fehlgeschlagen für eine oder mehrere Entitäten. Siehe 'EntityValidationErrors' - Eigenschaft
für weitere details. Der Fehler bei der Validierung: Das Feld Telefonnummer
muss ein string oder array-Typ mit einer maximalen Länge von '12';
Nachname ist ein Pflichtfeld.

Drop können Sie die überschriebene SaveChanges in jeder Klasse, die erbt von DbContext:
```
public partial class SomethingSomethingEntities
{
    public override int SaveChanges()
    {
        try
        {
            return base.SaveChanges();
        }
        catch (DbEntityValidationException ex)
        {
            //Retrieve the error messages as a list of strings.
            var errorMessages = ex.EntityValidationErrors
                    .SelectMany(x => x.ValidationErrors)
                    .Select(x => x.ErrorMessage);
    
            //Join the list to a single string.
            var fullErrorMessage = string.Join("; ", errorMessages);
    
            //Combine the original exception message with the new one.
            var exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);
    
            //Throw a new DbEntityValidationException with the improved exception message.
            throw new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors);
        }
    }
}
```
Den DbEntityValidationException enthält auch die Personen, die die Validierung Fehler. Also, wenn Sie benötigen noch mehr Informationen, können Sie ändern Sie den obigen code zur Ausgabe von Informationen über diese Personen.

Siehe auch: http://devillers.nl/improving-dbentityvalidationexception/

InformationsquelleAutor der Antwort Martin Devillers

Als Martin angegeben, weitere Informationen gibt es in der DbEntityValidationResult. Ich fand es hilfreich, um sowohl meine POCO-Klasse-name und name der Eigenschaft in jeder Nachricht, und wollte vermeiden, dass das schreiben eines benutzerdefinierten ErrorMessage Attribute auf alle meine [Required] tags nur für diese.

Den folgenden tweak zu Martins code kümmerte sich um diese details für mich:

//Retrieve the error messages as a list of strings.
List<string> errorMessages = new List<string>();
foreach (DbEntityValidationResult validationResult in ex.EntityValidationErrors)
{
    string entityName = validationResult.Entry.Entity.GetType().Name;
    foreach (DbValidationError error in validationResult.ValidationErrors)
    {
        errorMessages.Add(entityName + "." + error.PropertyName + ": " + error.ErrorMessage);
    }
}

InformationsquelleAutor der Antwort Eric Hirst

41

Anzeigen EntityValidationErrors Sammlung, fügen Sie den folgenden Ausdruck in das überwachungsfenster.
```
((System.Data.Entity.Validation.DbEntityValidationException)$exception).EntityValidationErrors
```
Ich bin mit visual studio 2013

InformationsquelleAutor der Antwort Shehab Fawzy
13

Während Sie in den debug-Modus in der catch {...} block öffnen Sie die "Schnellüberwachung" - Fenster (Strg+alt+f) und fügen Sie es:
```
((System.Data.Entity.Validation.DbEntityValidationException)ex).EntityValidationErrors
```
Wird diese ermöglichen es Ihnen, einen Drilldown in die ValidationErrors Baum. Es ist der einfachste Weg, den ich gefunden habe, erhalten Sie sofortigen Einblick in diese Fehler.

Für Visual 2012+ - Benutzer interessieren sich nur für die erste Fehlermeldung und möglicherweise nicht über eine catch blockieren, können Sie auch tun:
```
((System.Data.Entity.Validation.DbEntityValidationException)$exception).EntityValidationErrors.First().ValidationErrors.First().ErrorMessage
```
InformationsquelleAutor der Antwort GONeale
8

Schnell eine aussagekräftige Fehlermeldung, indem Sie den Fehler beim Debuggen:
- Fügen Sie eine schnelle Uhr für:
```
((System.Data.Entity.Validation.DbEntityValidationException)$exception).EntityValidationErrors
```
- Drill-down in EntityValidationErrors wie diese:
  
  (Sammlung Element, z.B. [0]) > ValidationErrors > (Sammlung Element, z.B. [0]) > ErrorMessage
InformationsquelleAutor der Antwort Chris Halcrow
5

Tatsächlich, dies ist nur die Validierung Problem, EF überprüft, ob Sie der Person zunächst die Eigenschaften, bevor Sie änderungen an der Datenbank.
So, EF wird geprüft, ob die Eigenschaft value ist out of range, wie wenn Sie die Tabelle. Table_Column_UserName ist vom Datentyp varchar(20). Aber in EF, den Sie eingegeben haben einen Wert, der mehr als 20.
Oder, in anderen Fällen, wenn die Spalte nicht Null ist.
Also, bei der überprüfung, müssen Sie einen Wert fest, der nicht null-Spalte, egal, ob Sie gehen, um die änderung vorzunehmen.
Ich persönlich, wie die Leniel Macaferi Antwort. Es kann zeigen Ihnen die Details des validierungsprobleme

InformationsquelleAutor der Antwort Calvin
3

Denke ich, dass "Der tatsächliche Fehler bei der Validierung" können vertrauliche Informationen enthalten, und dies könnte der Grund sein, warum Microsoft wählte, um Sie in einem anderen Ort (Eigenschaften). Die Lösung markiert, hier ist praktisch, aber es sollte mit Vorsicht eingenommen werden.

Ich würde es bevorzugen, erstellen Sie eine extension-Methode. Weitere Gründe, die für diese:
- Halten ursprünglichen stack-trace
- Folgen offen/geschlossen-Prinzip (dh.: Ich kann verschiedene Nachrichten für verschiedene Arten von logs)
- In Produktionsumgebungen es könnte auch andere Orte (zB.: andere dbcontext), wo ein DbEntityValidationException geworfen werden konnte.
InformationsquelleAutor der Antwort Luis Toapanta

-1

Für Azure-Funktionen, die wir verwenden dieses einfache Erweiterung Microsoft.Extensions.Die Protokollierung.ILogger

public static class LoggerExtensions
{
    public static void Error(this ILogger logger, string message, Exception exception)
    {
        if (exception is DbEntityValidationException dbException)
        {
            message += "\nValidation Errors: ";
            foreach (var error in dbException.EntityValidationErrors.SelectMany(entity => entity.ValidationErrors))
            {
                message += $"\n * Field name: {error.PropertyName}, Error message: {error.ErrorMessage}";
            }
        }

        logger.LogError(default(EventId), exception, message);
    }
}

und Beispiel für die Verwendung:

try
{
    do something with request and EF
}
catch (Exception e)
{
    log.Error($"Failed to create customer due to an exception: {e.Message}", e);
    return await StringResponseUtil.CreateResponse(HttpStatusCode.InternalServerError, e.Message);
}

InformationsquelleAutor der Antwort Juri

-2

Verwenden Sie try-block im code wie

try
{
    //Your code...
    //Could also be before try if you know the exception occurs in SaveChanges

    context.SaveChanges();
}
catch (DbEntityValidationException e)
{
    foreach (var eve in e.EntityValidationErrors)
    {
        Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
            eve.Entry.Entity.GetType().Name, eve.Entry.State);
        foreach (var ve in eve.ValidationErrors)
        {
            Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                ve.PropertyName, ve.ErrorMessage);
        }
    }
    throw;
}

Können Sie die details auch hier

InformationsquelleAutor der Antwort Atta H.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.