Question

HI,
Wit linq i populate a generic list in DAL. then in UI layer the user removes and updates items from the list. Is it possible for LINQ to keep track of the changes without having to write code to check which items have been removed and deleting them/adding new items and updating others etc. it seems that this is not possible when using datacontext which popluates the list and seperate datacontext which is responsible fo SubmitChanges. Any help appreciated.

thanks
Niall

Answer 1

If you are using Linq.DataContext then it does indeed keep track of changes for you.

The function to reference is System.Data.Linq.DataContext.GetChangeSet. Although GetChangeSet can be called at any time it would be good to reference the Remarks section in the MSDN documentation.

You can check / take action on submit…

Here is a quick example of how you can override SubmitChanges on a DataContext and take actions at that point.

The example shows that you can modify the data before final submit, you can also keep track and take special action when specific members are updated:

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

    }
}