엔티티 프레임워크에서 단일 레코드를 삭제하시겠습니까?

엔티티 프레임워크에서 단일 레코드를 삭제하시겠습니까?

엔티티 프레임워크에 SQL Server 테이블이 있습니다.employ단일 키 컬럼을 사용하여ID.

엔티티 프레임워크를 사용하여 테이블에서 단일 레코드를 삭제하려면 어떻게 해야 합니까?

개체를 먼저 쿼리할 필요는 없습니다. ID로 컨텍스트에 연결할 수 있습니다.다음과 같이 합니다.

var employer = new Employ { Id = 1 };
ctx.Employ.Attach(employer);
ctx.Employ.Remove(employer);
ctx.SaveChanges();

또는 연결된 엔트리의 상태를 deleted로 설정할 수 있습니다.

var employer = new Employ { Id = 1 };
ctx.Entry(employer).State = EntityState.Deleted;
ctx.SaveChanges();

사용할 수 있습니다.SingleOrDefault기준과 일치하는 단일 개체를 가져와서RemoveEF 테이블의 메서드.

var itemToRemove = Context.Employ.SingleOrDefault(x => x.id == 1); //returns a single item.

if (itemToRemove != null) {
    Context.Employ.Remove(itemToRemove);
    Context.SaveChanges();
}

  var stud = (from s1 in entities.Students
            where s1.ID== student.ID
            select s1).SingleOrDefault();

  //Delete it from memory
  entities.DeleteObject(stud);
  //Save to database
  entities.SaveChanges();

Employer employer = context.Employers.First(x => x.EmployerId == 1);

context.Customers.DeleteObject(employer);
context.SaveChanges();

LINQ에서 엔티티 프레임워크를 사용하고 있습니다.다음 코드가 도움이 되었습니다.

1- 여러 레코드의 경우

 using (var dbContext = new Chat_ServerEntities())
 {
     var allRec= dbContext.myEntities;
     dbContext.myEntities.RemoveRange(allRec);
     dbContext.SaveChanges();
 }

2- 싱글 레코드용

 using (var dbContext = new Chat_ServerEntities())
 {
     var singleRec = dbContext.ChatUserConnections.FirstOrDefault( x => x.ID ==1);// object your want to delete
     dbContext.ChatUserConnections.Remove(singleRec);
     dbContext.SaveChanges();
 }

보다 범용적인 어프로치

public virtual void Delete<T>(int id) where T : BaseEntity, new()
{
    T instance = Activator.CreateInstance<T>();
    instance.Id = id;
    if (dbContext.Entry<T>(entity).State == EntityState.Detached)
    {
        dbContext.Set<T>().Attach(entity);
    }

    dbContext.Set<T>().Remove(entity);
}

그냥 내가 왔다 갔다 했던 세 가지 방법에 기여하고 싶었어.

방법 1:

var record = ctx.Records.FirstOrDefault();
ctx.Records.Remove(record);
ctx.SaveChanges();

방법 2:.

var record = ctx.Records.FirstOfDefault();
ctx.Entry(record).State = EntityState.Deleted;
ctx.SaveChanges();
ctx.Entry(record).State = EntityState.Detached;

방법 2를 선호하는 이유 중 하나는 EF 또는 EFCore를 다음과 같이 설정하는 경우입니다.QueryTrackingBehavior.NoTracking하는 게 더 안전해

다음으로 방법 3이 있습니다.

var record = ctx.Records.FirstOrDefault();
var entry = ctx.Entry(record);
record.DeletedOn = DateTimeOffset.Now;
entry.State = EntityState.Modified;
ctx.SaveChanges();
entry.State = EntityState.Detached;

이 방법에서는 레코드를 설정하여 소프트 삭제 접근 방식을 사용합니다.DeletedOn나중에 사용할 수 있도록 기록을 보관할 수 있습니다.기본적으로 휴지통에 넣는 거죠.

---

또한 방법 3에 대해서는 전체 레코드를 수정하도록 설정하는 대신 다음을 수행합니다.

entry.State = EntityState.Modified;

또한 단순히 열만 설정할 수 있습니다.DeletedOn변경 시:

entry.Property(x => x.DeletedOn).IsModified = true;

Entity Framework 6에서는Remove또, 접속이 닫혀 있는 것을 확인하기 위해서 사용하는 것도 좋은 방법입니다.

using (var context = new EmployDbContext())
{
    Employ emp = context.Employ.Where(x => x.Id == id).Single<Employ>();
    context.Employ.Remove(emp);
    context.SaveChanges();
}

    [HttpPost]
    public JsonResult DeleteCotnact(int id)
    {
        using (MycasedbEntities dbde = new MycasedbEntities())
        {
            Contact rowcontact = (from c in dbde.Contact
                                     where c.Id == id
                                     select c).FirstOrDefault();

            dbde.Contact.Remove(rowcontact);
            dbde.SaveChanges();

            return Json(id);
        }
    }

