Convalida non riuscita per una o più entità durante il salvataggio delle modifiche al database SQL Server mediante Entity Framework

Voglio salvare la mia modifica nel database e sto usando Entity FrameWork Code-First in ASP.NET MVC 3 / C # ma sto riscontrando errori. Nella mia classe Event, ho i tipi di dati DateTime e TimeSpan ma nel mio database ho rispettivamente la data e l'ora. Potrebbe essere questa la ragione? Come posso trasmettere il tipo di dati appropriato nel codice prima di salvare le modifiche al database.

public class Event
{
    public int EventId { get; set; }
    public int CategoryId { get; set; }
    public int PlaceId { get; set; }
    public string Title { get; set; }
    public decimal Price { get; set; }
    public DateTime EventDate { get; set; }
    public TimeSpan StartTime { get; set; }
    public TimeSpan EndTime { get; set; }
    public string Description { get; set; }
    public string EventPlaceUrl { get; set; }
    public Category Category { get; set; }
    public Place Place { get; set; }
}

Metodo nel controller >>>> Problema su storeDB.SaveChanges ();

// POST: /EventManager/Edit/386        
[HttpPost]
public ActionResult Edit(int id, FormCollection collection)
{
    var theEvent = storeDB.Events.Find(id);

    if (TryUpdateModel(theEvent))
    {
        storeDB.SaveChanges();
        return RedirectToAction("Index");
    }
    else
    {
        ViewBag.Categories = storeDB.Categories.OrderBy(g => g.Name).ToList();
        ViewBag.Places = storeDB.Places.OrderBy(a => a.Name).ToList();
        return View(theEvent);
    }
}

con

public class EventCalendarEntities : DbContext
{
    public DbSet<Event> Events { get; set; }
    public DbSet<Category> Categories { get; set; }
    public DbSet<Place> Places { get; set; } 
}

Database SQL Server 2008 R2 / T-SQL

EventDate (Datatype = date)  
StartTime (Datatype = time)  
EndTime (Datatype = time)  

Modulo http

EventDate (Datatype = DateTime) e.g. 4/8/2011 12:00:00 AM  
StartTime (Datatype = Timespan/time not sure) e.g. 08:30:00  
EndTime (Datatype = Timespan/time not sure) e.g. 09:00:00  

Errore del server nell'applicazione '/'

Convalida non riuscita per una o più entità. Vedi la proprietà 'EntityValidationErrors' per maggiori dettagli.

Descrizione: si è verificata un'eccezione non gestita durante l'esecuzione della richiesta Web corrente. Esaminare la traccia dello stack per ulteriori informazioni sull'errore e sulla sua origine nel codice.

Dettagli eccezione: System.Data.Entity.Validation.DbEntityValidationException: convalida non riuscita per una o più entità. Vedi la proprietà 'EntityValidationErrors' per maggiori dettagli.

Errore sorgente:

Line 75:             if (TryUpdateModel(theEvent))
Line 76:             {
Line 77:                 storeDB.SaveChanges();
Line 78:                 return RedirectToAction("Index");
Line 79:             }

File di origine: C: \ sep \ MvcEventCalendar \ MvcEventCalendar \ Controllers \ EventManagerController.cs Riga: 77

Stack Trace:

[DbEntityValidationException: convalida non riuscita per una o più entità. Vedi la proprietà 'EntityValidationErrors' per maggiori dettagli.]

Puoi estrarre tutte le informazioni da DbEntityValidationExceptioncon il seguente codice (devi aggiungere gli spazi dei nomi: System.Data.Entity.Validatione System.Diagnosticsal tuo usingelenco):

catch (DbEntityValidationException dbEx)
{
    foreach (var validationErrors in dbEx.EntityValidationErrors)
    {
        foreach (var validationError in validationErrors.ValidationErrors)
        {
            Trace.TraceInformation("Property: {0} Error: {1}", 
                                    validationError.PropertyName, 
                                    validationError.ErrorMessage);
        }
    }
}

Nessuna modifica del codice richiesta:

Mentre sei in modalità debug all'interno del catch {...}blocco apri la finestra "QuickWatch" ( Ctrl+ Alt+ Q) e incolla lì:

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

o:

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

Se non ci si trova in try / catch o non si ha accesso all'oggetto eccezione.

Ciò ti consentirà di eseguire il drill down ValidationErrorssull'albero. È il modo più semplice che ho trovato per ottenere una visione istantanea di questi errori.

Nel caso in cui tu abbia classi con gli stessi nomi di proprietà, ecco una piccola estensione alla risposta di Praveen:

 catch (DbEntityValidationException dbEx)
 {
    foreach (var validationErrors in dbEx.EntityValidationErrors)
    {
       foreach (var validationError in validationErrors.ValidationErrors)
       {
          Trace.TraceInformation(
                "Class: {0}, Property: {1}, Error: {2}",
                validationErrors.Entry.Entity.GetType().FullName,
                validationError.PropertyName,
                validationError.ErrorMessage);
       }
    }
 }

