L'oggetto non può essere eliminato perché non è stato trovato in ObjectStateManager

Ricevo questo errore "Impossibile eliminare l'oggetto perché non è stato trovato in ObjectStateManager."

Il mio codice è:

    protected MyEntities sqlEntities;

    public virtual void Delete(TEntity entity)
    {
        System.Type t = typeof(TEntity);
        sqlEntities.DeleteObject(entity);
        sqlEntities.SaveChanges();
    }

Significa che l'entità non è collegata (non è stata caricata dalla stessa istanza di contesto). Prova questo:

protected MyEntities sqlEntities;

public virtual void Delete(TEntity entity)
{
    sqlEntities.Attach(entity);
    sqlEntities.DeleteObject(entity);
    sqlEntities.SaveChanges();
}

Solo un piccolo chiarimento sulla risposta di Ladislav Mrnka (che dovrebbe essere la risposta accettata).

Se come me, hai il codice in un formato come questo:

using (var context = new MyDataContext())
{
    context.MyTableEntity.Remove(EntytyToRemove);
    var nrOfObjectsChanged = context.SaveChanges();
}

..quindi questo è quello che vuoi fare:

using (var context = new MyDataContext())
{
    // Note: Attatch to the entity:
    context.MyTableEntity.Attach(EntityToRemove);

    context.MyTableEntity.Remove(EntityToRemove);
    var nrOfObjectsChanged = context.SaveChanges();
}

Forse questo sembra ovvio, ma inizialmente non mi era chiaro che fosse necessario specificare l' entità a cui attaccarsi, e non solo il contesto .

Giusto per correggere la spiegazione di Kjartans:

Avevo:

public Project DeleteProject(int id)
    {
        using (var context = new Context())
        {
            var p = GetProject(id);
            context.Projects.Remove(p);
            context.SaveChanges();
            return p;
        }
    }

Il problema è che ho usato il mio metodo (GetProject ()) per ottenere l'entità (quindi utilizzando un altro contesto per caricare l'entità):

public Project GetProject(int id)
    {
        using (var context = new Context())
        {
            var project = context.Projects
                .Include(p => p.Reports.Select(q => q.Issues.Select(r => r.Profession)))
                .Include(p => p.Reports.Select(q => q.Issues.Select(r => r.Room)))
                .SingleOrDefault(x => x.Id == id);
            return project;      
        }
    }

Una soluzione potrebbe essere quella di collegare l'entità caricata come afferma Kjartan, un'altra potrebbe essere la mia soluzione, per caricare l'entità nello stesso contesto:

public Project DeleteProject(int id)
    {
        using (var context = new Context())
        {
            var p = context.Projects.SingleOrDefault(x => x.Id == id);
            if (p == null)
                return p;

            context.Projects.Remove(p);
            context.SaveChanges();
            return p;
        }
    }

So che questa domanda è piuttosto vecchia ma nessuna delle precedenti ha funzionato per me poiché stavo cancellando i registri da più di una classe / servizio e ognuno di essi creava un'istanza del proprio contesto di connessione al database.

Quello che ho fatto per risolverlo è stato inviare il primo contesto creato al resto delle classi / servizi che dovevano accedere al database.

Ad esempio, il mio serviceAstava per eliminare alcuni dei suoi registri e chiamare serviceBe serviceCfare lo stesso con i loro registri.

Vorrei quindi eliminare i miei registri su serviceAe passare come parametro il contesto creato sul serviceAper serviceBe serviceC.

Puoi scrivere questo codice:

var x=yourquery.FirstOrDefault(); 

sqlEntities.DeleteObject(x);
sqlEntities.SaveChanges();

Nel caso in cui nessuna delle soluzioni precedenti abbia funzionato, puoi provare questa soluzione:

context.Entry(yourObject).State = System.Data.Entity.EntityState.Deleted; context.SaveChanges();

Dovresti essere sicuro che il tuo oggetto sia presente nell'elenco da cui stai tentando di rimuovere, dovresti mettere la seguente condizione

if (context.entity.contains (il tuo oggetto))

rimuoverla.

se hai una condizione complicata per l'uguaglianza dovresti sovrascrivere il metodo equal nella classe entità per mettere la tua condizione per l'uguaglianza, per ottenere il modo giusto per un metodo di estensione "entity.contains"

Assicurati che il modello che passa a Remove (Entity) sia esattamente lo stesso del record del database.

A volte è possibile passare il modello senza alcuni campi come Id o Data. tienili in @ html.Hiddenfor se pubblichi come modulo.

Il modo migliore è passare l'ID e ottenere l'entità utilizzando il metodo Find (Id) e passarlo a Remove (Entity)

Spero che questo aiuti qualcuno.

Ho questo problema e lo risolvo. Basta copiare il codice sottostante:

sqlEntities.Attach(entity);
sqlEntities.Remove(entity);
sqlEntities.SaveChanges();

Nel mio caso c'era un contesto, ma ho ottenuto l'entità con l'opzione "AsNoTracking"