EF-Code zuerst: Wie wird die Eigenschaft 'EntityValidationErrors' in der Nuget-Paketkonsole angezeigt?

Dafür bin ich ratlos:

Ich habe meine Klassen für einen Code-First-Ansatz für Entity Framework (4.1.3) definiert. Alles war in Ordnung (ich habe die Tabellen usw. erstellt), bis ich anfing zu säen.

Jetzt, wenn ich das mache

Add-Migration "remigrate" ; Update-Database;

Auf der Paketkonsole wird die Fehlermeldung "Die Überprüfung für eine oder mehrere Entitäten ist fehlgeschlagen. Weitere Informationen finden Sie in der Eigenschaft 'EntityValidationErrors'."

Ich habe einen Haltepunkt in meiner Seed () -Methode, aber da ich diesen auf der Konsole ausführe, wenn das Projekt nicht ausgeführt wird, weiß ich nicht, wie ich zu den Details komme (PS - Ich habe gesehen, dass die Thread- Validierung fehlgeschlagen ist für eine oder mehrere Entitäten beim Speichern von Änderungen an der SQL Server-Datenbank mithilfe von Entity Framework, das zeigt, wie ich die Eigenschaft sehen kann.)

Ich weiß, dass meine Seed () -Methode ein Problem hat, denn wenn ich direkt nach dem Methodenaufruf eine Rückgabe mache, verschwindet der Fehler. Wie setze ich meinen Haltepunkt, damit ich den Validierungsfehler sehen kann? Ein bisschen verloren. Oder gibt es eine andere Möglichkeit, es in der Nuget-Konsole zu verfolgen?

Das hat mich in letzter Zeit auch geärgert. Ich habe das Problem behoben, indem ich in der Seed-Methode eine Wrapper-Funktion in die Configuration-Klasse eingefügt und SaveChangesstattdessen Aufrufe von durch Aufrufe meiner Funktion ersetzt habe. Diese Funktion würde einfach die Fehler in der EntityValidationErrorsSammlung auflisten und eine Ausnahme erneut auslösen, in der die Ausnahmemeldung die einzelnen Probleme auflistet. Dadurch wird die Ausgabe in der NuGet-Paketmanagerkonsole angezeigt.

Code folgt:

/// <summary>
/// Wrapper for SaveChanges adding the Validation Messages to the generated exception
/// </summary>
/// <param name="context">The context.</param>
private void SaveChanges(DbContext context) {
    try {
        context.SaveChanges();
    } catch (DbEntityValidationException ex) {
        StringBuilder sb = new StringBuilder();

        foreach (var failure in ex.EntityValidationErrors) {
            sb.AppendFormat("{0} failed validation\n", failure.Entry.Entity.GetType());
            foreach (var error in failure.ValidationErrors) {
                sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
                sb.AppendLine();
            }
        }

        throw new DbEntityValidationException(
            "Entity Validation Failed - errors follow:\n" + 
            sb.ToString(), ex
        ); // Add the original exception as the innerException
    }
}

Ersetzen Sie einfach Aufrufe von context.SaveChanges()durch SaveChanges(context)in Ihrer Seed-Methode.

Erweitern Sie Ihre DBContext-Klasse bereits mit einer Teilklassendefinition!

Wenn Sie sich die Klassendefinition für Ihren DbContext ansehen, sieht sie ungefähr so ​​aus:

// DatabaseContext.cs   -- This file is auto generated and thus shouldn't be changed. 
public partial class [DatabaseContextName] : DbContext { ... }

In einer anderen Datei können Sie also dieselbe Definition erstellen und die gewünschten Teile überschreiben.

// partialDatabaseContext.cs  -- you can safely make changes 
// that will not be overwritten in here.
public partial class [DatabaseContextName] : DbContext { // Override defaults here } 

Die ganze Idee mit Teilklassen - haben Sie bemerkt, dass der DbContext eine Teilklasse ist - ist, dass Sie eine generierte Klasse erweitern (oder Klassen in mehreren Dateien organisieren) können. In unserem Fall möchten wir auch die SaveChanges- Methode überschreiben aus einer Teilklasse heraus , die dem DbContext hinzugefügt wird .

Auf diese Weise können wir Fehler-Debugging-Informationen von allen vorhandenen DbContext / SaveChanges-Aufrufen überall erhalten und müssen Ihren Seed-Code oder Entwicklungscode überhaupt nicht ändern.

Dies ist, was ich tun würde ( HINWEIS: Der Unterschied besteht darin, dass ich die SaveChanges-Methode in unserer eigenen DbContext-Teilklasse überschreibe , NICHT in der GENERIERTEN ). Stellen Sie außerdem sicher, dass Ihre Teilklasse den richtigen Namespace verwendet, da Sie sonst Ihren Kopf gegen die Wand schlagen.

public partial class Database : DbContext
{
    public override int SaveChanges()
    {
        try
        {
            return base.SaveChanges();
        }
        catch (DbEntityValidationException ex)
        {
            var sb = new StringBuilder();

            foreach (var failure in ex.EntityValidationErrors)
            {
                sb.AppendFormat("{0} failed validation\n", failure.Entry.Entity.GetType());
                foreach (var error in failure.ValidationErrors)
                {
                    sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
                    sb.AppendLine();
                }
            }

            throw new DbEntityValidationException(
                "Entity Validation Failed - errors follow:\n" +
                sb.ToString(), ex
                ); // Add the original exception as the innerException
        }
    }
}

Ich habe Richards Antwort in eine Erweiterungsmethode konvertiert:

