C# 是否从实体框架中删除单个记录？

我在实体框架中有一个名为

employ

的SQL Server表，其中一个键列名为

ID

---

如何使用实体框架从表中删除单个记录？

您可以使用

SingleOrDefault

获取与您的条件匹配的单个对象，然后将其传递给EF表的

Remove

方法

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

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

---

不必首先查询对象，您可以通过其id将其附加到上下文。 像这样：

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

或者，您可以将附加条目的状态设置为“已删除”：

var employer = new Employ { Id = 1 };
ctx.Entry(employer).State = EntityState.Deleted;
ctx.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);
}

public-virtual-void-Delete（int-id），其中T:BaseEntity，new（）
{
T instance=Activator.CreateInstance（）；
instance.Id=Id；
if（dbContext.Entry（entity.State==EntityState.Detached）
{
dbContext.Set（）.Attach（实体）；
}
dbContext.Set（）.Remove（实体）；
}

你觉得这个怎么样，简单还是不简单，你也可以试试这个：

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

---

对于通用DAO，这是有效的：

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

可以选择使用：

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");
        }
    }

模型

您将从中调用它的视图

 <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>

名字
姓氏
城市
@foreach（模型中的var项目）
{
@item.FirstName
@item.LastName
@项目.城市
|
|
}

---

我希望这将便于您理解

使用实体框架6，您可以使用

删除

。 另外，使用

和
来确保连接已关闭也是一种很好的策略

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

使用（var context=new EmployDbContext（））
{
emp=context.Employ.Where（x=>x.Id==Id.Single（）；
上下文。使用。删除（emp）；
SaveChanges（）；
}
您可以在网格的click或celldoubleclick事件中执行类似操作（如果您使用了一个）

然后在删除按钮中执行类似操作：

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
}

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

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

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

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

或者，您可以使用LINQ查询而不是使用LINQ到实体查询：

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
}

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

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

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

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

employ.Id用作已从DataGridView的CellDoubleClick事件传递的筛选参数。
以下是一种安全的方法：

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和Commit之前执行一系列删除操作，因此只有当它们全部成功时，才会应用它们。
只想贡献我反复使用的三种方法

方法1:

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
}

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

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

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

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

方法2:

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
}

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

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

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

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

我喜欢使用方法2的原因之一是，如果将EF或EFCore设置为
QueryTrackingBehavior.NoTracking
，这样做更安全

还有方法3：

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
}

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

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

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

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;

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

您也只需将列
DeletedOn
设置为已修改：

entry.State = EntityState.Modified;

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

最好的方法是检查然后删除

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

或者，
ctx.Entry（employer.State=EntityState.Deleted
仅当关系定义为delete cascade时，此操作才有效。否则，上述代码将在FK异常时失败。@mt_serg，我将向前看3步。您最后一次从数据库中删除如此简单的记录是什么时候？通常，您处理的是包含FK关系的更复杂的记录。因此我的评论。@IanWarburton第2行和第3行（附加和删除）@PaulZahra：有时候你有一个来自其他查询或源的ID列表，你需要删除一个。这样，您就可以按ID删除对象，而不是加载对象来删除它们。您知道，SQL中的delete语句通常就是这样工作的。这不是一个好方法，因为您正在从数据库中选择所有字段！我就是这样做的。@Ali，Jack-但我认为这更可取，因为它首先检查您试图删除的数据是否确实存在，这样可以避免任何麻烦。被接受的答案本身没有检查。这是更好的方法。想想看。如果John Smith试图删除Susie Smith 30秒前删除但John不知道的id为1的项目，该怎么办？在这种情况下，你需要访问数据库。@Yusha为什么？在这两种情况下，结果都是记录消失了。我们真的在乎是现在还是30秒前发生的吗？有些竞赛条件并不是很有趣，不需要跟踪。如果没有Id为1的对象，这是否可以保护它？它不会抛出异常吗？@JackFairfield我想你应该检查null对象。然后根据它执行删除。
首先
是危险的。或者您知道只有一个（所以使用
Single
），或者有多个，并且应该在循环中完成。db.employ.Remove（db.employ.Find（ID1））@CarterMedlin-这将起作用，但有两个数据库点击：一个选择，一个删除。大多数人认为这是非常浪费的，特别是因为select可能比delete花费更多的时间。由于性能问题，我不建议使用entity framework Remove或RemoveAnge。我宁愿只使用以下超级简单的东西：var sql=“从您的_表中删除，其中您的_字段=@YOUR_参数”；这个.your_context.Database.ExecuteSqlCommand（sql，新的SqlParameter（“@your_parameter”，y