Entity Framework: "L'istruzione di aggiornamento, inserimento o eliminazione dello store ha interessato un numero imprevisto di righe (0)." [chiuso]

Sto usando Entity Framework per popolare un controllo di griglia. A volte quando faccio aggiornamenti ottengo il seguente errore:

L'istruzione di aggiornamento, inserimento o eliminazione dello store ha interessato un numero imprevisto di righe (0). Le entità potrebbero essere state modificate o eliminate da quando le entità sono state caricate. Aggiorna voci ObjectStateManager.

Non riesco a capire come riprodurlo. Ma potrebbe avere qualcosa a che fare con quanto vicino faccio gli aggiornamenti. Qualcuno ha visto questo o qualcuno sa a cosa si riferisce il messaggio di errore?

Modifica: Sfortunatamente non sono più libero di riprodurre il problema che avevo qui, perché mi sono allontanato da questo progetto e non ricordo se alla fine ho trovato una soluzione, se un altro sviluppatore l'ha risolto o se ci ho lavorato. Pertanto non posso accettare alcuna risposta.

Questo è un effetto collaterale di una funzionalità chiamata concorrenza ottimistica.

Non sono sicuro al 100% su come attivarlo / disattivarlo in Entity Framework, ma fondamentalmente quello che ti dice è che tra quando hai estratto i dati dal database e quando hai salvato le modifiche qualcun altro ha cambiato i dati (il che significava quando sei andato per salvarlo 0 righe effettivamente aggiornate). In termini SQL, la loro updatequerywhere clausola contiene il valore originale di ogni campo della riga e se sono interessate 0 righe, sa che qualcosa è andato storto.

L'idea alla base è che non finirai per sovrascrivere una modifica che la tua applicazione non sapeva fosse accaduta - è fondamentalmente una piccola misura di sicurezza introdotta da .NET su tutti i tuoi aggiornamenti.

Se è coerente, ci sono delle probabilità che stia accadendo all'interno della tua logica (ad esempio: stai effettivamente aggiornando i dati tu stesso in un altro metodo tra la selezione e l'aggiornamento), ma potrebbe essere semplicemente una condizione di competizione tra due applicazioni.

Mi sono imbattuto in questo ed è stato causato dal campo ID (chiave) dell'entità non impostato. Pertanto, quando il contesto è andato a salvare i dati, non è stato possibile trovare un ID = 0. Accertarsi di inserire un punto di interruzione nell'istruzione di aggiornamento e verificare che l'ID dell'entità sia stato impostato.

Dal commento di Paul Bellora

Ho avuto questo esatto problema, causato dalla dimenticanza di includere l'input ID nascosto nella pagina di modifica .cshtml

Wow, molte risposte, ma ho avuto questo errore quando ho fatto qualcosa di leggermente diverso che nessun altro ha menzionato.

Per EntityState.Modifiedfarla breve, se si crea un nuovo oggetto e si dice a EF che è stato modificato utilizzando il , verrà generato questo errore in quanto non esiste ancora nel database. Ecco il mio codice:

MyObject foo = new MyObject()
{
    someAttribute = someValue
};

context.Entry(foo).State = EntityState.Modified;
context.SaveChanges();

Sì, questo sembra stupido, ma è nato perché il metodo in questione era foopassato ad esso essendo stato creato in precedenza, ora è someValuepassato solo ad esso e si crea foo.

Facile correzione, basta cambiare EntityState.Modifieda EntityState.Addedo cambiamento che tutta la linea a:

context.MyObject.Add(foo);

Stavo affrontando questo stesso errore spaventoso ... :) Poi mi sono reso conto che stavo dimenticando di impostare un

@Html.HiddenFor(model => model.UserProfile.UserId)

per la chiave primaria dell'oggetto da aggiornare! Tendo a dimenticare questa cosa semplice, ma molto importante!

A proposito: HiddenForè per ASP.NET MVC.

Controlla se hai dimenticato l'attributo "DataKeyNames" in GridView. è un must quando si modificano i dati all'interno di GridView

http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.gridview.datakeynames.aspx

Il problema è causato da una di queste due cose:

1. Hai provato ad aggiornare una riga con una o più proprietà sono Concurrency Mode: Fixed.. e la concorrenza ottimistica ha impedito il salvataggio dei dati. Vale a dire. alcuni hanno modificato i dati della riga tra il momento in cui hai ricevuto i dati del server e quando hai salvato i dati del server.
2. Hai provato ad aggiornare o eliminare una riga ma la riga non esiste. Un altro esempio di qualcuno che modifica i dati (in questo caso, rimuovendo) tra un recupero e poi salva O stai pianificando il nostro tentativo di aggiornare un campo che non è un'Identità (es. StoreGeneratedPattern = Computed) E quella riga non esiste.

