Modo corretto per eliminare record in LINQ alle entità

Question

Ho solo una situazione molto semplice in cui tutto ciò di cui ho bisogno è cancellare il record usando Linq2Entities. Ho provato a fare qualche ricerca e ancora non riesco a capire il modo giusto per farlo.

Ecco il mio codice semplice:

[DataObjectMethod(DataObjectMethodType.Delete)] 
public void DeleteEmployee(Employee z) 
{ 
    using (var ctx = new MyEntity()) 
    { 
     var x = (from y in ctx.Employees 
       where y.EmployeeId == z.EmployeeId 
       select y).FirstOrDefault(); 
     ctx.DeleteObject(x); 
     ctx.SaveChanges(); 
    } 
} 

[DataObjectMethod(DataObjectMethodType.Select)] 
public List<Employee> GetAllEmployee() 
{ 
    using (var ctx = new MyEntity()) 
    { 
     var x = from y in ctx.Employees 
       select y; 
     return x.ToList(); 
    } 
} 

posso eliminare un record particolare se per esempio assegno y.EmployeeName == "Harold Javier" al metodo Delete sopra, ma quando assegno y .EmployeeId == z.EmployeeId al codice precedente, l'eliminazione non funziona. (Nota: EmployeeId è la chiave primaria della tabella Employee)

Answer 1

Ho deciso di rispondere alla mia domanda.

La mia funzione di cancellazione ha funzionato quando ho fatto la seguente:

using (var ctx = new MyEntity()) 
    { 
     var x = (from y in ctx.Employees 
      orderby y.EmployeeId descending 
      select y).FirstOrDefault(); 
     ctx.Employees.DeleteObject(x); 
     ctx.SaveChanges(); 
    } 

so che ci potrebbe essere un approccio migliore di questo, ma funziona per me per il tempo medio.

Answer 2

prima è necessario verificare che se esiste un record prima di eliminarlo effettivamente;

[DataObjectMethod(DataObjectMethodType.Delete)] 

    public void DeleteEmployee(Employee z) 
    { 
     using (var ctx = new MyEntity()) 
     { 
      var x = (from y in ctx.Employees 
        where y.EmployeeId == z.EmployeeId 
        select y).FirstOrDefault(); 
      if(x!=null) 
      { 
      ctx.Employees.DeleteObject(x); 
      ctx.SaveChanges(); 
      } 
     } 
    } 

Controllare sempre i valori null, prima di eliminare qualcosa. Perché un utente può cambiare l'Id (a querystring) e provare diverse combinazioni.

Answer 3

Questo probabilmente perché il contesto è diverso per ogni richiesta (var ctx = new MyEntity()). Provare a utilizzare questo

public static class ObjectContextPerHttpRequest 
{ 
    public static TestCasesModelContainer Context 
    { 
     get 
     { 
      string objectContextKey = HttpContext.Current.GetHashCode().ToString("ObjectContextPerHttpRequest"); 

      if (!HttpContext.Current.Items.Contains(objectContextKey)) 
      { 
       HttpContext.Current.Items.Add(objectContextKey, new TestCasesModelContainer()); 
      } 

      return HttpContext.Current.Items[objectContextKey] as TestCasesModelContainer; 
     } 
    } 
} 

e cancellare è come

public static void Delete(Testcase tc) 
{ 
    var db = ObjectContextPerHttpRequest.Context; 

    db.DeleteObject((from p in db.TestcaseSet 
        where p.Id == tc.Id 
        select p).Single()); 
    db.SaveChanges(); 
} 

Answer 4

Penso che questa sia una migliore possibilità di cancellazione

using (var ctx = new MyEntity()) 
    { 
     var x = (from y in ctx.Employees 
      orderby y.EmployeeId descending 
      select y).FirstOrDefault(); 
     ctx.Employees.Remove(x); 
     ctx.SaveChanges(); 
    } 

al mio fianco DeleteObject non funziona così io uso Remove

Answer 5

La risposta di cui sopra potrebbe essere superata ... Il metodo DeleteObject non sembra ex ist nella versione attuale di ENtity Framework. Ho dovuto usare il metodo Remove.

var delobj = db.mytable.Where(p => p.ServiceLocation == serviceLocationID).SingleOrDefault(); 
db.myTable.Remove(delobj); 

Answer 6

@Harold, so che questo post è piuttosto vecchio, ma io sento che è importante per rispondere alla sua domanda originale e risposta. La tua soluzione potrebbe aver funzionato nella tua situazione, ma ci sono un paio di problemi.

Innanzitutto, il codice originale stava selezionando il record da eliminare in base a un parametro passato. La tua soluzione sta eliminando il record con il più grande EmployeeId. Potrebbe essere ciò che desideri, ma non è probabile. Il secondo problema è che per l'eliminazione sono necessari due accessi al database. Il primo è ottenere l'entità per eliminare il secondo per eseguire effettivamente l'eliminazione.

Il seguente frammento di codice eliminerà la necessità di leggere ed eliminerà il dipendente "z". Questo dovrebbe dare il risultato desiderato ed eseguire molto meglio.

public void DeleteEmployeeId(Employee z) 
{ 
    using (var ctx = new MyEntityContext()) 
    { 
     var x = new Employee{ EmployeeId = z.EmployeeId }; 
     ctx.Entry(x).State = EntityState.Deleted; 
     ctx.SaveChanges(); 
    } 
}