Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Runtime/CorrelationToken.cs

@@ -0,0 +1,371 @@
+using System;
+using System.Xml;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.Serialization;
+using System.Workflow.ComponentModel;
+using System.Workflow.ComponentModel.Design;
+using System.Workflow.ComponentModel.Serialization;
+using System.Workflow.Runtime;
+using System.Globalization;
+
+namespace System.Workflow.Runtime
+{
+    [DesignerSerializer(typeof(DependencyObjectCodeDomSerializer), typeof(CodeDomSerializer))]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public sealed class CorrelationToken : DependencyObject, IPropertyValueProvider
+    {
+        internal static readonly DependencyProperty NameProperty = DependencyProperty.Register("Name", typeof(string), typeof(CorrelationToken), new PropertyMetadata(DependencyPropertyOptions.Metadata, new Attribute[] { new BrowsableAttribute(false) }));
+        internal static readonly DependencyProperty OwnerActivityNameProperty = DependencyProperty.Register("OwnerActivityName", typeof(string), typeof(CorrelationToken), new PropertyMetadata(DependencyPropertyOptions.Metadata, new Attribute[] { new TypeConverterAttribute(typeof(PropertyValueProviderTypeConverter)) }));
+
+        // instance properties
+        internal static readonly DependencyProperty PropertiesProperty = DependencyProperty.Register("Properties", typeof(ICollection<CorrelationProperty>), typeof(CorrelationToken), new PropertyMetadata(new Attribute[] { new BrowsableAttribute(false), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
+        internal static readonly DependencyProperty SubscriptionsProperty = DependencyProperty.Register("Subscriptions", typeof(IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>), typeof(CorrelationToken));
+        internal static readonly DependencyProperty InitializedProperty = DependencyProperty.Register("Initialized", typeof(bool), typeof(CorrelationToken), new PropertyMetadata(false, new Attribute[] { new BrowsableAttribute(false), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
+
+        public CorrelationToken()
+        {
+        }
+
+        public CorrelationToken(string name)
+        {
+            this.Name = name;
+        }
+
+        [Browsable(false)]
+        public string Name
+        {
+            get
+            {
+                return (string)GetValue(NameProperty);
+            }
+            set
+            {
+                SetValue(NameProperty, value);
+            }
+        }
+
+        [TypeConverter(typeof(PropertyValueProviderTypeConverter))]
+        public string OwnerActivityName
+        {
+            get
+            {
+                return (string)GetValue(OwnerActivityNameProperty);
+            }
+
+            set
+            {
+                SetValue(OwnerActivityNameProperty, value);
+            }
+        }
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public ICollection<CorrelationProperty> Properties
+        {
+            get
+            {
+                return GetValue(PropertiesProperty) as ICollection<CorrelationProperty>;
+            }
+        }
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public bool Initialized
+        {
+            get
+            {
+                return (bool)GetValue(InitializedProperty);
+            }
+        }
+
+        ICollection IPropertyValueProvider.GetPropertyValues(ITypeDescriptorContext context)
+        {
+            StringCollection names = new StringCollection();
+            if (string.Equals(context.PropertyDescriptor.Name, "OwnerActivityName", StringComparison.Ordinal))
+            {
+                ISelectionService selectionService = context.GetService(typeof(ISelectionService)) as ISelectionService;
+                if (selectionService != null && selectionService.SelectionCount == 1 && selectionService.PrimarySelection is Activity)
+                {
+                    Activity currentActivity = selectionService.PrimarySelection as Activity;
+                    foreach (Activity activity in GetEnclosingCompositeActivities(currentActivity))
+                    {
+                        string activityId = activity.QualifiedName;
+                        if (!names.Contains(activityId))
+                            names.Add(activityId);
+                    }
+                }
+            }
+            return names;
+        }
+
+        public void Initialize(Activity activity, ICollection<CorrelationProperty> propertyValues)
+        {
+            if (this.Initialized)
+                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, ExecutionStringManager.CorrelationAlreadyInitialized, this.Name));
+
+            SetValue(PropertiesProperty, propertyValues);
+
+            // fire correlation initialized events
+            CorrelationTokenEventArgs eventArgs = new CorrelationTokenEventArgs(this, true);
+            IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>> subscribers = GetValue(SubscriptionsProperty) as IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>;
+            if (subscribers != null)
+            {
+                foreach (ActivityExecutorDelegateInfo<CorrelationTokenEventArgs> subscriber in subscribers)
+                {
+                    subscriber.InvokeDelegate(ContextActivityUtils.ContextActivity(activity), eventArgs, true, false);
+                }
+            }
+            SetValue(InitializedProperty, true);
+            WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "CorrelationToken initialized for {0} owner activity {1} ", this.Name, this.OwnerActivityName);
+        }
+
+        internal void Uninitialize(Activity activity)
+        {
+            SetValue(PropertiesProperty, null);
+
+            // fire correlation uninitialized events
+            CorrelationTokenEventArgs eventArgs = new CorrelationTokenEventArgs(this, false);
+            IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>> subscribers = GetValue(SubscriptionsProperty) as IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>;
+            if (subscribers != null)
+            {
+                ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>[] clonedSubscribers = new ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>[subscribers.Count];
+                subscribers.CopyTo(clonedSubscribers, 0);
+                foreach (ActivityExecutorDelegateInfo<CorrelationTokenEventArgs> subscriber in clonedSubscribers)
+                {
+                    subscriber.InvokeDelegate(ContextActivityUtils.ContextActivity(activity), eventArgs, true, false);
+                }
+            }
+            //SetValue(InitializedProperty, false);
+            WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "CorrelationToken Uninitialized for {0} owner activity {1}", this.Name, this.OwnerActivityName);
+        }
+
+        public void SubscribeForCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener<CorrelationTokenEventArgs> dataChangeListener)
+        {
+            if (dataChangeListener == null)
+                throw new ArgumentNullException("dataChangeListener");
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+
+            ActivityExecutorDelegateInfo<CorrelationTokenEventArgs> subscriber =
+                new ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>(dataChangeListener,
+                ContextActivityUtils.ContextActivity(activity), true);
+
+            IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>> subscriptions = GetValue(SubscriptionsProperty) as IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>;
+            if (subscriptions == null)
+            {
+                subscriptions = new List<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>();
+                SetValue(SubscriptionsProperty, subscriptions);
+            }
+
+            subscriptions.Add(subscriber);
+        }
+
+        public void UnsubscribeFromCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener<CorrelationTokenEventArgs> dataChangeListener)
+        {
+            if (dataChangeListener == null)
+                throw new ArgumentNullException("dataChangeListener");
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+
+            ActivityExecutorDelegateInfo<CorrelationTokenEventArgs> subscriber =
+                new ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>(dataChangeListener,
+                ContextActivityUtils.ContextActivity(activity), true);
+
+            IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>> subscriptions = GetValue(SubscriptionsProperty) as IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>;
+            if (subscriptions != null)
+            {
+                subscriptions.Remove(subscriber);
+            }
+        }
+
+        private static IEnumerable GetEnclosingCompositeActivities(Activity startActivity)
+        {
+            Activity currentActivity = null;
+            Stack<Activity> activityStack = new Stack<Activity>();
+            activityStack.Push(startActivity);
+
+            while ((currentActivity = activityStack.Pop()) != null)
+            {
+                if ((typeof(CompositeActivity).IsAssignableFrom(currentActivity.GetType())) && currentActivity.Enabled)
+                {
+                    yield return currentActivity;
+                }
+                activityStack.Push(currentActivity.Parent);
+            }
+            yield break;
+        }
+    }
+
+    [Serializable]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public sealed class CorrelationTokenCollection : KeyedCollection<string, CorrelationToken>
+    {
+        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes",
+            Justification = "Design has been approved.  This is a false positive. DependencyProperty is an immutable type.")]
+        public static readonly DependencyProperty CorrelationTokenCollectionProperty = DependencyProperty.RegisterAttached("CorrelationTokenCollection", typeof(CorrelationTokenCollection), typeof(CorrelationTokenCollection));
+
+        public CorrelationTokenCollection()
+        {
+        }
+
+        public CorrelationToken GetItem(string key)
+        {
+            return this[key];
+        }
+
+        protected override string GetKeyForItem(CorrelationToken item)
+        {
+            return item.Name;
+        }
+        protected override void ClearItems()
+        {
+            base.ClearItems();
+        }
+        protected override void InsertItem(int index, CorrelationToken item)
+        {
+            if (item == null)
+                throw new ArgumentNullException("item");
+
+            base.InsertItem(index, item);
+        }
+        protected override void RemoveItem(int index)
+        {
+            base.RemoveItem(index);
+        }
+        protected override void SetItem(int index, CorrelationToken item)
+        {
+            if (item == null)
+                throw new ArgumentNullException("item");
+
+            base.SetItem(index, item);
+        }
+
+        internal static void UninitializeCorrelationTokens(Activity activity)
+        {
+            CorrelationTokenCollection collection = activity.GetValue(CorrelationTokenCollectionProperty) as CorrelationTokenCollection;
+            if (collection != null)
+            {
+                foreach (CorrelationToken correlator in collection)
+                {
+                    correlator.Uninitialize(activity);
+                }
+            }
+        }
+
+        public static CorrelationToken GetCorrelationToken(Activity activity, string correlationTokenName, string ownerActivityName)
+        {
+            if (null == correlationTokenName)
+                throw new ArgumentNullException("correlationTokenName");
+            if (null == ownerActivityName)
+                throw new ArgumentNullException("ownerActivityName");
+            if (null == activity)
+                throw new ArgumentNullException("activity");
+
+            Activity contextActivity = ContextActivityUtils.ContextActivity(activity);
+            Activity owner = null;
+
+            if (!String.IsNullOrEmpty(ownerActivityName))
+            {
+                while (contextActivity != null)
+                {
+                    owner = contextActivity.GetActivityByName(ownerActivityName, true);
+                    if (owner != null)
+                        break;
+                    contextActivity = ContextActivityUtils.ParentContextActivity(contextActivity);
+                }
+
+                if (owner == null)
+                    owner = Helpers.ParseActivityForBind(activity, ownerActivityName);
+            }
+
+            if (owner == null)
+                throw new InvalidOperationException(ExecutionStringManager.OwnerActivityMissing);
+
+            CorrelationTokenCollection collection = owner.GetValue(CorrelationTokenCollectionProperty) as CorrelationTokenCollection;
+            if (collection == null)
+            {
+                collection = new CorrelationTokenCollection();
+                owner.SetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty, collection);
+            }
+
+            if (!collection.Contains(correlationTokenName))
+            {
+                collection.Add(new CorrelationToken(correlationTokenName));
+            }
+            return collection[correlationTokenName];
+        }
+    }
+
+    [Serializable]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public class CorrelationProperty
+    {
+        private object value = null;
+        private string name;
+
+        public CorrelationProperty(string name, object value)
+        {
+            if (null == name)
+            {
+                throw new ArgumentNullException("name");
+            }
+
+            this.name = name;
+            this.value = value;
+        }
+
+        public object Value
+        {
+            get
+            {
+                return this.value;
+            }
+        }
+
+        public string Name
+        {
+            get
+            {
+                return this.name;
+            }
+        }
+    }
+
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public sealed class CorrelationTokenEventArgs : EventArgs
+    {
+        CorrelationToken correlator;
+        bool initialized;
+
+        internal CorrelationTokenEventArgs(CorrelationToken correlator, bool initialized)
+        {
+            this.correlator = correlator;
+            this.initialized = initialized;
+        }
+
+        public bool IsInitializing
+        {
+            get
+            {
+                return this.initialized;
+            }
+        }
+
+        public CorrelationToken CorrelationToken
+        {
+            get
+            {
+                return this.correlator;
+            }
+        }
+    }
+}