c# see Die Validierung ist für eine oder mehrere Entitäten fehlgeschlagen. Weitere Informationen finden Sie unter Eigenschaft 'EntityValidationErrors'




validation failed for one or more entities see entityvalidationerrors property for more details (18)

Das funktioniert für mich.

var modelState = ModelState.Values;
if (!ModelState.IsValid)
{
    return RedirectToAction("Index", "Home", model);
}

Setzen Sie einen Haltepunkt auf if-Anweisung. Dann können Sie ModelState in Debugfenstern überprüfen. Auf jedem Wert können Sie sehen, ob es einen Fehler und sogar die Fehlermeldung gibt. Das ist es. Wenn Sie es nicht mehr brauchen, löschen oder kommentieren Sie einfach die Zeile.

Ich hoffe, das wird helfen.

Wenn gefragt, kann ich einen detaillierten Screenshot im Debug-Fenster zur Verfügung stellen.

Ich habe diesen Fehler beim Seeding meiner Datenbank mit dem ersten Codeansatz.

Die Validierung ist für eine oder mehrere Entitäten fehlgeschlagen. Weitere Informationen finden Sie unter Eigenschaft 'EntityValidationErrors'.

Um ehrlich zu sein, weiß ich nicht, wie ich den Inhalt der Validierungsfehler überprüfen soll. Visual Studio zeigt mir, dass es ein Array mit 8 Objekten ist, also 8 Validierungsfehler.

Dies funktionierte mit meinem vorherigen Modell, aber ich habe ein paar Änderungen vorgenommen, die ich unten erläutere:

  • Ich hatte ein Enum namens Status, ich änderte es in eine Klasse namens Status
  • Ich habe die Klasse ApplicantsPositionHistory so geändert, dass sie zwei Fremdschlüssel für dieselbe Tabelle enthält

Entschuldigung für den langen Code, aber ich muss alles einfügen. Die Ausnahme wird in der letzten Zeile des folgenden Codes ausgelöst.

namespace Data.Model
{  
    public class Position
    {
        [DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.Identity)]   
        public int PositionID { get; set; }

        [Required(ErrorMessage = "Position name is required.")]
        [StringLength(20, MinimumLength = 3, ErrorMessage = "Name should not be longer than 20 characters.")]
        [Display(Name = "Position name")]              
        public string name { get; set; }

        [Required(ErrorMessage = "Number of years is required")] 
        [Display(Name = "Number of years")]        
        public int yearsExperienceRequired { get; set; }