단순하든 그렇지 않든, 다음과 같이 시도해 볼 수 있습니다.

        var productrow = cnn.Product.Find(id);
        cnn.Product.Remove(productrow);
        cnn.SaveChanges();

Entity Framework 사용.옵션으로는 다음과 같은 것이 있습니다.

dbContext.Employ.Where(e => e.Id == 1).Delete();

자세한 예는 이쪽에서 보실 수 있습니다.

너는 이렇게 간단하게 할 수 있다.

   public ActionResult Delete(int? id)
    {
        using (var db = new RegistrationEntities())
        {
            Models.RegisterTable Obj = new Models.RegisterTable();
            Registration.DAL.RegisterDbTable personalDetail = db.RegisterDbTable.Find(id);
            if (personalDetail == null)
            {
                return HttpNotFound();
            }
            else
            {
                Obj.UserID = personalDetail.UserID;
                Obj.FirstName = personalDetail.FName;
                Obj.LastName = personalDetail.LName;
                Obj.City = personalDetail.City;

            }
            return View(Obj);
        }
    }


    [HttpPost, ActionName("Delete")]

    public ActionResult DeleteConfirmed(int? id)
    {
        using (var db = new RegistrationEntities())
        {
            Registration.DAL.RegisterDbTable personalDetail = db.RegisterDbTable.Find(id);
            db.RegisterDbTable.Remove(personalDetail);
            db.SaveChanges();
            return RedirectToAction("where u want it to redirect");
        }
    }

모델

 public class RegisterTable
{

    public int UserID
    { get; set; }


    public string FirstName
    { get; set; }


    public string LastName
    { get; set; }


    public string Password
    { get; set; }


    public string City
    { get; set; }

} 

당신이 그것을 부를 수 있는 곳

 <table class="table">
    <tr>
        <th>
            FirstName
        </th>
        <th>
            LastName
        </th>

        <th>
            City
        </th>
        <th></th>
    </tr>

    @foreach (var item in Model)
    {
        <tr>
            <td> @item.FirstName </td>
            <td> @item.LastName </td>
            <td> @item.City</td>
            <td>
                <a href="@Url.Action("Edit", "Registeration", new { id = item.UserID })">Edit</a> |
                <a href="@Url.Action("Details", "Registeration", new { id = item.UserID })">Details</a> |
                <a href="@Url.Action("Delete", "Registeration", new { id = item.UserID })">Delete</a>

            </td>
        </tr>

    }

</table>

나는 이것이 네가 이해하기 쉽기를 바란다.

그리드의 클릭 또는 셀 더블 클릭 이벤트에서 이와 같은 작업을 수행할 수 있습니다(사용한 경우).

if(dgEmp.CurrentRow.Index != -1)
 {
    employ.Id = (Int32)dgEmp.CurrentRow.Cells["Id"].Value;
    //Some other stuff here
 }

그런 다음 삭제 버튼으로 다음과 같은 작업을 수행합니다.

using(Context context = new Context())
{
     var entry = context.Entry(employ);
     if(entry.State == EntityState.Detached)
     {
        //Attached it since the record is already being tracked
        context.Employee.Attach(employ);
     }                             
     //Use Remove method to remove it virtually from the memory               
     context.Employee.Remove(employ);
     //Finally, execute SaveChanges method to finalized the delete command 
     //to the actual table
     context.SaveChanges();

     //Some stuff here
}

또는 LINQ To Entities 쿼리를 사용하는 대신 LINQ 쿼리를 사용할 수 있습니다.

var query = (from emp in db.Employee
where emp.Id == employ.Id
select emp).Single();

employ.Id는 DataGridView의 CellDoubleClick Event에서 이미 전달된 필터링 파라미터로 사용됩니다.

안전한 방법은 다음과 같습니다.

using (var transitron = ctx.Database.BeginTransaction())
{
  try
  {
    var employer = new Employ { Id = 1 };
    ctx.Entry(employer).State = EntityState.Deleted;
    ctx.SaveChanges();
    transitron.Commit();
  }
  catch (Exception ex)
  {
    transitron.Rollback();
    //capture exception like: entity does not exist, Id property does not exist, etc...
  }
}

여기서 원하는 모든 변경 사항을 축적할 수 있으므로 SaveChanges and Commit 전에 일련의 삭제를 수행할 수 있습니다.이러한 변경 사항은 모두 성공한 경우에만 적용됩니다.

가장 좋은 방법은 확인 후 삭제하는 것입니다.

        if (ctx.Employ.Any(r=>r.Id == entity.Id))
        {
            Employ rec = new Employ() { Id = entity.Id };
            ctx.Entry(rec).State = EntityState.Deleted;
            ctx.SaveChanges();
        }

일반적인 DAO의 경우 다음과 같이 동작했습니다.

    public void Delete(T entity)
    {
        db.Entry(entity).State = EntityState.Deleted;
        db.SaveChanges();
    }

언급URL : https://stackoverflow.com/questions/17723276/delete-a-single-record-from-entity-framework