Ho avuto lo stesso errore perché parte del PK era una colonna datetime e il record che veniva inserito utilizzava DateTime.Oow come valore per quella colonna. Il framework di entità inserisce il valore con precisione in millisecondi, quindi cerca il valore che ha appena inserito anche con precisione in millisecondi. Tuttavia, SqlServer ha arrotondato il valore alla seconda precisione, e quindi il framework dell'entità non è stato in grado di trovare il valore di precisione in millisecondi.

La soluzione consisteva nel troncare i millisecondi di DateTime.Oow prima dell'inserimento.

Avevo lo stesso problema e la risposta di @ webtrifusion mi ha aiutato a trovare la soluzione.

Il mio modello utilizzava l' Bind(Exclude)attributo sull'ID dell'entità che causava il valore dell'ID dell'entità su zero su HttpPost.

namespace OrderUp.Models
{
[Bind(Exclude = "OrderID")]
public class Order
{
    [ScaffoldColumn(false)]
    public int OrderID { get; set; }

    [ScaffoldColumn(false)]
    public System.DateTime OrderDate { get; set; }

    [Required(ErrorMessage = "Name is required")]
    public string Username { get; set; }
    }
}   

Ho avuto lo stesso problema, ho capito che era causato dalla RowVersion che era nulla. Verifica che il tuo ID e RowVersion non siano nulli .

per ulteriori informazioni consultare questo tutorial

http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/handling-concurrency-with-the-entity-framework-in-an-asp-net-mvc-application

Ho iniziato a ricevere questo errore dopo essere passato dal primo modello al primo codice. Ho più thread che aggiornano un database in cui alcuni potrebbero aggiornare la stessa riga. Non so perché non ho avuto problemi con l'utilizzo del modello, suppongo che utilizzi un valore predefinito di concorrenza diverso.

Per gestirlo in un posto conoscendo le condizioni in cui potrebbe verificarsi, ho aggiunto il seguente sovraccarico alla mia classe DbContext:

using System.Data.Entity.Core.Objects;
using System.Data.Entity.Infrastructure;

public class MyDbContext: DbContext {
...
        public int SaveChanges(bool refreshOnConcurrencyException, RefreshMode refreshMode = RefreshMode.ClientWins) {
            try {
                return SaveChanges();
            }
            catch (DbUpdateConcurrencyException ex) {
                foreach (DbEntityEntry entry in ex.Entries) {
                    if (refreshMode == RefreshMode.ClientWins)
                        entry.OriginalValues.SetValues(entry.GetDatabaseValues());
                    else
                        entry.Reload();
                }
                return SaveChanges();
            }
        }
}

Quindi chiamato SaveChanges(true)ovunque applicabile.

È necessario includere esplicitamente un BoundField della chiave primaria. Se non vuoi che l'utente veda la chiave primaria, devi nasconderla tramite CSS:

    <asp:BoundField DataField="Id_primary_key" ItemStyle-CssClass="hidden" 
HeaderStyle-CssClass="hidden" />

Dove "nascosto" è una classe in CSS che ha il display impostato su "nessuno".

Durante la modifica includere l'id o la chiave primaria dell'entità come campo nascosto nella vista

vale a dire

      @Html.HiddenFor(m => m.Id)

questo risolve il problema.

Inoltre, se il tuo modello include articoli non utilizzati, includi anche quello e pubblicalo sul controller

Ho anche riscontrato questo errore. Il problema si è scoperto è stato causato da un trigger sul tavolo che stavo cercando di salvare. Il trigger ha usato "INSTEAD OF INSERT", il che significa che 0 righe sono mai state inserite in quella tabella, quindi l'errore. Fortunatamente in questo caso la funzionalità di trigger era errata, ma suppongo che potrebbe essere un'operazione valida che dovrebbe in qualche modo essere gestita nel codice. Spero che questo aiuti qualcuno un giorno.

Mi sono imbattuto in questo problema su una tabella in cui mancava una chiave primaria e aveva una colonna DATETIME (2, 3) (quindi la "chiave primaria" dell'entità era una combinazione di tutte le colonne) ... Durante l'esecuzione dell'inserimento il timestamp aveva un tempo più preciso (20-03-2018 08: 29: 51.8319154) che è stato troncato in (20-03-2018 08: 29: 51.832) in modo che la ricerca sui campi chiave non riesca.

Ho anche avuto questo errore. Esistono alcune situazioni in cui l'Entità potrebbe non essere a conoscenza del contesto di database effettivo in uso o il Modello potrebbe essere diverso. Per questo, impostare: EntityState.Modified; a EntityState.Added;

Per fare questo:

if (ModelState.IsValid)
{
context.Entry(yourModelReference).State = EntityState.Added;
context.SaveChanges();
}

Questo assicurerà che l'Entità sappia che stai usando o aggiungendo lo Stato con cui stai lavorando. A questo punto è necessario impostare tutti i valori di modello corretti. Fare attenzione a non perdere eventuali modifiche che potrebbero essere state apportate in background.

Spero che questo ti aiuti.

  @Html.HiddenFor(model => model.RowVersion)

La mia rowversion era nulla, quindi ho dovuto aggiungere questo alla vista che ha risolto il mio problema

La linea [DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.None)]ha funzionato nel mio caso:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;


