Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Activities/System/Activities/Statements/NoPersistScope.cs

@@ -0,0 +1,177 @@
+//------------------------------------------------------------------------------
+// <copyright file="NoPersistScope.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Activities.Statements
+{
+    using System;
+    using System.Activities;
+    using System.Activities.Expressions;
+    using System.Activities.Statements;
+    using System.Activities.Validation;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.ComponentModel;
+    using System.Linq;
+    using System.Runtime;
+    using System.Windows.Markup;
+
+    [ContentProperty("Body")]
+    public sealed class NoPersistScope : NativeActivity
+    {
+        static Constraint constraint;
+
+        Variable<NoPersistHandle> noPersistHandle;
+
+        public NoPersistScope()
+        {
+            this.noPersistHandle = new Variable<NoPersistHandle>();
+            this.Constraints.Add(NoPersistScope.Constraint);
+        }
+
+        [DefaultValue(null)]
+        public Activity Body
+        {
+            get;
+            set;
+        }
+
+        static Constraint Constraint
+        {
+            get
+            {
+                if (constraint == null)
+                {
+                    constraint = NoPersistScope.NoPersistInScope();
+                }
+
+                return constraint;
+            }
+        }
+
+        protected override void CacheMetadata(NativeActivityMetadata metadata)
+        {
+            metadata.AddChild(this.Body);
+            metadata.AddImplementationVariable(this.noPersistHandle);
+        }
+
+        protected override void Execute(NativeActivityContext context)
+        {
+            if (this.Body != null)
+            {
+                NoPersistHandle handle = this.noPersistHandle.Get(context);
+                handle.Enter(context);
+                context.ScheduleActivity(this.Body);
+            }
+        }
+
+        static Constraint NoPersistInScope()
+        {
+            DelegateInArgument<ValidationContext> validationContext = new DelegateInArgument<ValidationContext>("validationContext");
+            DelegateInArgument<NoPersistScope> noPersistScope = new DelegateInArgument<NoPersistScope>("noPersistScope");
+            Variable<bool> isConstraintSatisfied = new Variable<bool>("isConstraintSatisfied", true);
+            Variable<IEnumerable<Activity>> childActivities = new Variable<IEnumerable<Activity>>("childActivities");
+            Variable<string> constraintViolationMessage = new Variable<string>("constraintViolationMessage");
+
+            return new Constraint<NoPersistScope>
+            {
+                Body = new ActivityAction<NoPersistScope, ValidationContext>
+                {
+                    Argument1 = noPersistScope,
+                    Argument2 = validationContext,
+                    Handler = new Sequence
+                    {
+                        Variables =
+                        {
+                            isConstraintSatisfied,
+                            childActivities,
+                            constraintViolationMessage,
+                        },
+                        Activities =
+                        {
+                            new Assign<IEnumerable<Activity>>
+                            {
+                                To = childActivities,
+                                Value = new GetChildSubtree
+                                {
+                                    ValidationContext = validationContext,
+                                },
+                            },
+                            new Assign<bool>
+                            {
+                                To = isConstraintSatisfied,
+                                Value = new CheckNoPersistInDescendants
+                                {
+                                    NoPersistScope = noPersistScope,
+                                    DescendantActivities = childActivities,
+                                    ConstraintViolationMessage = constraintViolationMessage,
+                                },
+                            },
+                            new AssertValidation
+                            {
+                                Assertion = isConstraintSatisfied,
+                                Message = constraintViolationMessage,
+                            },
+                        }
+                    }
+                }
+            };
+        }
+
+        sealed class CheckNoPersistInDescendants : CodeActivity<bool>
+        {
+            [RequiredArgument]
+            public InArgument<NoPersistScope> NoPersistScope { get; set; }
+
+            [RequiredArgument]
+            public InArgument<IEnumerable<Activity>> DescendantActivities { get; set; }
+
+            [RequiredArgument]
+            public OutArgument<string> ConstraintViolationMessage { get; set; }
+
+            protected override void CacheMetadata(CodeActivityMetadata metadata)
+            {
+                Collection<RuntimeArgument> runtimeArguments = new Collection<RuntimeArgument>();
+
+                RuntimeArgument noPersistScopeArgument = new RuntimeArgument("NoPersistScope", typeof(NoPersistScope), ArgumentDirection.In);
+                metadata.Bind(this.NoPersistScope, noPersistScopeArgument);
+                runtimeArguments.Add(noPersistScopeArgument);
+
+                RuntimeArgument descendantActivitiesArgument = new RuntimeArgument("DescendantActivities", typeof(IEnumerable<Activity>), ArgumentDirection.In);
+                metadata.Bind(this.DescendantActivities, descendantActivitiesArgument);
+                runtimeArguments.Add(descendantActivitiesArgument);
+
+                RuntimeArgument constraintViolationMessageArgument = new RuntimeArgument("ConstraintViolationMessage", typeof(string), ArgumentDirection.Out);
+                metadata.Bind(this.ConstraintViolationMessage, constraintViolationMessageArgument);
+                runtimeArguments.Add(constraintViolationMessageArgument);
+
+                RuntimeArgument resultArgument = new RuntimeArgument("Result", typeof(bool), ArgumentDirection.Out);
+                metadata.Bind(this.Result, resultArgument);
+                runtimeArguments.Add(resultArgument);
+
+                metadata.SetArgumentsCollection(runtimeArguments);
+            }
+
+            protected override bool Execute(CodeActivityContext context)
+            {
+                IEnumerable<Activity> descendantActivities = this.DescendantActivities.Get(context);
+                Fx.Assert(descendantActivities != null, "this.DescendantActivities cannot evaluate to null.");
+
+                Persist firstPersist = descendantActivities.OfType<Persist>().FirstOrDefault();
+                if (firstPersist != null)
+                {
+                    NoPersistScope noPersistScope = this.NoPersistScope.Get(context);
+                    Fx.Assert(noPersistScope != null, "this.NoPersistScope cannot evaluate to null.");
+
+                    string constraintViolationMessage = SR.NoPersistScopeCannotContainPersist(noPersistScope.DisplayName, firstPersist.DisplayName);
+                    this.ConstraintViolationMessage.Set(context, constraintViolationMessage);
+                    return false;
+                }
+
+                return true;
+            }
+        }
+    }
+}