Come miglioramento sia per Praveen che per Tony, utilizzo una sostituzione:

public partial class MyDatabaseEntities : DbContext
{
    public override int SaveChanges()
    {
        try
        {
            return base.SaveChanges();
        }
        catch (DbEntityValidationException dbEx)
        {
            foreach (var validationErrors in dbEx.EntityValidationErrors)
            {
                foreach (var validationError in validationErrors.ValidationErrors)
                {
                    Trace.TraceInformation("Class: {0}, Property: {1}, Error: {2}",
                        validationErrors.Entry.Entity.GetType().FullName,
                        validationError.PropertyName,
                        validationError.ErrorMessage);
                }
            }

            throw;  // You can also choose to handle the exception here...
        }
    }
}

Questa implementazione include l'eccezione dell'entità all'eccezione con il testo dettagliato. Gestisce DbEntityValidationException, DbUpdateException, datetime2errori di intervallo (MS SQL), e comprendono chiave di entità non valida in un messaggio (utile quando savind molte entità in una sola SaveChangeschiamata).

Innanzitutto, sovrascrivi SaveChangesnella classe DbContext:

public class AppDbContext : DbContext
{
    public override int SaveChanges()
    {
        try
        {
            return base.SaveChanges();
        }
        catch (DbEntityValidationException dbEntityValidationException)
        {
            throw ExceptionHelper.CreateFromEntityValidation(dbEntityValidationException);
        }
        catch (DbUpdateException dbUpdateException)
        {
            throw ExceptionHelper.CreateFromDbUpdateException(dbUpdateException);
        }
    }   

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken)
    {
        try
        {
            return await base.SaveChangesAsync(cancellationToken);
        }
        catch (DbEntityValidationException dbEntityValidationException)
        {
            throw ExceptionHelper.CreateFromEntityValidation(dbEntityValidationException);
        }
        catch (DbUpdateException dbUpdateException)
        {
            throw ExceptionHelper.CreateFromDbUpdateException(dbUpdateException);
        }
    }

Classe ExceptionHelper:

public class ExceptionHelper
{
    public static Exception CreateFromEntityValidation(DbEntityValidationException ex)
    {
        return new Exception(GetDbEntityValidationMessage(ex), ex);
    }

    public static string GetDbEntityValidationMessage(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);
        return exceptionMessage;
    }

    public static IEnumerable<Exception> GetInners(Exception ex)
    {
        for (Exception e = ex; e != null; e = e.InnerException)
            yield return e;
    }

    public static Exception CreateFromDbUpdateException(DbUpdateException dbUpdateException)
    {
        var inner = GetInners(dbUpdateException).Last();
        string message = "";
        int i = 1;
        foreach (var entry in dbUpdateException.Entries)
        {
            var entry1 = entry;
            var obj = entry1.CurrentValues.ToObject();
            var type = obj.GetType();
            var propertyNames = entry1.CurrentValues.PropertyNames.Where(x => inner.Message.Contains(x)).ToList();
            // check MS SQL datetime2 error
            if (inner.Message.Contains("datetime2"))
            {
                var propertyNames2 = from x in type.GetProperties()
                                        where x.PropertyType == typeof(DateTime) ||
                                            x.PropertyType == typeof(DateTime?)
                                        select x.Name;
                propertyNames.AddRange(propertyNames2);
            }

            message += "Entry " + i++ + " " + type.Name + ": " + string.Join("; ", propertyNames.Select(x =>
                string.Format("'{0}' = '{1}'", x, entry1.CurrentValues[x])));
        }
        return new Exception(message, dbUpdateException);
    }
}

Questo codice mi ha aiutato a trovare il mio problema quando ho avuto problemi con il mio Entity VAlidation Erros. Mi ha detto l'esatto problema con la mia definizione di entità. Prova a seguire il codice in cui è necessario coprire storeDB.SaveChanges (); nel seguito prova a prendere il blocco.

  try
{
         if (TryUpdateModel(theEvent))
         {
             storeDB.SaveChanges();
             return RedirectToAction("Index");
         }
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
    Exception raise = dbEx;
    foreach (var validationErrors in dbEx.EntityValidationErrors)
    {
        foreach (var validationError in validationErrors.ValidationErrors)
        {
            string message = string.Format("{0}:{1}", 
                validationErrors.Entry.Entity.ToString(),
                validationError.ErrorMessage);
            // raise a new exception nesting
            // the current instance as InnerException
            raise = new InvalidOperationException(message, raise);
        }
    }
    throw raise;
}

