C# LINQ跟踪更改

嗨， Wit linq i在DAL中填充一个通用列表。然后在UI层中，用户从列表中删除和更新项目。LINQ是否可以跟踪更改，而不必编写代码来检查哪些项目已被删除和删除/添加新项目和更新其他项目等。在使用datacontext时，这似乎是不可能的，datacontext会弹出列表并分离datacontext，datacontext负责提交更改。谢谢你的帮助

谢谢

---

Niall

不清楚您使用的是什么编辑机制，但如果涉及多个DataContext，则是：您必须告诉提交数据上下文有关删除的信息。当然，它需要知道每一次更改-否则它将不知道如何更改数据库。

不清楚您使用的编辑机制，但如果涉及多个DataContext，则是：您必须通过以下方式告诉提交数据上下文有关删除。当然，它需要知道每一次更改—否则它将不知道更改数据库。

如果您有一个N层应用程序，这将是不可能的，因为您将以断开连接的方式进行更新、删除和插入

---

换句话说，一个数据上下文将用于创建列表，实体将通过WCF或其他机制传递给客户端，然后发送回DAL，另一个数据上下文将用于执行更新。

如果您有一个N层应用程序，这将不可能，因为您将执行更新，以断开连接的方式删除和插入

换句话说，一个数据上下文将用于创建列表，实体将通过WCF或其他机制传递给客户端，然后发送回DAL，另一个数据上下文将用于进行更新。

如果您使用的是Linq.DataContext，那么它确实会为您跟踪更改

要引用的函数是。尽管可以在任何时候调用GetChangeSet，但最好参考MSDN文档中的部分

您可以在提交时检查/采取操作

下面是一个快速示例，说明如何覆盖DataContext上的SubmitChanges，并在此时采取操作

该示例显示，您可以在最终提交之前修改数据，也可以在更新特定成员时跟踪并采取特殊操作：

namespace ExampleProject1.Models
{
    public partial class ExampleProject1DataContext
    {
        public override void SubmitChanges(ConflictMode failureMode)
        {
            ManangeAndProcessChangeSet(base.GetChangeSet());
            base.SubmitChanges(failureMode);
        }

        private void ManangeAndProcessChangeSet(ChangeSet changeSet)
        {
            DateTime now = DateTime.UtcNow;

            if (changeSet.Inserts.Count > 0)
            {
                ProcessInserts(changeSet.Inserts, now);
            }

            if (changeSet.Updates.Count > 0)
            {
                ProcessUpdates(changeSet.Updates, now);
            }

            if (changeSet.Deletes.Count > 0)
            {
                ProcessDeletes(changeSet.Deletes, now);
            }
        }

        private void ProcessInserts(IList<object> list, DateTime now)
        {
            IEnumerable<Cake> cakes = list.OfType<Cake>();
            IEnumerable<Topping> toppings = list.OfType<Topping>();

            // Update the created and modified times.
            foreach (Cake cake in cakes)
            {
                cake.Guid = Guid.NewGuid();
                cake.CreatedDateTime = now;
                cake.ModifiedDateTime = now;
            }
            foreach (Topping topping in toppings)
            {
                topping.Guid = Guid.NewGuid();
                topping.CreatedDateTime = now;
                topping.ModifiedDateTime = now;
            }
        }

        private void ProcessUpdates(IList<object> list, DateTime now)
        {
            IEnumerable<Cake> cakes = list.OfType<Cake>();
            IEnumerable<Topping> toppings = list.OfType<Topping>();

            // Update the created and modified times.
            foreach (Cake cake in cakes)
            {
                ProcessUpdates(cake, now);
            }
            foreach (Topping topping in toppings)
            {
                topping.ModifiedDateTime = now;
            }
        }

        private void ProcessDeletes(IList<object> list, DateTime now)
        {
            IEnumerable<Cake> cakes = list.OfType<Cake>();
            IEnumerable<Topping> toppings = list.OfType<Topping>();

            // Could create tasks here to delete associated stored files for cakes and toppings.
        }