[Key]
[DatabaseGenerated(DatabaseGeneratedOption.None)]
public int? SomeNumber { get; set; }

Assicurati solo che sia la tabella che il modulo abbiano la chiave primaria ed edmx aggiornati.

ho riscontrato che gli errori durante l'aggiornamento erano generalmente dovuti a: - Nessuna chiave primaria nella tabella - Nessuna chiave primaria nella vista Modifica / modulo (ad es. @Html.HiddenFor(m=>m.Id)

Ho avuto lo stesso problema. Nel mio caso stavo cercando di aggiornare la chiave primaria, che non è consentita.

Ho avuto questo errore sporadicamente quando ho usato un async metodo. Non è successo da quando sono passato a un metodo sincrono.

Errori sporadici:

[Authorize(Roles = "Admin")]
[HttpDelete]
[Route("file/{id}/{customerId}/")]
public async Task<IHttpActionResult> Delete(int id, int customerId)
{
    var file = new Models.File() { Id = id, CustomerId = customerId };
    db.Files.Attach(file);
    db.Files.Remove(file);

    await db.SaveChangesAsync();

    return Ok();
}

Funziona sempre:

[Authorize(Roles = "Admin")]
[HttpDelete]
[Route("file/{id}/{customerId}/")]
public IHttpActionResult Delete(int id, int customerId)
{
    var file = new Models.File() { Id = id, CustomerId = customerId };
    db.Files.Attach(file);
    db.Files.Remove(file);

    db.SaveChanges();

    return Ok();
}

Ho avuto quell'errore quando stavo cancellando alcune righe nel DB (nel ciclo) e aggiungendo quelle nuove nella stessa tabella.

La soluzione per me è stata quella di creare dinamicamente un nuovo contesto in ogni iterazione di loop

    public void Save(object entity)
    {
        using (var transaction = Connection.BeginTransaction())
        {
        try
                {
                    SaveChanges();
                    transaction.Commit();
                }
                catch (OptimisticConcurrencyException)
                {
                    if (ObjectStateManager.GetObjectStateEntry(entity).State == EntityState.Deleted || ObjectStateManager.GetObjectStateEntry(entity).State == EntityState.Modified)
                        this.Refresh(RefreshMode.StoreWins, entity);
                    else if (ObjectStateManager.GetObjectStateEntry(entity).State == EntityState.Added)
                        Detach(entity);
                    AcceptAllChanges(); 
                    transaction.Commit();
                }
        }
    }

Ciò accadrà anche se stai cercando di inserire una situazione di vincolo unica, ovvero se puoi avere un solo tipo di indirizzo per datore di lavoro e provi a inserire un secondo dello stesso tipo con lo stesso datore di lavoro, otterrai lo stesso problema .

O

Ciò può accadere anche se tutte le proprietà dell'oggetto a cui sono state assegnate, sono state assegnate con gli stessi valori di prima.

        using(var db = new MyContext())
        {
            var address = db.Addresses.FirstOrDefault(x => x.Id == Id);

            address.StreetAddress = StreetAddress; // if you are assigning   
            address.City = City;                   // all of the same values
            address.State = State;                 // as they are
            address.ZipCode = ZipCode;             // in the database    

            db.SaveChanges();           // Then this will throw that exception
        }

Se stai provando a creare una mappatura nel tuo file edmx su una "funzione Importazioni", questo errore può causare questo errore. Deseleziona semplicemente i campi per l'inserimento, l'aggiornamento e l'eliminazione che si trova in Dettagli di mappatura per una determinata entità nel tuo edmx e dovrebbe funzionare. Spero di averlo chiarito.

Ho ottenuto questa eccezione quando ho collegato un oggetto che non esisteva nel database. Avevo supposto che l'oggetto fosse caricato da un contesto separato, ma se era la prima volta che l'utente visitava il sito, l'oggetto veniva creato da zero. Abbiamo chiavi primarie a incremento automatico, quindi potrei sostituirle

context.Users.Attach(orderer);

con