Oggi stavo ricevendo questo errore e non riuscivo a risolverlo per un po ', ma mi sono reso conto che dopo aver aggiunto alcuni RequireAttributes ai miei modelli e che alcuni dati di seed di sviluppo non stavano popolando tutti i campi richiesti.
Quindi, basta notare che se si verifica questo errore durante l'aggiornamento del database tramite una sorta di strategia init come DropCreateDatabaseIfModelChangesallora, è necessario assicurarsi che i dati di seed soddisfino e soddisfino tutti gli attributi di convalida dei dati del modello .

So che questo è leggermente diverso dal problema nella domanda, ma è una domanda popolare, quindi ho pensato di aggiungere un po 'di più alla risposta per gli altri che hanno lo stesso problema.
Spero che questo aiuti gli altri :)

Penso che l'aggiunta di try / catch per ogni SaveChanges()operazione non sia una buona pratica, è meglio centralizzare questo:

Aggiungi questa classe alla DbContextclasse principale :

public override int SaveChanges()
{
    try
    {
        return base.SaveChanges();
    }
    catch (DbEntityValidationException ex)
    {
        string errorMessages = string.Join("; ", ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage));
        throw new DbEntityValidationException(errorMessages);
    }
}

Questo sovrascriverà il SaveChanges()metodo del tuo contesto e otterrai un elenco separato da virgole contenente tutti gli errori di convalida dell'entità.

anche questo può essere migliorato, per registrare gli errori nell'ambiente di produzione, anziché semplicemente lanciare un errore.

spero che sia utile

Ecco un'estensione per l'estensione di Tony ... :-)

Per Entity Framework 4.x, se si desidera ottenere il nome e il valore del campo chiave in modo da sapere quale istanza dell'entità (record DB) presenta il problema, è possibile aggiungere quanto segue. Ciò fornisce l'accesso ai membri della classe ObjectContext più potenti dall'oggetto DbContext.

// Get the key field name & value.
// This assumes your DbContext object is "_context", and that it is a single part key.
var e = ((IObjectContextAdapter)_context).ObjectContext.ObjectStateManager.GetObjectStateEntry(validationErrors.Entry.Entity);
string key = e.EntityKey.EntityKeyValues[0].Key;
string val = e.EntityKey.EntityKeyValues[0].Value;

Non mi piacciono le eccezioni, ho registrato OnSaveChanges e ho questo

var validationErrors = model.GetValidationErrors();

var h = validationErrors.SelectMany(x => x.ValidationErrors
                                          .Select(f => "Entity: " 
                                                      +(x.Entry.Entity) 
                                                      + " : " + f.PropertyName 
                                                      + "->" + f.ErrorMessage));

Questo errore si verifica anche quando si tenta di salvare un'entità con errori di convalida. Un buon modo per causare ciò è dimenticare di controllare ModelState.IsValid prima di salvare sul DB.

Assicurati che se hai nvarchar (50) nella riga DB non cerchi di inserire più di 50 caratteri al suo interno. Stupido errore, ma mi ci sono volute 3 ore per capirlo.

Ciò potrebbe essere dovuto al numero massimo di caratteri consentito per una colonna specifica, come in sql un campo potrebbe avere il seguente tipo di dati, nvarchar(5)ma il numero di caratteri immessi dall'utente è maggiore di quello specificato, quindi si verifica l'errore.

Ho riscontrato lo stesso problema un paio di giorni fa durante l'aggiornamento del database. Nel mio caso, sono state aggiunte alcune nuove colonne non annullabili per manutenzione che non sono state fornite nel codice che causa l'eccezione. Ho capito quei campi e fornito valori per loro e risolto.

Grazie per le tue risposte, mi aiuta molto. come codice in Vb.Net, questo codice Bolt per Vb.Net

Try
   Return MyBase.SaveChanges()
Catch dbEx As Validation.DbEntityValidationException
   For Each [error] In From validationErrors In dbEx.EntityValidationErrors
                       From validationError In validationErrors.ValidationErrors
                       Select New With { .PropertyName = validationError.PropertyName,
                                         .ErrorMessage = validationError.ErrorMessage,
                                         .ClassFullName = validationErrors.Entry.Entity
                                                                    .GetType().FullName}

        Diagnostics.Trace.TraceInformation("Class: {0}, Property: {1}, Error: {2}",
                                           [error].ClassFullName,
                                           [error].PropertyName,
                                           [error].ErrorMessage)
   Next
   Throw
End Try

può essere causato da Proprietà che non è popolata dal modello .. invece è popolata da Controller .. che può causare questo errore .. la soluzione a ciò è assegnare la proprietà prima di applicare la validazione ModelState. e questo secondo presupposto è. potresti avere già dei dati nel tuo database e provare ad aggiornarli ma ora li stanno recuperando.

Nel mio caso ho un nome di colonna della colonna Path il cui tipo di dati ho impostato era varchar (200). Dopo averlo aggiornato su nvarchar (max), ho eliminato la tabella da edmx e poi ho aggiunto nuovamente la tabella e si è svegliata correttamente per me.