        public virtual ICollection<ApplicantPosition> applicantPosition { get; set; }
    }

    public class Applicant
    {
        [DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.Identity)]      
        public int ApplicantID { get; set; }

        [Required(ErrorMessage = "Name is required")] 
        [StringLength(20, MinimumLength = 3, ErrorMessage="Name should not be longer than 20 characters.")]
        [Display(Name = "First and LastName")]
        public string name { get; set; }

        [Required(ErrorMessage = "Telephone number is required")] 
        [StringLength(10, MinimumLength = 3, ErrorMessage = "Telephone should not be longer than 20 characters.")]
        [Display(Name = "Telephone Number")]
        public string telephone { get; set; }

        [Required(ErrorMessage = "Skype username is required")] 
        [StringLength(10, MinimumLength = 3, ErrorMessage = "Skype user should not be longer than 20 characters.")]
        [Display(Name = "Skype Username")]
        public string skypeuser { get; set; }

        public byte[] photo { get; set; }

        public virtual ICollection<ApplicantPosition> applicantPosition { get; set; }
    }

    public class ApplicantPosition
    {
        [Key]
        [Column("ApplicantID", Order = 0)]
        public int ApplicantID { get; set; }

        [Key]
        [Column("PositionID", Order = 1)]
        public int PositionID { get; set; }

        public virtual Position Position { get; set; }

        public virtual Applicant Applicant { get; set; }

        [Required(ErrorMessage = "Applied date is required")] 
        [DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
        [Display(Name = "Date applied")]     
        public DateTime appliedDate { get; set; }

        [Column("StatusID", Order = 0)]
        public int StatusID { get; set; }

        public Status CurrentStatus { get; set; }

        //[NotMapped]
        //public int numberOfApplicantsApplied
        //{
        //    get
        //    {
        //        int query =
        //             (from ap in Position
        //              where ap.Status == (int)Status.Applied
        //              select ap
        //                  ).Count();
        //        return query;
        //    }
        //}
    }

    public class Address
    {
        [StringLength(20, MinimumLength = 3, ErrorMessage = "Country should not be longer than 20 characters.")]
        public string Country { get; set; }

        [StringLength(20, MinimumLength = 3, ErrorMessage = "City  should not be longer than 20 characters.")]
        public string City { get; set; }

        [StringLength(50, MinimumLength = 3, ErrorMessage = "Address  should not be longer than 50 characters.")]
        [Display(Name = "Address Line 1")]     
        public string AddressLine1 { get; set; }

        [Display(Name = "Address Line 2")]
        public string AddressLine2 { get; set; }   
    }

    public class ApplicationPositionHistory
    {
        [DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.Identity)]
        public int ApplicationPositionHistoryID { get; set; }

        public ApplicantPosition applicantPosition { get; set; }

        [Column("oldStatusID")]
        public int oldStatusID { get; set; }

        [Column("newStatusID")]
        public int newStatusID { get; set; }

        public Status oldStatus { get; set; }

        public Status newStatus { get; set; }

        [StringLength(500, MinimumLength = 3, ErrorMessage = "Comments  should not be longer than 500 characters.")]
        [Display(Name = "Comments")]
        public string comments { get; set; }

        [DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
        [Display(Name = "Date")]     
        public DateTime dateModified { get; set; }
    }

    public class Status
    {
        [DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.Identity)]
        public int StatusID { get; set; }

        [StringLength(20, MinimumLength = 3, ErrorMessage = "Status  should not be longer than 20 characters.")]
        [Display(Name = "Status")]
        public string status { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Entity;
using System.IO;

namespace Data.Model
{
    public class HRContextInitializer : DropCreateDatabaseAlways<HRContext>
    {
        protected override void Seed(HRContext context)
        {
            #region Status
            Status applied = new Status() { status = "Applied" };
            Status reviewedByHR = new Status() { status = "Reviewed By HR" };
            Status approvedByHR = new Status() { status = "Approved by HR" };
            Status rejectedByHR = new Status() { status = "Rejected by HR" };
            Status assignedToTechnicalDepartment = new Status() { status = "Assigned to Technical Department" };
            Status approvedByTechnicalDepartment = new Status() { status = "Approved by Technical Department" };
            Status rejectedByTechnicalDepartment = new Status() { status = "Rejected by Technical Department" };

            Status assignedToGeneralManager = new Status() { status = "Assigned to General Manager" };
            Status approvedByGeneralManager = new Status() { status = "Approved by General Manager" };
            Status rejectedByGeneralManager = new Status() { status = "Rejected by General Manager" };

            context.Status.Add(applied);
            context.Status.Add(reviewedByHR);
            context.Status.Add(approvedByHR);
            context.Status.Add(rejectedByHR);
            context.Status.Add(assignedToTechnicalDepartment);
            context.Status.Add(approvedByTechnicalDepartment);
            context.Status.Add(rejectedByTechnicalDepartment);
            context.Status.Add(assignedToGeneralManager);
            context.Status.Add(approvedByGeneralManager);
            context.Status.Add(rejectedByGeneralManager); 
            #endregion    

            #region Position
            Position netdeveloper = new Position() { name = ".net developer", yearsExperienceRequired = 5 };
            Position javadeveloper = new Position() { name = "java developer", yearsExperienceRequired = 5 };
            context.Positions.Add(netdeveloper);
            context.Positions.Add(javadeveloper); 
            #endregion

            #region Applicants
            Applicant luis = new Applicant()
            {
                name = "Luis",
                skypeuser = "le.valencia",
                telephone = "0491732825",
                photo = File.ReadAllBytes(@"C:\Users\LUIS.SIMBIOS\Documents\Visual Studio 2010\Projects\SlnHR\HRRazorForms\Content\pictures\1.jpg")
            };

            Applicant john = new Applicant()
            {
                name = "John",
                skypeuser = "jo.valencia",
                telephone = "3435343543",
                photo = File.ReadAllBytes(@"C:\Users\LUIS.SIMBIOS\Documents\Visual Studio 2010\Projects\SlnHR\HRRazorForms\Content\pictures\2.jpg")
            };

            context.Applicants.Add(luis);
            context.Applicants.Add(john); 
            #endregion

            #region ApplicantsPositions
            ApplicantPosition appicantposition = new ApplicantPosition()
            {
                Applicant = luis,
                Position = netdeveloper,
                appliedDate = DateTime.Today,
                StatusID = 1
            };

            ApplicantPosition appicantposition2 = new ApplicantPosition()
            {
                Applicant = john,
                Position = javadeveloper,
                appliedDate = DateTime.Today,
                StatusID = 1
            };        

            context.ApplicantsPositions.Add(appicantposition);            
            context.ApplicantsPositions.Add(appicantposition2); 
            #endregion

            context.SaveChanges(); --->> Error here
        }
    }
}

Wenn Sie nur eine generische Ausnahme abfangen , können Sie dies als DbEntityValidationException darstellen . Dieser Typ einer Ausnahme weist eine Validierungsfehlereigenschaft auf, und Sie werden alle weiteren Probleme finden, wenn Sie Ihren Weg in diese Ausnahme fortsetzen.

Wenn Sie beispielsweise einen Haltepunkt in den Fang setzen, können Sie Folgendes in eine Armbanduhr werfen:

((System.Data.Entity.Validation.DbEntityValidationException ) ex)

Ein Beispiel für einen Fehler ist, wenn ein Feld Nullen nicht erlaubt und Sie eine Null-Zeichenfolge haben, sehen Sie, dass das Feld erforderlich ist.


Per @ Slaumas Antwort und @ Miltons Vorschlag Ich habe die benutzerdefinierte Save-Methode der Basisklasse um einen try / catch erweitert, der diese Art von Ausnahmen behandelt (und somit unsere Fehlerprotokollierung protokolliert!).

// Where `BaseDB` is your Entities object... (it could be `this` in a different design)
public void Save(bool? validateEntities = null)
{
    try
    {
        //Capture and set the validation state if we decide to
        bool validateOnSaveEnabledStartState = BaseDB.Configuration.ValidateOnSaveEnabled;
        if (validateEntities.HasValue)
            BaseDB.Configuration.ValidateOnSaveEnabled = validateEntities.Value;

        BaseDB.SaveChanges();

        //Revert the validation state when done
        if (validateEntities.HasValue)
            BaseDB.Configuration.ValidateOnSaveEnabled = validateOnSaveEnabledStartState;
    }
    catch (DbEntityValidationException e)
    {
        StringBuilder sb = new StringBuilder();
        foreach (var eve in e.EntityValidationErrors)
        {
            sb.AppendLine(string.Format("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)
            {
                sb.AppendLine(string.Format("- Property: \"{0}\", Error: \"{1}\"",
                                            ve.PropertyName,
                                            ve.ErrorMessage));
            }
        }
        throw new DbEntityValidationException(sb.ToString(), e);
    }
}

Was ich gefunden habe ... wenn ich 'EntityValidationErrors' error habe, ist das .... Ich habe ein Feld in meiner Datenbank 'db1' in der Tabelle 'tbladdress' als 'address1' welches eine Größe von 100 hat (zB address varchar (100) Null) und ich übergab Wert mehr als 100 Zeichen..und dies führte zu Fehler beim Speichern von Daten in der Datenbank ....

Sie müssen also die Daten überprüfen, die Sie an das Feld übergeben.


Ich musste dies im Direktfenster schreiben: 3

(((exception as System.Data.Entity.Validation.DbEntityValidationException).EntityValidationErrors as System.Collections.Generic.List<System.Data.Entity.Validation.DbEntityValidationResult>)[0].ValidationErrors as System.Collections.Generic.List<System.Data.Entity.Validation.DbValidationError>)[0]

um tief in den genauen Fehler zu kommen!


Bitte überprüfen Sie die Felder Wert, den Sie übergeben, sind gültig und nach Datenbankfeldern. Zum Beispiel ist die Anzahl der Zeichen, die in einem bestimmten Feld übergeben werden, kleiner als die im Datenbanktabellenfeld definierten Zeichen.


Mit der Antwort von @Slauma habe ich ein Code-Snippet (eine Einfassung mit Snippet) zur besseren Verwendung erstellt.

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <SnippetTypes>
        <SnippetType>SurroundsWith</SnippetType>
      </SnippetTypes>
      <Title>ValidationErrorsTryCatch</Title>
      <Author>Phoenix</Author>
      <Description>
      </Description>
      <HelpUrl>
      </HelpUrl>
      <Shortcut>
      </Shortcut>
    </Header>
    <Snippet>
      <Code Language="csharp"><![CDATA[try
{
    $selected$ $end$
}
catch (System.Data.Entity.Validation.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;
}]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Ich habe diesen Fehler vorher gesehen

wenn ich versucht habe, ein bestimmtes Feld in meinem Modell in Entity Framwork zu aktualisieren

Letter letter = new Letter {ID = letterId, ExportNumber = letterExportNumber,EntityState = EntityState.Modified};
LetterService.ChangeExportNumberfor(letter);
//----------


public int ChangeExportNumber(Letter letter)
    {
        int result = 0;
        using (var db = ((LettersGeneratorEntities) GetContext()))
        {
            db.Letters.Attach(letter);
            db.Entry(letter).Property(x => x.ExportNumber).IsModified = true;
            result += db.SaveChanges();
        }
        return result;
    }

und entsprechend den obigen Antworten

Ich habe die Validierungsnachricht gefunden The SignerName field is required.

welches auf Feld in meinem Modell zeigt

und als ich mein Datenbankschema überprüfte, fand ich

So ist die Gültigkeit der ValidationException berechtigt

und nach diesem Feld möchte ich, dass es nullfähig ist (ich weiß nicht, wie ich es vermasselt habe)

Also habe ich dieses Feld geändert, um Null zu erlauben, und dadurch wird mir mein Code diesen Fehler nicht wieder geben

Dieser Fehler tritt möglicherweise auf, wenn Sie Ihre Datenintegrität Ihrer Datenbank ungültig machen


Während Sie sich im Debug-Modus im catch {...} Block catch {...} , öffnen Sie das Fenster "QuickWatch" ( Strg + Alt + Q ) und fügen Sie dort ein:

((System.Data.Entity.Validation.DbEntityValidationException)ex).EntityValidationErrors

oder:

((System.Data.Entity.Validation.DbEntityValidationException)$exception).EntityValidationErrors

Wenn Sie nicht versuchen / fangen oder keinen Zugriff auf das Ausnahmeobjekt haben.

Auf diese Weise können Sie einen Drilldown in die ValidationErrors Struktur durchführen. Es ist der einfachste Weg, den ich gefunden habe, um einen sofortigen Einblick in diese Fehler zu bekommen.


So können Sie den Inhalt der EntityValidationErrors in Visual Studio überprüfen (ohne zusätzlichen Code schreiben zu müssen), zB während des Debuggens in der IDE .

Das Problem?

Sie haben Recht: Das EntityValidationErrors Popup des Visual Studio-Debuggers zeigt nicht die tatsächlichen Fehler in der EntityValidationErrors Auflistung an.

Die Lösung!

Fügen Sie einfach den folgenden Ausdruck in ein Schnellüberwachungsfenster ein und klicken Sie auf Neubewertung .

((System.Data.Entity.Validation.DbEntityValidationException)$exception).EntityValidationErrors

In meinem Fall sehen Sie, wie ich in der ValidationErrors List in der EntityValidationErrors Auflistung EntityValidationErrors

Referenzen: http://mattrandle.me/viewing-entityvalidationerrors-in-visual-studio/ , @ Yoel Antwort


Für eine schnelle Möglichkeit, den ersten Fehler zu sehen, ohne eine Uhr hinzuzufügen, können Sie diese in das Direktfenster einfügen:

((System.Data.Entity.Validation.DbEntityValidationException)$exception)
    .EntityValidationErrors.First()
    .ValidationErrors.First()

Fange die Exception in einem try catch und watch dann kurz oder ctrl + d & ctrl + q und du kannst bis zu den EntityValidationErrors bohren.


Um ehrlich zu sein, weiß ich nicht, wie ich den Inhalt der Validierungsfehler überprüfen soll. Visual Studio zeigt mir, dass es ein Array mit 8 Objekten ist, also 8 Validierungsfehler.

Eigentlich sollten Sie die Fehler sehen, wenn Sie während des Debuggings in Visual Studio in dieses Array bohren. Sie können jedoch auch die Ausnahme abfangen und dann die Fehler in einen Protokollspeicher oder die Konsole schreiben:

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

EntityValidationErrors ist eine Auflistung, die die Entitäten darstellt, die nicht erfolgreich validiert werden konnten, und die innere Auflistung ValidationErrors pro Entity ist eine Liste von Fehlern auf Property-Ebene.

Diese Validierungsnachrichten sind normalerweise hilfreich genug, um die Ursache des Problems zu finden.

Bearbeiten

Ein paar kleine Verbesserungen:

Der Wert der beanstandeten Eigenschaft kann wie folgt in der inneren Schleife enthalten sein:

        foreach (var ve in eve.ValidationErrors)
        {
            Console.WriteLine("- Property: \"{0}\", Value: \"{1}\", Error: \"{2}\"",
                ve.PropertyName,
                eve.Entry.CurrentValues.GetValue<object>(ve.PropertyName),
                ve.ErrorMessage);
        }

Beim Debuggen von Debug.Write ist Console.WriteLine möglicherweise vorzuziehen, da es in allen Arten von Anwendungen funktioniert, nicht nur in Konsolenanwendungen (dank @Bart für seine Notiz in den Kommentaren unten).

Für Webanwendungen, die sich in Produktion befinden und Elmah für die Ausnahmeprotokollierung verwenden, hat es sich als sehr nützlich erwiesen, eine benutzerdefinierte Ausnahme zu erstellen und SaveChanges überschreiben, um diese neue Ausnahme SaveChanges .

Der benutzerdefinierte Ausnahmetyp sieht folgendermaßen aus:

public class FormattedDbEntityValidationException : Exception
{
    public FormattedDbEntityValidationException(DbEntityValidationException innerException) :
        base(null, innerException)
    {
    }

    public override string Message
    {
        get
        {
            var innerException = InnerException as DbEntityValidationException;
            if (innerException != null)
            {
                StringBuilder sb = new StringBuilder();

                sb.AppendLine();
                sb.AppendLine();
                foreach (var eve in innerException.EntityValidationErrors)
                {
                    sb.AppendLine(string.Format("- Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                        eve.Entry.Entity.GetType().FullName, eve.Entry.State));
                    foreach (var ve in eve.ValidationErrors)
                    {
                        sb.AppendLine(string.Format("-- Property: \"{0}\", Value: \"{1}\", Error: \"{2}\"",
                            ve.PropertyName,
                            eve.Entry.CurrentValues.GetValue<object>(ve.PropertyName),
                            ve.ErrorMessage));
                    }
                }
                sb.AppendLine();

                return sb.ToString();
            }

            return base.Message;
        }
    }
}

Und SaveChanges kann folgendermaßen überschrieben werden:

public class MyContext : DbContext
{
    // ...

    public override int SaveChanges()
    {
        try
        {
            return base.SaveChanges();
        }
        catch (DbEntityValidationException e)
        {
            var newException = new FormattedDbEntityValidationException(e);
            throw newException;
        }
    }
}

Ein paar Bemerkungen:

  • Der gelbe Fehlerbildschirm, den Elmah in der Weboberfläche oder in den gesendeten E-Mails anzeigt (wenn Sie dies konfiguriert haben), zeigt nun die Validierungsdetails direkt am Anfang der Nachricht an.

  • Das Überschreiben der Message Eigenschaft in der benutzerdefinierten Ausnahme anstelle des Überschreibens von ToString() hat den Vorteil, dass der Standard-ASP.NET-Bildschirm "Yellow screen of death (YSOD)" diese Meldung ebenfalls anzeigt. Im Gegensatz zu Elmah verwendet die YSOD anscheinend nicht ToString() , aber beide zeigen die Message Eigenschaft an.

  • DbEntityValidationException die ursprüngliche DbEntityValidationException als innere Ausnahme eingeschlossen wird, ist sichergestellt, dass die ursprüngliche Stack-Ablaufverfolgung weiterhin verfügbar ist und in Elmah und YSOD angezeigt wird.

  • Durch Setzen eines Haltepunkts in der Zeile throw newException; Sie können die newException.Message Eigenschaft einfach als Text prüfen, anstatt in die Validierungssammlungen zu bohren. newException.Message ist ein wenig peinlich und scheint nicht für alle leicht zu funktionieren (siehe Kommentare unten).


Für jeden, der in VB.NET

Try
Catch ex As DbEntityValidationException
    For Each a In ex.EntityValidationErrors
        For Each b In a.ValidationErrors
            Dim st1 As String = b.PropertyName
            Dim st2 As String = b.ErrorMessage
        Next
    Next
End Try

Die Antwort von @Slauma ist wirklich großartig, aber ich fand, dass es nicht funktionierte, wenn eine ComplexType-Eigenschaft ungültig war.

PhoneNumber , Sie haben eine Eigenschaft Phone des komplexen Typs PhoneNumber . Wenn die AreaCode Eigenschaft ungültig ist, lautet der Name der Eigenschaft in ve.PropertyNames "Phone.AreaCode". Dies führt dazu, dass der Aufruf von eve.Entry.CurrentValues<object>(ve.PropertyName) fehlschlägt.

Um dies zu beheben, können Sie den Eigenschaftsnamen an jedem teilen . , dann recurse durch das resultierende Array von Eigenschaftsnamen. Wenn Sie schließlich am Ende der Kette ankommen, können Sie einfach den Wert der Eigenschaft zurückgeben.

Unten ist @Slaumas FormattedDbEntityValidationException-Klasse mit Unterstützung für ComplexTypes.

Genießen!

[Serializable]
public class FormattedDbEntityValidationException : Exception
{
    public FormattedDbEntityValidationException(DbEntityValidationException innerException) :
        base(null, innerException)
    {
    }

    public override string Message
    {
        get
        {
            var innerException = InnerException as DbEntityValidationException;
            if (innerException == null) return base.Message;

            var sb = new StringBuilder();

            sb.AppendLine();
            sb.AppendLine();
            foreach (var eve in innerException.EntityValidationErrors)
            {
                sb.AppendLine(string.Format("- Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                    eve.Entry.Entity.GetType().FullName, eve.Entry.State));
                foreach (var ve in eve.ValidationErrors)
                {
                    object value;
                    if (ve.PropertyName.Contains("."))
                    {
                        var propertyChain = ve.PropertyName.Split('.');
                        var complexProperty = eve.Entry.CurrentValues.GetValue<DbPropertyValues>(propertyChain.First());
                        value = GetComplexPropertyValue(complexProperty, propertyChain.Skip(1).ToArray());
                    }
                    else
                    {
                        value = eve.Entry.CurrentValues.GetValue<object>(ve.PropertyName);
                    }
                    sb.AppendLine(string.Format("-- Property: \"{0}\", Value: \"{1}\", Error: \"{2}\"",
                        ve.PropertyName,
                        value,
                        ve.ErrorMessage));
                }
            }
            sb.AppendLine();

            return sb.ToString();
        }
    }

    private static object GetComplexPropertyValue(DbPropertyValues propertyValues, string[] propertyChain)
    {
        var propertyName = propertyChain.First();
        return propertyChain.Count() == 1 
            ? propertyValues[propertyName] 
            : GetComplexPropertyValue((DbPropertyValues)propertyValues[propertyName], propertyChain.Skip(1).ToArray());
    }
}

Sie können dies während des Debugging von Visual Studio aus tun, ohne Code zu schreiben, nicht einmal einen Catch-Block.

Fügen Sie einfach eine Uhr mit dem Namen hinzu:

((System.Data.Entity.Validation.DbEntityValidationException)$exception).EntityValidationErrors

Die $exception Ausdrucks watch gibt eine Ausnahme aus, die im aktuellen Kontext ausgelöst wurde, auch wenn sie nicht abgefangen und einer Variablen zugewiesen wurde.

Basiert auf http://mattrandle.me/viewing-entityvalidationerrors-in-visual-studio/


Ich werfe nur meine zwei Cent in ...

Innerhalb meiner dbConfiguration.cs möchte ich meine context.SaveChanges () -Methode in eine try / catch-Methode einbinden und eine Ausgabetextdatei erzeugen, die es mir ermöglicht, die Fehler deutlich zu lesen, und dieser Code gibt ihnen auch Zeitstempel - praktisch, wenn Sie laufe zu mehr als einem Fehler zu verschiedenen Zeiten!

        try
        {
            context.SaveChanges();
        }
        catch (DbEntityValidationException e)
        {
            //Create empty list to capture Validation error(s)
            var outputLines = new List<string>();

            foreach (var eve in e.EntityValidationErrors)
            {
                outputLines.Add(
                    $"{DateTime.Now}: Entity of type \"{eve.Entry.Entity.GetType().Name}\" in state \"{eve.Entry.State}\" has the following validation errors:");
                outputLines.AddRange(eve.ValidationErrors.Select(ve =>
                    $"- Property: \"{ve.PropertyName}\", Error: \"{ve.ErrorMessage}\""));
            }
            //Write to external file
            File.AppendAllLines(@"c:\temp\dbErrors.txt", outputLines);
            throw;
        }

Wie in anderen Posts erwähnt, fangen Sie einfach die Ausnahme in der DbEntityValidationException-Klasse ab. Dadurch erhalten Sie während der Fehlerfälle den erforderlichen Wasserbedarf.

 try
 {
  ....
 }
 catch(DbEntityValidationException ex)
 {
  ....
 }




entity-framework-4.1