C# ChangeSet.GetAssociatedChanges方法代码示例

        public void Changeset_GetAssociatedChanges_ParamValidation()
        {
            DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(CompositionScenarios_Explicit));

            // test where entity passed in does not exist in the changeset
            ChangeSet cs = new ChangeSet(new ChangeSetEntry[] { new ChangeSetEntry(1, new Parent { Children = new List<Child> { new Child() } }, null, DomainOperation.Insert) });
            Parent parent = cs.ChangeSetEntries.Select(p => p.Entity).Cast<Parent>().First();
            ExceptionHelper.ExpectArgumentException(delegate
            {
                cs.GetAssociatedChanges(new Parent(), p => p.Children);
            }, Resource.ChangeSet_ChangeSetEntryNotFound, "entity");

            // test where the changeset is empty
            cs = new ChangeSet(new ChangeSetEntry[0]);
            ExceptionHelper.ExpectArgumentException(delegate
            {
                cs.GetAssociatedChanges(new Parent(), p => p.Children);
            }, Resource.ChangeSet_ChangeSetEntryNotFound, "entity");

            ExceptionHelper.ExpectArgumentNullException(delegate
            {
                cs.GetAssociatedChanges(null, (Parent p) => p.Children);
            }, "entity");

            ExceptionHelper.ExpectArgumentNullException(delegate
            {
                cs.GetAssociatedChanges(parent, (Expression<Func<Parent, Child>>)null);
            }, "expression");

            // try to pass in a non compositional member
            cs = new ChangeSet(new ChangeSetEntry[] { new ChangeSetEntry(1, new Parent { Children = new List<Child> { new Child() } }, null, DomainOperation.Insert) });
            parent = cs.ChangeSetEntries.Select(p => p.Entity).Cast<Parent>().First();
            ExceptionHelper.ExpectArgumentException(delegate
            {
                cs.GetAssociatedChanges(parent, p => p.OperationResult);
            }, string.Format(Resource.MemberNotAnAssociation, typeof(CompositionEntityBase), "OperationResult"), "expression");
        }

        public void Changeset_GetAssociatedChanges_Enumerable()
        {
            DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(CompositionScenarios_Explicit));

            #region build up a compositional hierarchy
            int id = 1;
            Parent currParent = new Parent();
            List<ChangeSetEntry> changeSetEntries = new List<ChangeSetEntry>();
            ChangeSetEntry parentUpdateOperation = new ChangeSetEntry(id++, currParent, null, DomainOperation.Update);
            List<int> currentAssociatedChildren = new List<int>();
            changeSetEntries.Add(parentUpdateOperation);

            // add 3 unmodified children
            List<Child> unmodifiedChildren = new List<Child>() { new Child(), new Child(), new Child() };
            foreach (Child c in unmodifiedChildren)
            {
                ChangeSetEntry operation = new ChangeSetEntry(id++, c, c, DomainOperation.None);
                changeSetEntries.Add(operation);
                currParent.Children.Add(c);
                currentAssociatedChildren.Add(operation.Id);
            }

            // add 2 child edits
            List<Child> originalEditedChildren = new List<Child> { new Child(), new Child() };
            List<Child> currentEditedChildren = new List<Child> { new Child(), new Child() };
            for (int i = 0; i < originalEditedChildren.Count; i++)
            {
                Child currChild = currentEditedChildren[i];
                Child origChild = originalEditedChildren[i];
                ChangeSetEntry operation = new ChangeSetEntry(id++, currChild, origChild, DomainOperation.Update);
                changeSetEntries.Add(operation);
                currParent.Children.Add(currChild);
                currentAssociatedChildren.Add(operation.Id);
            }

            // add a 2 new children children
            List<Child> newChildren = new List<Child> { new Child(), new Child() };
            foreach (Child c in newChildren)
            {
                ChangeSetEntry operation = new ChangeSetEntry(id++, c, null, DomainOperation.Insert);
                changeSetEntries.Add(operation);
                currParent.Children.Add(c);
                currentAssociatedChildren.Add(operation.Id);
            }

            // add 2 removes by adding operations for the deleted children
            // and setting up the original association
            List<Child> removedChildren = new List<Child> { new Child(), new Child() };
            List<int> deletedChildren = new List<int>();
            foreach (Child c in removedChildren)
            {
                int deletedId = id++;
                changeSetEntries.Add(new ChangeSetEntry(deletedId, c, c, DomainOperation.Delete));
                deletedChildren.Add(deletedId);
            }
            parentUpdateOperation.OriginalAssociations = new Dictionary<string, int[]>() { { "Children", deletedChildren.ToArray() } };
            parentUpdateOperation.Associations = new Dictionary<string, int[]>() { { "Children", currentAssociatedChildren.ToArray() } };
            #endregion

            // verify unmodified children
            ChangeSet cs = new ChangeSet(changeSetEntries);
            IEnumerable<Child> childChanges = cs.GetAssociatedChanges(currParent, p => p.Children, ChangeOperation.None).Cast<Child>();
            Assert.AreEqual(3, childChanges.Count());
            foreach (Child c in childChanges)
            {
                Assert.IsTrue(unmodifiedChildren.Contains(c));
            }

            // verify inserted children
            childChanges = cs.GetAssociatedChanges(currParent, p => p.Children, ChangeOperation.Insert).Cast<Child>();
            Assert.AreEqual(2, childChanges.Count());
            foreach (Child c in childChanges)
            {
                Assert.IsTrue(newChildren.Contains(c));
            }

            // verify deleted children
            childChanges = cs.GetAssociatedChanges(currParent, p => p.Children, ChangeOperation.Delete).Cast<Child>();
            Assert.AreEqual(2, childChanges.Count());
            foreach (Child c in childChanges)
            {
                Assert.IsTrue(removedChildren.Contains(c));
            }

            // verify modified children
            childChanges = cs.GetAssociatedChanges(currParent, p => p.Children, ChangeOperation.Update).Cast<Child>();
            Assert.AreEqual(2, childChanges.Count());
            foreach (Child c in childChanges)
            {
                Assert.IsTrue(currentEditedChildren.Contains(c));
            }

            // verify overload that returns all - should return all unmodified
            // in addition to all changed
            IEnumerable<Child> allChildren = cs.GetAssociatedChanges(currParent, p => p.Children).Cast<Child>();
            Assert.AreEqual(9, allChildren.Count());
            foreach (Child c in allChildren)
            {
                ChangeOperation operationType = cs.GetChangeOperation(c);
                switch (operationType)
//.........这里部分代码省略.........

        public void Changeset_GetAssociatedChanges_Singleton()
        {
            DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(CompositionScenarios_Explicit));

            // verify singleton change of None
            GreatGrandChild unmodifiedGgc = new GreatGrandChild();
            GrandChild currGrandChild = new GrandChild
            {
                Child = unmodifiedGgc
            };
            GrandChild origGrandChild = new GrandChild
            {
                Child = unmodifiedGgc
            };
            ChangeSetEntry gcOperation = new ChangeSetEntry(1, currGrandChild, origGrandChild, DomainOperation.Update);
            gcOperation.Associations = new Dictionary<string, int[]> { { "Child", new int[] { 2 } } };
            ChangeSetEntry ggcOperation = new ChangeSetEntry(2, unmodifiedGgc, null, DomainOperation.None);
            ChangeSet cs = new ChangeSet(new ChangeSetEntry[] { gcOperation, ggcOperation });
            GreatGrandChild ggcChange = cs.GetAssociatedChanges(currGrandChild, p => p.Child, ChangeOperation.None).Cast<GreatGrandChild>().SingleOrDefault();
            Assert.AreSame(unmodifiedGgc, ggcChange);

            // verify singleton insert
            GreatGrandChild newGgc = new GreatGrandChild();
            currGrandChild = new GrandChild
            {
                Child = newGgc
            };
            origGrandChild = new GrandChild
            {
                Child = null
            };
            gcOperation = new ChangeSetEntry(1, currGrandChild, origGrandChild, DomainOperation.Update);
            gcOperation.Associations = new Dictionary<string, int[]> { { "Child", new int[] { 2 } } };
            ggcOperation = new ChangeSetEntry(2, newGgc, null, DomainOperation.Insert);
            cs = new ChangeSet(new ChangeSetEntry[] { gcOperation, ggcOperation });
            ggcChange = cs.GetAssociatedChanges(currGrandChild, p => p.Child, ChangeOperation.Insert).Cast<GreatGrandChild>().SingleOrDefault();
            Assert.AreSame(newGgc, ggcChange);
            Assert.AreEqual(ChangeOperation.Insert, cs.GetChangeOperation(newGgc));

            // verify singleton update
            GreatGrandChild modifiedGgc = new GreatGrandChild();
            currGrandChild = new GrandChild
            {
                Child = modifiedGgc
            };
            origGrandChild = new GrandChild
            {
                Child = modifiedGgc
            };
            gcOperation = new ChangeSetEntry(1, currGrandChild, origGrandChild, DomainOperation.Update);
            gcOperation.Associations = new Dictionary<string, int[]> { { "Child", new int[] { 2 } } };
            ggcOperation = new ChangeSetEntry(2, modifiedGgc, unmodifiedGgc, DomainOperation.Update);
            cs = new ChangeSet(new ChangeSetEntry[] { gcOperation, ggcOperation });
            ggcChange = cs.GetAssociatedChanges(currGrandChild, p => p.Child, ChangeOperation.Update).Cast<GreatGrandChild>().SingleOrDefault();
            Assert.AreSame(modifiedGgc, ggcChange);
            Assert.AreSame(unmodifiedGgc, cs.GetOriginal(modifiedGgc));
            Assert.AreEqual(ChangeOperation.Update, cs.GetChangeOperation(modifiedGgc));

            // verify singleton delete
            GreatGrandChild deletedGgc = new GreatGrandChild();
            currGrandChild = new GrandChild
            {
                Child = null
            };
            origGrandChild = new GrandChild
            {
                Child = deletedGgc
            };
            gcOperation = new ChangeSetEntry(1, currGrandChild, null, DomainOperation.Update);
            gcOperation.OriginalAssociations = new Dictionary<string, int[]>() { { "Child", new int[] { 2 } } };
            ggcOperation = new ChangeSetEntry(2, deletedGgc, null, DomainOperation.Delete);
            gcOperation.OriginalAssociations = new Dictionary<string, int[]>() { { "Child", new int[] { 2 } } };
            cs = new ChangeSet(new ChangeSetEntry[] { gcOperation, ggcOperation });
            ggcChange = cs.GetAssociatedChanges(currGrandChild, p => p.Child, ChangeOperation.Delete).Cast<GreatGrandChild>().SingleOrDefault();
            Assert.AreSame(deletedGgc, ggcChange);
            Assert.AreSame(null, cs.GetOriginal(deletedGgc));
            Assert.AreEqual(ChangeOperation.Delete, cs.GetChangeOperation(deletedGgc));
        }