        private bool ProcessUpdates(Cake cake, DateTime now)
        {
            bool modified = false;

            ModifiedMemberInfo[] mmi = context.Cakes.GetModifiedMembers(cake);
            foreach (ModifiedMemberInfo mi in mmi)
            {
                switch (mi.Member.Name)
                {
                    case "CountOfItemsSold":
                        // Exclude from updating the modified date.
                        break;

                    case "IsExpired":
                        if ((bool)mi.CurrentValue)
                        {
                            cake.ExpiredDateTime = now;
                        }
                        else
                        {
                            cake.ExpiredDateTime = null;
                        }
                        modified = true;
                        break;

                    default:
                        modified = true;
                        break;
                }
            }

            if (modified)
            {
                cake.ModifiedDateTime = now;
            }

            return modified;
        }

    }
}

如果您使用的是Linq.DataContext，那么它确实会为您跟踪更改

要引用的函数是。尽管可以在任何时候调用GetChangeSet，但最好参考MSDN文档中的部分

您可以在提交时检查/采取操作

下面是一个快速示例，说明如何覆盖DataContext上的SubmitChanges，并在此时采取操作

该示例显示，您可以在最终提交之前修改数据，也可以在更新特定成员时跟踪并采取特殊操作：

namespace ExampleProject1.Models
{
    public partial class ExampleProject1DataContext
    {
        public override void SubmitChanges(ConflictMode failureMode)
        {
            ManangeAndProcessChangeSet(base.GetChangeSet());
            base.SubmitChanges(failureMode);
        }

        private void ManangeAndProcessChangeSet(ChangeSet changeSet)
        {
            DateTime now = DateTime.UtcNow;

            if (changeSet.Inserts.Count > 0)
            {
                ProcessInserts(changeSet.Inserts, now);
            }

            if (changeSet.Updates.Count > 0)
            {
                ProcessUpdates(changeSet.Updates, now);
            }

            if (changeSet.Deletes.Count > 0)
            {
                ProcessDeletes(changeSet.Deletes, now);
            }
        }

        private void ProcessInserts(IList<object> list, DateTime now)
        {
            IEnumerable<Cake> cakes = list.OfType<Cake>();
            IEnumerable<Topping> toppings = list.OfType<Topping>();

            // Update the created and modified times.
            foreach (Cake cake in cakes)
            {
                cake.Guid = Guid.NewGuid();
                cake.CreatedDateTime = now;
                cake.ModifiedDateTime = now;
            }
            foreach (Topping topping in toppings)
            {
                topping.Guid = Guid.NewGuid();
                topping.CreatedDateTime = now;
                topping.ModifiedDateTime = now;
            }
        }

        private void ProcessUpdates(IList<object> list, DateTime now)
        {
            IEnumerable<Cake> cakes = list.OfType<Cake>();
            IEnumerable<Topping> toppings = list.OfType<Topping>();

            // Update the created and modified times.
            foreach (Cake cake in cakes)
            {
                ProcessUpdates(cake, now);
            }
            foreach (Topping topping in toppings)
            {
                topping.ModifiedDateTime = now;
            }
        }

        private void ProcessDeletes(IList<object> list, DateTime now)
        {
            IEnumerable<Cake> cakes = list.OfType<Cake>();
            IEnumerable<Topping> toppings = list.OfType<Topping>();

            // Could create tasks here to delete associated stored files for cakes and toppings.
        }

        private bool ProcessUpdates(Cake cake, DateTime now)
        {
            bool modified = false;

            ModifiedMemberInfo[] mmi = context.Cakes.GetModifiedMembers(cake);
            foreach (ModifiedMemberInfo mi in mmi)
            {
                switch (mi.Member.Name)
                {
                    case "CountOfItemsSold":
                        // Exclude from updating the modified date.
                        break;

                    case "IsExpired":
                        if ((bool)mi.CurrentValue)
                        {
                            cake.ExpiredDateTime = now;
                        }
                        else
                        {
                            cake.ExpiredDateTime = null;
                        }
                        modified = true;
                        break;

                    default:
                        modified = true;
                        break;
                }
            }

            if (modified)
            {
                cake.ModifiedDateTime = now;
            }

            return modified;
        }

    }
}

---

我正在使用多个datacontext，所以我需要告诉那个些datacontext的变化是不理想的。我希望LINQ能帮我处理好这件事，但不幸的是，它确实如此。谢谢你们的帮助，我正在使用多个datacontext，所以我需要告诉你们datacontext的变化并不理想。我希望LINQ能帮我照看一下，但不幸的是，它确实如此。谢谢你的帮助为什么要蛋糕和配料？那么，为什么不呢-为什么要吃蛋糕和浇头？那么，为什么不呢-