if (orderer.Id > 0) {
    context.Users.Attach(orderer);
}

Bene ho questo stesso problema. Ma questo era dovuto al mio errore. In realtà stavo salvando un oggetto invece di aggiungerlo. Quindi questo era il conflitto.

Un modo per eseguire il debug di questo problema in un ambiente SQL Server è utilizzare il Profiler SQL incluso con la copia di SQL Server o, se si utilizza la versione Express, ottenere una copia di Express Profiler gratuitamente da CodePlex seguendo il seguente link:

Express Profiler

Utilizzando Sql Profiler è possibile accedere a tutto ciò che viene inviato da EF al DB. Nel mio caso ciò equivaleva a:

exec sp_executesql N'UPDATE [dbo].[Category]
SET [ParentID] = @0, [1048] = NULL, [1033] = @1, [MemberID] = @2, [AddedOn] = @3
WHERE ([CategoryID] = @4)
',N'@0 uniqueidentifier,@1 nvarchar(50),@2 uniqueidentifier,@3 datetime2(7),@4 uniqueidentifier',
@0='E060F2CA-433A-46A7-86BD-80CD165F5023',@1=N'I-Like-Noodles-Do-You',@2='EEDF2C83-2123-4B1C-BF8D-BE2D2FA26D09',
@3='2014-01-29 15:30:27.0435565',@4='3410FD1E-1C76-4D71-B08E-73849838F778'
go

Copio questo incollato in una finestra di query in SQL Server ed eseguito. Abbastanza sicuro, anche se è stato eseguito, 0 record sono stati interessati da questa query, quindi l'errore è stato restituito da EF.

Nel mio caso il problema è stato causato dal CategoryID.

Non è stato identificato un ID categoria identificato dall'ID EF inviato al database, pertanto sono interessati 0 record.

Non è stata colpa di EF, ma piuttosto di una buggy a coalescenza nulla "??" istruzione in un controller di visualizzazione che stava inviando sciocchezze al livello dati.

Nessuna delle risposte di cui sopra ha abbastanza coperto la mia situazione e la soluzione ad essa.

Codice in cui è stato generato l'errore nel controller MVC5:

        if (ModelState.IsValid)
        {
            db.Entry(object).State = EntityState.Modified; 
            db.SaveChanges(); // line that threw exception
            return RedirectToAction("Index");
        }

Ho ricevuto questa eccezione quando stavo salvando un oggetto da una vista Modifica. Il motivo per cui è stato lanciato è perché quando sono tornato per salvarlo, avevo modificato le proprietà che costituivano la chiave primaria sull'oggetto. Pertanto, impostare il suo stato su Modified non aveva alcun senso per EF: era una nuova voce, non una precedentemente salvata.

Puoi risolverlo sia A) modificando la chiamata di salvataggio in Aggiungi l'oggetto, sia B) semplicemente non cambiare la chiave primaria in modifica. Ho fatto B).

Quando la risposta accettata diceva " non finirà per sovrascrivere una modifica che la tua applicazione non sapeva fosse accaduta ", ero scettico perché il mio oggetto era stato appena creato. Ma poi si scopre, c'era unINSTEAD OF UPDATE, INSERT- TRIGGER allegato alla tabella che stava aggiornando una colonna calcolata della stessa tabella.

Una volta che lo cambio AFTER INSERT, UPDATE, funzionava bene.

Questo mi è successo a causa di una discrepanza tra datetime e datetime2. Stranamente, ha funzionato bene prima che un tester scoprisse il problema. Il mio codice Il primo modello includeva un DateTime come parte della chiave primaria:

[Key, Column(Order = 2)]  
public DateTime PurchasedDate { get; set; } = (DateTime)SqlDateTime.MinValue;

La colonna generata è una colonna datetime. Quando si chiama SaveChanges, EF ha generato il seguente SQL:

-- Region Parameters
DECLARE @0 Int = 2
DECLARE @1 Int = 25
DECLARE @2 Int = 141051
DECLARE @3 DateTime2 = '2017-07-27 15:16:09.2630000' --(will not equal a datetime value)
-- EndRegion
UPDATE [dbo].[OrganizationSurvey]
SET [OrganizationSurveyStatusId] = @0
WHERE ((([SurveyID] = @1) AND ([OrganizationID] = @2)) AND ([PurchasedDate] = @3))

Poiché stava cercando di abbinare una colonna datetime a un valore datetime2, non ha restituito risultati. L'unica soluzione che mi è venuta in mente è stata quella di cambiare la colonna in un datetime2:

[Key, Column(Order = 2, TypeName = "DateTime2")]  
public DateTime PurchasedDate { get; set; } = (DateTime)SqlDateTime.MinValue;