  public static int SaveChangesWithErrors(this DbContext context)
    {
        try
        {
            return context.SaveChanges();
        }
        catch (DbEntityValidationException ex)
        {
            StringBuilder sb = new StringBuilder();

            foreach (var failure in ex.EntityValidationErrors)
            {
                sb.AppendFormat("{0} failed validation\n", failure.Entry.Entity.GetType());
                foreach (var error in failure.ValidationErrors)
                {
                    sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
                    sb.AppendLine();
                }
            }

            throw new DbEntityValidationException(
                "Entity Validation Failed - errors follow:\n" +
                sb.ToString(), ex
            ); // Add the original exception as the innerException
        }
    }

Rufen Sie so an:

context.SaveChangesWithErrors();

Ich habe die Version von craigvl in C # konvertiert. Ich musste context.SaveChanges () hinzufügen. damit es für mich wie unten funktioniert.

try
{
    byte[] bytes = System.IO.File.ReadAllBytes(@"C:\Users\sheph_000\Desktop\Rawr.png");
    Console.WriteLine(bytes);

    context.BeverageTypes.AddOrUpdate(
        x => x.Name,
        new AATPos.DAL.Entities.BeverageType { ID = 1, Name = "Sodas" }
        );

    context.Beverages.AddOrUpdate(
        x => x.Name,
        new AATPos.DAL.Entities.Beverage { ID = 1, Name = "Coke", BeverageTypeID = 1, ImageData = bytes, IsStocked = true, StockLevel = 10, Price = 10.00M, ImageMimeType = "test" },
        new AATPos.DAL.Entities.Beverage { ID = 2, Name = "Fanta", BeverageTypeID = 1, ImageData = bytes, IsStocked = true, StockLevel = 10, Price = 10.00M, ImageMimeType = "test" },
        new AATPos.DAL.Entities.Beverage { ID = 3, Name = "Sprite", BeverageTypeID = 1, ImageData = bytes, IsStocked = true, StockLevel = 10, Price = 10.00M, ImageMimeType = "test" },
        new AATPos.DAL.Entities.Beverage { ID = 4, Name = "Cream Soda", BeverageTypeID = 1, ImageData = bytes, IsStocked = true, StockLevel = 10, Price = 10.00M, ImageMimeType = "test" },
        new AATPos.DAL.Entities.Beverage { ID = 5, Name = "Pepsi", BeverageTypeID = 1, ImageData = bytes, IsStocked = true, StockLevel = 10, Price = 10.00M, ImageMimeType = "test" }
        );

    context.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
    var sb = new System.Text.StringBuilder();
    foreach (var failure in ex.EntityValidationErrors)
            {
                sb.AppendFormat("{0} failed validation", failure.Entry.Entity.GetType());
        foreach (var error in failure.ValidationErrors)
                {
            sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
            sb.AppendLine();
                }
            }

    throw new Exception(sb.ToString());
}

Richard, danke, dass Sie mich auf den richtigen Weg gebracht haben (hatte das gleiche Problem). Dies ist eine Alternative ohne den Wrapper, der bei der Seed-Methode für die Migrationskonfiguration für mich funktioniert hat:

 Protected Overrides Sub Seed(context As NotificationContext)

        Try
            context.System.AddOrUpdate(
               Function(c) c.SystemName,
                New E_NotificationSystem() With {.SystemName = "System1"},
                New E_NotificationSystem() With {.SystemName = "System2"},
                New E_NotificationSystem() With {.SystemName = "System3"})

            context.SaveChanges()

        Catch ex As DbEntityValidationException

            Dim sb As New StringBuilder

            For Each failure In ex.EntityValidationErrors

                sb.AppendFormat("{0} failed validation" & vbLf, failure.Entry.Entity.[GetType]())

                For Each [error] In failure.ValidationErrors
                    sb.AppendFormat("- {0} : {1}", [error].PropertyName, [error].ErrorMessage)
                    sb.AppendLine()
                Next
            Next

            Throw New Exception(sb.ToString())

        End Try
End Sub

Konnte dann die Ausnahme in der Paketmanager-Konsole sehen. Hoffe das hilft jemandem.