linux-packaging-mono/mcs/class/referencesource/System.Workflow.Runtime/System/Activities/Statements/Interop.cs

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

namespace System.Activities.Statements
{
    using System.Activities;
    using System.Activities.Expressions;
    using System.Activities.Persistence;
    using System.Activities.Tracking;
    using System.Activities.Validation;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.Linq;
    using System.Reflection;
    using System.Threading;
    using System.Transactions;
    using System.Xml.Linq;
    using System.Workflow.Runtime;
    using System.Workflow.ComponentModel.Compiler;
    using ValidationError = System.Activities.Validation.ValidationError;
    using System.Workflow.Runtime.Hosting;
    using System.Workflow.Activities;
    using System.Runtime.Serialization;

    [SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces",
        Justification = "The type name 'Interop' conflicts in whole or in part with the namespace name 'System.Web.Services.Interop' - not common usage")]
    [Obsolete("The WF3 Types are deprecated. Instead, please use the new WF4 Types from System.Activities.*")] 
    public sealed class Interop : NativeActivity, ICustomTypeDescriptor
    {
        static Func<TimerExtension> getDefaultTimerExtension = new Func<TimerExtension>(GetDefaultTimerExtension);
        static Func<InteropPersistenceParticipant> getInteropPersistenceParticipant = new Func<InteropPersistenceParticipant>(GetInteropPersistenceParticipant);
        Dictionary<string, Argument> properties;
        Dictionary<string, object> metaProperties;
        System.Workflow.ComponentModel.Activity v1Activity;
        IList<PropertyInfo> outputPropertyDefinitions;
        HashSet<string> extraDynamicArguments;
        bool exposedBodyPropertiesCacheIsValid;
        IList<InteropProperty> exposedBodyProperties;
        Variable<InteropExecutor> interopActivityExecutor;
        Variable<RuntimeTransactionHandle> runtimeTransactionHandle;
        BookmarkCallback onResumeBookmark;
        CompletionCallback onPersistComplete;
        BookmarkCallback onTransactionComplete;
        Type activityType;
        Persist persistActivity;

        internal const string InArgumentSuffix = "In";
        internal const string OutArgumentSuffix = "Out";
        Variable<bool> persistOnClose;
        Variable<InteropEnlistment> interopEnlistment;
        Variable<Exception> outstandingException;

        object thisLock;
        // true if the body type is a valid activity. used so we can have delayed validation support in the designer
        bool hasValidBody;
        // true if the V3 activity property names will conflict with our generated argument names
        bool hasNameCollision;

        public Interop()
            : base()
        {
            this.interopActivityExecutor = new Variable<InteropExecutor>();
            this.runtimeTransactionHandle = new Variable<RuntimeTransactionHandle>();
            this.persistOnClose = new Variable<bool>();
            this.interopEnlistment = new Variable<InteropEnlistment>();
            this.outstandingException = new Variable<Exception>();
            this.onResumeBookmark = new BookmarkCallback(this.OnResumeBookmark);
            this.persistActivity = new Persist();
            this.thisLock = new object();
            base.Constraints.Add(ProcessAdvancedConstraints());
        }

        [DefaultValue(null)]
        public Type ActivityType
        {
            get
            {
                return this.activityType;
            }
            set
            {
                if (value != this.activityType)
                {
                    this.hasValidBody = false;
                    if (value != null)
                    {
                        if (typeof(System.Workflow.ComponentModel.Activity).IsAssignableFrom(value)
                            && value.GetConstructor(Type.EmptyTypes) != null)
                        {
                            this.hasValidBody = true;
                        }
                    }

                    this.activityType = value;

                    if (this.metaProperties != null)
                    {
                        this.metaProperties.Clear();
                    }
                    if (this.outputPropertyDefinitions != null)
                    {
                        this.outputPropertyDefinitions.Clear();
                    }
                    if (this.properties != null)
                    {
                        this.properties.Clear();
                    }
                    if (this.exposedBodyProperties != null)
                    {
                        for (int i = 0; i < this.exposedBodyProperties.Count; i++)
                        {
                            this.exposedBodyProperties[i].Invalidate();
                        }
                        this.exposedBodyProperties.Clear();
                    }
                    this.exposedBodyPropertiesCacheIsValid = false;

                    this.v1Activity = null;
                }
            }
        }

        [Browsable(false)]
        public IDictionary<string, Argument> ActivityProperties
        {
            get
            {
                if (this.properties == null)
                {
                    this.properties = new Dictionary<string, Argument>();
                }

                return this.properties;
            }
        }

        [Browsable(false)]
        public IDictionary<string, object> ActivityMetaProperties
        {
            get
            {
                if (this.metaProperties == null)
                {
                    this.metaProperties = new Dictionary<string, object>();
                }
                return this.metaProperties;
            }
        }

        protected override bool CanInduceIdle
        {
            get
            {
                return true;
            }
        }

        internal System.Workflow.ComponentModel.Activity ComponentModelActivity
        {
            get
            {
                if (this.v1Activity == null && this.ActivityType != null)
                {
                    Debug.Assert(this.hasValidBody, "should only be called when we have a valid body");
                    this.v1Activity = CreateActivity();
                }
                return this.v1Activity;
            }
        }

        internal IList<PropertyInfo> OutputPropertyDefinitions
        {
            get
            {
                return this.outputPropertyDefinitions;
            }
        }

        internal bool HasNameCollision
        {
            get
            {
                return this.hasNameCollision;
            }
        }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            if (this.extraDynamicArguments != null)
            {
                this.extraDynamicArguments.Clear();
            }

            this.v1Activity = null;

            if (this.hasValidBody)
            {
                //Cache the output properties prop info for look up.
                this.outputPropertyDefinitions = new List<PropertyInfo>();

                //Cache the extra property definitions for look up in OnOpen
                if (this.properties != null)
                {
                    if (this.extraDynamicArguments == null)
                    {
                        this.extraDynamicArguments = new HashSet<string>();
                    }

                    foreach (string name in properties.Keys)
                    {
                        this.extraDynamicArguments.Add(name);
                    }
                }

                //Create matched pair of RuntimeArguments for every property: Property (InArgument) & PropertyOut (Argument)
                PropertyInfo[] bodyProperties = this.ActivityType.GetProperties();
                // recheck for name collisions
                this.hasNameCollision = InteropEnvironment.ParameterHelper.HasPropertyNameCollision(bodyProperties);
                foreach (PropertyInfo propertyInfo in bodyProperties)
                {
                    if (InteropEnvironment.ParameterHelper.IsBindable(propertyInfo))
                    {
                        string propertyInName;
                        //If there are any Property/PropertyOut name pairs already extant, we fall back to renaming the InArgument half of the pair as well
                        if (this.hasNameCollision)
                        {
                            propertyInName = propertyInfo.Name + Interop.InArgumentSuffix;
                        }
                        else
                        {
                            propertyInName = propertyInfo.Name;
                        }
                        //We always rename the OutArgument half of the pair
                        string propertyOutName = propertyInfo.Name + Interop.OutArgumentSuffix;

                        RuntimeArgument inArgument = new RuntimeArgument(propertyInName, propertyInfo.PropertyType, ArgumentDirection.In);
                        RuntimeArgument outArgument = new RuntimeArgument(propertyOutName, propertyInfo.PropertyType, ArgumentDirection.Out);

                        if (this.properties != null)
                        {
                            Argument inBinding = null;
                            if (this.properties.TryGetValue(propertyInName, out inBinding))
                            {
                                if (inBinding.Direction != ArgumentDirection.In)
                                {
                                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropArgumentDirectionMismatch, propertyInName, propertyOutName));
                                }

                                this.extraDynamicArguments.Remove(propertyInName);
                                metadata.Bind(inBinding, inArgument);
                            }

                            Argument outBinding = null;
                            if (this.properties.TryGetValue(propertyOutName, out outBinding))
                            {
                                this.extraDynamicArguments.Remove(propertyOutName);
                                metadata.Bind(outBinding, outArgument);
                            }
                        }
                        metadata.AddArgument(inArgument);
                        metadata.AddArgument(outArgument);

                        this.outputPropertyDefinitions.Add(propertyInfo);
                    }
                }
            }

            metadata.SetImplementationVariablesCollection(
                new Collection<Variable>
                {
                    this.interopActivityExecutor,
                    this.runtimeTransactionHandle,
                    this.persistOnClose,
                    this.interopEnlistment,
                    this.outstandingException
                });

            metadata.AddImplementationChild(this.persistActivity);

            if (!this.hasValidBody)
            {
                if (this.ActivityType == null)
                {
                    metadata.AddValidationError(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropBodyNotSet, this.DisplayName));
                }
                else
                {
                    // Body needs to be a WF 3.0 activity
                    if (!typeof(System.Workflow.ComponentModel.Activity).IsAssignableFrom(this.ActivityType))
                    {
                        metadata.AddValidationError(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropWrongBody, this.DisplayName));
                    }

                    // and have a default ctor
                    if (this.ActivityType.GetConstructor(Type.EmptyTypes) == null)
                    {
                        metadata.AddValidationError(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropBodyMustHavePublicDefaultConstructor, this.DisplayName));
                    }
                }
            }
            else
            {
                if (this.extraDynamicArguments != null && this.extraDynamicArguments.Count > 0)
                {
                    metadata.AddValidationError(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.AttemptToBindUnknownProperties, this.DisplayName, this.extraDynamicArguments.First()));
                }
                else
                {
                    try
                    {
                        InitializeMetaProperties(this.ComponentModelActivity);
                        // We call InitializeDefinitionForRuntime in the first call to execute to 
                        // make sure it only happens once.
                    }
                    catch (InvalidOperationException e)
                    {
                        metadata.AddValidationError(e.Message);
                    }
                }
            }

            metadata.AddDefaultExtensionProvider(getDefaultTimerExtension);
            metadata.AddDefaultExtensionProvider(getInteropPersistenceParticipant);
        }

        static TimerExtension GetDefaultTimerExtension()
        {
            return new DurableTimerExtension();
        }

        static InteropPersistenceParticipant GetInteropPersistenceParticipant()
        {
            return new InteropPersistenceParticipant();
        }

        protected override void Execute(NativeActivityContext context)
        {
            // 


            WorkflowRuntimeService workflowRuntimeService = context.GetExtension<WorkflowRuntimeService>();
            if (workflowRuntimeService != null && !(workflowRuntimeService is ExternalDataExchangeService))
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropWorkflowRuntimeServiceNotSupported));
            }

            lock (this.thisLock)
            {
                ((System.Workflow.ComponentModel.IDependencyObjectAccessor)this.ComponentModelActivity).InitializeDefinitionForRuntime(null);
            }
            if (!this.ComponentModelActivity.Enabled)
            {
                return;
            }

            System.Workflow.ComponentModel.Activity activityInstance = CreateActivity();
            InitializeMetaProperties(activityInstance);
            activityInstance.SetValue(WorkflowExecutor.WorkflowInstanceIdProperty, context.WorkflowInstanceId);

            InteropExecutor interopExecutor = new InteropExecutor(context.WorkflowInstanceId, activityInstance, this.OutputPropertyDefinitions, this.ComponentModelActivity);

            if (!interopExecutor.HasCheckedForTrackingParticipant)
            {
                interopExecutor.TrackingEnabled = (context.GetExtension<TrackingParticipant>() != null);
                interopExecutor.HasCheckedForTrackingParticipant = true;
            }

            this.interopActivityExecutor.Set(context, interopExecutor);

            //Register the Handle as an execution property so that we can call GetCurrentTransaction or
            //RequestTransactionContext on it later
            RuntimeTransactionHandle runtimeTransactionHandle = this.runtimeTransactionHandle.Get(context);
            context.Properties.Add(runtimeTransactionHandle.ExecutionPropertyName, runtimeTransactionHandle);

            try
            {
                using (new ServiceEnvironment(activityInstance))
                {
                    using (InteropEnvironment interopEnvironment = new InteropEnvironment(
                        interopExecutor, context,
                        this.onResumeBookmark,
                        this,
                        runtimeTransactionHandle.GetCurrentTransaction(context)))
                    {
                        interopEnvironment.Execute(this.ComponentModelActivity, context);
                    }
                }
            }
            catch (Exception exception)
            {
                if (WorkflowExecutor.IsIrrecoverableException(exception) || !this.persistOnClose.Get(context))
                {
                    throw;
                }

                // We are not ----ing the exception.  The exception is saved in this.outstandingException.  
                // We will throw the exception from OnPersistComplete.
            }
        }

        protected override void Cancel(NativeActivityContext context)
        {
            InteropExecutor interopExecutor = this.interopActivityExecutor.Get(context);

            if (!interopExecutor.HasCheckedForTrackingParticipant)
            {
                interopExecutor.TrackingEnabled = (context.GetExtension<TrackingParticipant>() != null);
                interopExecutor.HasCheckedForTrackingParticipant = true;
            }

            interopExecutor.EnsureReload(this);

            try
            {
                using (InteropEnvironment interopEnvironment = new InteropEnvironment(
                    interopExecutor, context,
                    this.onResumeBookmark,
                    this,
                    this.runtimeTransactionHandle.Get(context).GetCurrentTransaction(context)))
                {
                    interopEnvironment.Cancel();
                }
            }
            catch (Exception exception)
            {
                if (WorkflowExecutor.IsIrrecoverableException(exception) || !this.persistOnClose.Get(context))
                {
                    throw;
                }

                // We are not ----ing the exception.  The exception is saved in this.outstandingException.  
                // We will throw the exception from OnPersistComplete.
            }
        }

        internal void SetOutputArgumentValues(IDictionary<string, object> outputs, NativeActivityContext context)
        {
            if ((this.properties != null) && (outputs != null))
            {
                foreach (KeyValuePair<string, object> output in outputs)
                {
                    Argument argument;
                    if (this.properties.TryGetValue(output.Key, out argument) && argument != null)
                    {
                        if (argument.Direction == ArgumentDirection.Out)
                        {
                            argument.Set(context, output.Value);
                        }
                    }
                }
            }
        }

        internal IDictionary<string, object> GetInputArgumentValues(NativeActivityContext context)
        {
            Dictionary<string, object> arguments = null;

            if (this.properties != null)
            {
                foreach (KeyValuePair<string, Argument> parameter in this.properties)
                {
                    Argument argument = parameter.Value;

                    if (argument.Direction == ArgumentDirection.In)
                    {
                        if (arguments == null)
                        {
                            arguments = new Dictionary<string, object>();
                        }

                        arguments.Add(parameter.Key, argument.Get<object>(context));
                    }
                }
            }

            return arguments;
        }

        System.Workflow.ComponentModel.Activity CreateActivity()
        {
            Debug.Assert(this.ActivityType != null, "ActivityType must be set by the time we get here");

            System.Workflow.ComponentModel.Activity activity = Activator.CreateInstance(this.ActivityType) as System.Workflow.ComponentModel.Activity;
            Debug.Assert(activity != null, "We should have validated that the type has a default ctor() and derives from System.Workflow.ComponentModel.Activity.");

            return activity;
        }

        void InitializeMetaProperties(System.Workflow.ComponentModel.Activity activity)
        {
            Debug.Assert((activity.GetType() == this.ActivityType), "activity must be the same type as this.ActivityType");
            if (this.metaProperties != null && this.metaProperties.Count > 0)
            {
                foreach (string name in this.metaProperties.Keys)
                {
                    PropertyInfo property = this.ActivityType.GetProperty(name);
                    if (property == null)
                    {
                        throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.MetaPropertyDoesNotExist, name, this.ActivityType.FullName));
                    }
                    property.SetValue(activity, this.metaProperties[name], null);
                }
            }
        }

        void OnResumeBookmark(NativeActivityContext context, Bookmark bookmark, object state)
        {
            InteropExecutor interopExecutor = this.interopActivityExecutor.Get(context);

            if (!interopExecutor.HasCheckedForTrackingParticipant)
            {
                interopExecutor.TrackingEnabled = (context.GetExtension<TrackingParticipant>() != null);
                interopExecutor.HasCheckedForTrackingParticipant = true;
            }

            interopExecutor.EnsureReload(this);

            try
            {
                using (InteropEnvironment interopEnvironment = new InteropEnvironment(
                    interopExecutor, context,
                    this.onResumeBookmark,
                    this,
                    this.runtimeTransactionHandle.Get(context).GetCurrentTransaction(context)))
                {
                    IComparable queueName = interopExecutor.BookmarkQueueMap[bookmark];
                    interopEnvironment.EnqueueEvent(queueName, state);
                }
            }
            catch (Exception exception)
            {
                if (WorkflowExecutor.IsIrrecoverableException(exception) || !this.persistOnClose.Get(context))
                {
                    throw;
                }

                // We are not ----ing the exception.  The exception is saved in this.outstandingException.  
                // We will throw the exception from OnPersistComplete.
            }
        }

        AttributeCollection ICustomTypeDescriptor.GetAttributes()
        {
            return TypeDescriptor.GetAttributes(this, true);
        }

        string ICustomTypeDescriptor.GetClassName()
        {
            return TypeDescriptor.GetClassName(this, true);
        }

        string ICustomTypeDescriptor.GetComponentName()
        {
            return TypeDescriptor.GetComponentName(this, true);
        }

        TypeConverter ICustomTypeDescriptor.GetConverter()
        {
            return TypeDescriptor.GetConverter(this, true);
        }

        EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
        {
            return TypeDescriptor.GetDefaultEvent(this, true);
        }

        PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
        {
            return TypeDescriptor.GetDefaultProperty(this, true);
        }

        object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
        {
            return TypeDescriptor.GetEditor(this, editorBaseType, true);
        }

        EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
        {
            return TypeDescriptor.GetEvents(this, attributes, true);
        }

        EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
        {
            return TypeDescriptor.GetEvents(this, true);
        }

        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
        {
            List<PropertyDescriptor> properties = new List<PropertyDescriptor>();

            PropertyDescriptorCollection interopProperties;
            if (attributes != null)
            {
                interopProperties = TypeDescriptor.GetProperties(this, attributes, true);
            }
            else
            {
                interopProperties = TypeDescriptor.GetProperties(this, true);
            }
            for (int i = 0; i < interopProperties.Count; i++)
            {
                properties.Add(interopProperties[i]);
            }

            if (this.hasValidBody)
            {
                // First, cache the full set of body properties
                if (!this.exposedBodyPropertiesCacheIsValid)
                {
                    //Create matched pair of RuntimeArguments for every property: Property (InArgument) & PropertyOut (Argument)
                    PropertyInfo[] bodyProperties = this.ActivityType.GetProperties();
                    // recheck for name collisions
                    this.hasNameCollision = InteropEnvironment.ParameterHelper.HasPropertyNameCollision(bodyProperties);
                    for (int i = 0; i < bodyProperties.Length; i++)
                    {
                        PropertyInfo property = bodyProperties[i];
                        bool isMetaProperty;
                        if (InteropEnvironment.ParameterHelper.IsBindableOrMetaProperty(property, out isMetaProperty))
                        {
                            // Propagate the attributes to the PropertyDescriptor, appending a DesignerSerializationVisibility attribute
                            Attribute[] customAttributes = Attribute.GetCustomAttributes(property, true);
                            Attribute[] newAttributes = new Attribute[customAttributes.Length + 1];
                            customAttributes.CopyTo(newAttributes, 0);
                            newAttributes[customAttributes.Length] = new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden);

                            if (this.exposedBodyProperties == null)
                            {
                                this.exposedBodyProperties = new List<InteropProperty>(bodyProperties.Length);
                            }
                            if (isMetaProperty)
                            {
                                InteropProperty descriptor = new LiteralProperty(this, property.Name, property.PropertyType, newAttributes);
                                this.exposedBodyProperties.Add(descriptor);
                            }
                            else
                            {
                                InteropProperty inDescriptor;
                                //If there are any Property/PropertyOut name pairs already extant, we fall back to renaming the InArgument half of the pair as well
                                if (this.hasNameCollision)
                                {
                                    inDescriptor = new ArgumentProperty(this, property.Name + InArgumentSuffix, Argument.Create(property.PropertyType, ArgumentDirection.In), newAttributes);
                                }
                                else
                                {
                                    inDescriptor = new ArgumentProperty(this, property.Name, Argument.Create(property.PropertyType, ArgumentDirection.In), newAttributes);
                                }
                                this.exposedBodyProperties.Add(inDescriptor);
                                //We always rename the OutArgument half of the pair
                                InteropProperty outDescriptor = new ArgumentProperty(this, property.Name + OutArgumentSuffix, Argument.Create(property.PropertyType, ArgumentDirection.Out), newAttributes);
                                this.exposedBodyProperties.Add(outDescriptor);
                            }
                        }
                    }
                    this.exposedBodyPropertiesCacheIsValid = true;
                }
                // Now adds body properties, complying with the filter:
                if (this.exposedBodyProperties != null)
                {
                    for (int i = 0; i < this.exposedBodyProperties.Count; i++)
                    {
                        PropertyDescriptor descriptor = this.exposedBodyProperties[i];
                        if (attributes == null || !ShouldFilterProperty(descriptor, attributes))
                        {
                            properties.Add(descriptor);
                        }
                    }
                }
            }

            return new PropertyDescriptorCollection(properties.ToArray());
        }

        static bool ShouldFilterProperty(PropertyDescriptor property, Attribute[] attributes)
        {
            if (attributes == null || attributes.Length == 0)
            {
                return false;
            }

            for (int i = 0; i < attributes.Length; i++)
            {
                Attribute filterAttribute = attributes[i];
                Attribute propertyAttribute = property.Attributes[filterAttribute.GetType()];
                if (propertyAttribute == null)
                {
                    if (!filterAttribute.IsDefaultAttribute())
                    {
                        return true;
                    }
                }
                else
                {
                    if (!filterAttribute.Match(propertyAttribute))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
        {
            return ((ICustomTypeDescriptor)this).GetProperties(null);
        }

        object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
        {
            InteropProperty intProp = pd as InteropProperty;
            if (intProp != null)
            {
                return intProp.Owner;
            }
            else
            {
                return this;
            }
        }

        internal void OnClose(NativeActivityContext context, Exception exception)
        {
            if (this.persistOnClose.Get(context))
            {
                if (exception == null)
                {
                    context.ScheduleActivity(this.persistActivity);
                }
                else
                {
                    // The V1 workflow faulted and there is an uncaught exception. We cannot throw
                    // the exception right away because we must Persist in order to process the WorkBatch.
                    // So we are saving the uncaught exception and scheduling the Persist activity with a completion callback.
                    // We will throw the exception from OnPersistComplete.
                    this.outstandingException.Set(context, exception);

                    if (this.onPersistComplete == null)
                    {
                        this.onPersistComplete = new CompletionCallback(this.OnPersistComplete);
                    }

                    context.ScheduleActivity(this.persistActivity, this.onPersistComplete);
                }
            }

            this.interopEnlistment.Set(context, null);
        }

        internal void Persist(NativeActivityContext context)
        {
            if (this.onPersistComplete == null)
            {
                this.onPersistComplete = new CompletionCallback(this.OnPersistComplete);
            }

            // If Persist fails for any reason, the workflow aborts
            context.ScheduleActivity(this.persistActivity, this.onPersistComplete);
        }

        internal void OnPersistComplete(NativeActivityContext context, ActivityInstance completedInstance)
        {
            this.persistOnClose.Set(context, false);
            Exception exception = this.outstandingException.Get(context);
            if (exception != null)
            {
                this.outstandingException.Set(context, null);
                throw exception;
            }

            this.Resume(context, null);
        }

        internal void CreateTransaction(NativeActivityContext context, TransactionOptions txOptions)
        {
            RuntimeTransactionHandle transactionHandle = this.runtimeTransactionHandle.Get(context);
            Debug.Assert(transactionHandle != null, "RuntimeTransactionHandle is null");

            transactionHandle.RequestTransactionContext(context, OnTransactionContextAcquired, txOptions);
        }

        void OnTransactionContextAcquired(NativeActivityTransactionContext context, object state)
        {
            Debug.Assert(context != null, "ActivityTransactionContext was null");
            TransactionOptions txOptions = (TransactionOptions)state;
            CommittableTransaction transaction = new CommittableTransaction(txOptions);
            context.SetRuntimeTransaction(transaction);
            this.Resume(context, transaction);
        }

        internal void CommitTransaction(NativeActivityContext context)
        {
            if (this.onTransactionComplete == null)
            {
                this.onTransactionComplete = new BookmarkCallback(this.OnTransactionComplete);
            }

            RuntimeTransactionHandle transactionHandle = this.runtimeTransactionHandle.Get(context);
            transactionHandle.CompleteTransaction(context, this.onTransactionComplete);
        }

        void OnTransactionComplete(NativeActivityContext context, Bookmark bookmark, object state)
        {
            this.Resume(context, null);
        }

        void Resume(NativeActivityContext context, Transaction transaction)
        {
            InteropExecutor interopExecutor = this.interopActivityExecutor.Get(context);

            if (!interopExecutor.HasCheckedForTrackingParticipant)
            {
                interopExecutor.TrackingEnabled = (context.GetExtension<TrackingParticipant>() != null);
                interopExecutor.HasCheckedForTrackingParticipant = true;
            }

            interopExecutor.EnsureReload(this);

            try
            {
                using (InteropEnvironment interopEnvironment = new InteropEnvironment(
                    interopExecutor, context,
                    this.onResumeBookmark,
                    this,
                    transaction))
                {
                    interopEnvironment.Resume();
                }
            }
            catch (Exception exception)
            {
                if (WorkflowExecutor.IsIrrecoverableException(exception) || !this.persistOnClose.Get(context))
                {
                    throw;
                }

                // We are not ----ing the exception.  The exception is saved in this.outstandingException.  
                // We will throw the exception from OnPersistComplete.
            }
        }

        internal void AddResourceManager(NativeActivityContext context, VolatileResourceManager resourceManager)
        {
            if (Transaction.Current != null &&
                Transaction.Current.TransactionInformation.Status == TransactionStatus.Active)
            {
                InteropEnlistment enlistment = this.interopEnlistment.Get(context);
                if (enlistment == null || !enlistment.IsValid)
                {
                    enlistment = new InteropEnlistment(Transaction.Current, resourceManager);
                    Transaction.Current.EnlistVolatile(enlistment, EnlistmentOptions.EnlistDuringPrepareRequired);
                    this.interopEnlistment.Set(context, enlistment);
                }
            }
            else
            {
                InteropPersistenceParticipant persistenceParticipant = context.GetExtension<InteropPersistenceParticipant>();
                persistenceParticipant.Add(this.Id, resourceManager);
                this.persistOnClose.Set(context, true);
            }
        }

        Constraint ProcessAdvancedConstraints()
        {
            DelegateInArgument<Interop> element = new DelegateInArgument<Interop>() { Name = "element" };
            DelegateInArgument<ValidationContext> validationContext = new DelegateInArgument<ValidationContext>() { Name = "validationContext" };
            DelegateInArgument<Activity> parent = new DelegateInArgument<Activity>() { Name = "parent" };

            //This will accumulate all potential violations at the root level. See the use case DIRECT of the Interop spec
            Variable<HashSet<InteropValidationEnum>> rootValidationDataVar = new Variable<HashSet<InteropValidationEnum>>(context => new HashSet<InteropValidationEnum>());

            //This will accumulate all violations at the nested level. See the use case NESTED of the Interop spec
            Variable<HashSet<InteropValidationEnum>> nestedChildrenValidationDataVar = new Variable<HashSet<InteropValidationEnum>>(context => new HashSet<InteropValidationEnum>());

            return new Constraint<Interop>
            {
                Body = new ActivityAction<Interop, ValidationContext>
                {
                    Argument1 = element,
                    Argument2 = validationContext,
                    Handler = new If
                    {
                        Condition = new InArgument<bool>(env => element.Get(env).hasValidBody),
                        Then = new Sequence
                        {
                            Variables = { rootValidationDataVar, nestedChildrenValidationDataVar },
                            Activities = 
                             {
                                //First traverse the interop body and collect all available data for validation. This is done at all levels, DIRECT and NESTED
                                new WalkInteropBodyAndGatherData()
                                {
                                     RootLevelValidationData = new InArgument<HashSet<InteropValidationEnum>>(rootValidationDataVar),
                                     NestedChildrenValidationData = new InArgument<HashSet<InteropValidationEnum>>(nestedChildrenValidationDataVar),
                                     InteropActivity = element
                                },
                                //This is based off the table in the Interop spec.
                                new ValidateAtRootAndNestedLevels()
                                {
                                     RootLevelValidationData = rootValidationDataVar,
                                     NestedChildrenValidationData = nestedChildrenValidationDataVar,
                                     Interop = element,
                                },
                                //Traverse the parent chain of the Interop activity to look for specifc violations regarding composition of 3.0 activities within 4.0 activities.
                                //Specifically, 
                                //  - 3.0 TransactionScope within a 4.0 TransactionScope
                                //  - 3.0 PersistOnClose within a 4.0 TransactionScope
                                //
                                new ForEach<Activity>
                                {
                                    Values = new GetParentChain
                                    {
                                        ValidationContext = validationContext,
                                    },
                                    Body = new ActivityAction<Activity>
                                    {
                                        Argument = parent,
                                        Handler = new Sequence                                   
                                        {
                                            Activities = 
                                            {
                                                new If()
                                                {
                                                    Condition = new Or<bool, bool, bool>
                                                    { 
                                                        Left = new Equal<Type, Type, bool>
                                                        {
                                                            Left = new ObtainType
                                                            {
                                                                Input = parent,
                                                            },
                                                            Right = new InArgument<Type>(context => typeof(System.Activities.Statements.TransactionScope))
                                                        },
                                                        Right = new Equal<string, string, bool>
                                                        {
                                                            Left = new InArgument<string>(env => parent.Get(env).GetType().FullName),
                                                            Right = "System.ServiceModel.Activities.TransactedReceiveScope"
                                                        }
                                                    },
                                                    Then = new Sequence
                                                    {
                                                        Activities = 
                                                        {
                                                            new AssertValidation
                                                            {
                                                                //Here we only pass the NestedChildrenValidationData since root level use 
                                                                //of TransactionScope would have already been flagged as an error
                                                                Assertion = new CheckForTransactionScope()
                                                                {
                                                                     ValidationResults = nestedChildrenValidationDataVar
                                                                },
                                                                Message = new InArgument<string>(ExecutionStringManager.InteropBodyNestedTransactionScope)
                                                            },
                                                            new AssertValidation
                                                            {
                                                                Assertion = new CheckForPersistOnClose()
                                                                {
                                                                     NestedChildrenValidationData = nestedChildrenValidationDataVar,
                                                                     RootLevelValidationData = rootValidationDataVar
                                                                },
                                                                Message = new InArgument<string>(ExecutionStringManager.InteropBodyNestedPersistOnCloseWithinTransactionScope)
                                                            },

                                                        }
                                                    },
                                                },
                                            }
                                        }                                   
                                    }
                                },
                                new ActivityTreeValidation()
                                {
                                    Interop = element
                                }
                            }
                        }
                    }
                }
            };
        }

        class ActivityTreeValidation : NativeActivity
        {
            public ActivityTreeValidation()
            {
            }

            public InArgument<Interop> Interop
            {
                get;
                set;
            }

            protected override void Execute(NativeActivityContext context)
            {
                Interop interop = this.Interop.Get(context);

                if (interop == null)
                {
                    return;
                }

                if (!typeof(System.Workflow.ComponentModel.Activity).IsAssignableFrom(interop.ActivityType))
                {
                    return;
                }

                System.ComponentModel.Design.ServiceContainer container = new System.ComponentModel.Design.ServiceContainer();
                container.AddService(typeof(ITypeProvider), CreateTypeProvider(interop.ActivityType));
                ValidationManager manager = new ValidationManager(container);

                System.Workflow.ComponentModel.Activity interopBody = interop.ComponentModelActivity;
                using (WorkflowCompilationContext.CreateScope(manager))
                {
                    foreach (Validator validator in manager.GetValidators(interop.ActivityType))
                    {
                        ValidationErrorCollection errors = validator.Validate(manager, interopBody);
                        foreach (System.Workflow.ComponentModel.Compiler.ValidationError error in errors)
                        {
                            Constraint.AddValidationError(context, new ValidationError(error.ErrorText, error.IsWarning, error.PropertyName));
                        }
                    }
                }
            }

            static TypeProvider CreateTypeProvider(Type rootType)
            {
                TypeProvider typeProvider = new TypeProvider(null);

                typeProvider.SetLocalAssembly(rootType.Assembly);
                typeProvider.AddAssembly(rootType.Assembly);

                foreach (AssemblyName assemblyName in rootType.Assembly.GetReferencedAssemblies())
                {
                    Assembly referencedAssembly = null;
                    try
                    {
                        referencedAssembly = Assembly.Load(assemblyName);
                        if (referencedAssembly != null)
                            typeProvider.AddAssembly(referencedAssembly);
                    }
                    catch
                    {
                    }

                    if (referencedAssembly == null && assemblyName.CodeBase != null)
                        typeProvider.AddAssemblyReference(assemblyName.CodeBase);
                }

                return typeProvider;
            }
        }

        class CheckForTransactionScope : CodeActivity<bool>
        {
            public InArgument<HashSet<InteropValidationEnum>> ValidationResults
            {
                get;
                set;
            }

            protected override bool Execute(CodeActivityContext context)
            {
                HashSet<InteropValidationEnum> validationResults = this.ValidationResults.Get(context);
                if (validationResults.Contains(InteropValidationEnum.TransactionScope))
                {
                    return false;
                }

                return true;
            }
        }

        class CheckForPersistOnClose : CodeActivity<bool>
        {
            public InArgument<HashSet<InteropValidationEnum>> NestedChildrenValidationData
            {
                get;
                set;
            }

            public InArgument<HashSet<InteropValidationEnum>> RootLevelValidationData
            {
                get;
                set;
            }

            protected override bool Execute(CodeActivityContext context)
            {
                HashSet<InteropValidationEnum> nestedValidationData = this.NestedChildrenValidationData.Get(context);
                HashSet<InteropValidationEnum> rootValidationData = this.RootLevelValidationData.Get(context);

                if (nestedValidationData.Contains(InteropValidationEnum.PersistOnClose) || rootValidationData.Contains(InteropValidationEnum.PersistOnClose))
                {
                    return false;
                }

                return true;
            }
        }

        class ValidateAtRootAndNestedLevels : NativeActivity
        {
            public ValidateAtRootAndNestedLevels()
            {
            }

            public InArgument<Interop> Interop
            {
                get;
                set;
            }

            public InArgument<HashSet<InteropValidationEnum>> RootLevelValidationData
            {
                get;
                set;
            }

            public InArgument<HashSet<InteropValidationEnum>> NestedChildrenValidationData
            {
                get;
                set;
            }

            protected override void Execute(NativeActivityContext context)
            {
                Interop activity = this.Interop.Get(context);

                foreach (InteropValidationEnum validationEnum in this.RootLevelValidationData.Get(context))
                {
                    //We care to mark PersistOnClose during the walking algorithm because we need to check if it happens under a 4.0 TransactionScopActivity and flag that
                    //That is done later, so skip here. 
                    if (validationEnum != InteropValidationEnum.PersistOnClose)
                    {
                        string message = string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropBodyRootLevelViolation, activity.DisplayName, validationEnum.ToString() + "Activity");
                        Constraint.AddValidationError(context, new ValidationError(message));
                    }
                }

                foreach (InteropValidationEnum validationEnum in this.NestedChildrenValidationData.Get(context))
                {
                    //We care to mark PersistOnClose or TransactionScope during the walking algorithm because we need to check if it happens under a 4.0 TransactionScopActivity and flag that
                    //That is done later, so skip here. 
                    if ((validationEnum != InteropValidationEnum.PersistOnClose) && (validationEnum != InteropValidationEnum.TransactionScope))
                    {
                        string message = string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropBodyNestedViolation, activity.DisplayName, validationEnum.ToString() + "Activity");
                        Constraint.AddValidationError(context, new ValidationError(message));
                    }
                }
            }
        }

        class WalkInteropBodyAndGatherData : System.Activities.CodeActivity
        {
            public InArgument<Interop> InteropActivity
            {
                get;
                set;
            }

            public InArgument<HashSet<InteropValidationEnum>> RootLevelValidationData
            {
                get;
                set;
            }

            public InArgument<HashSet<InteropValidationEnum>> NestedChildrenValidationData
            {
                get;
                set;
            }

            protected override void Execute(CodeActivityContext context)
            {
                Interop interop = this.InteropActivity.Get(context);
                Debug.Assert(interop != null, "Interop activity is null");

                Debug.Assert(interop.hasValidBody, "Interop activity has an invalid body");

                System.Workflow.ComponentModel.Activity interopBody = interop.ComponentModelActivity;
                Debug.Assert(interopBody != null, "Interop Body was null");

                HashSet<InteropValidationEnum> validationResults;
                validationResults = this.RootLevelValidationData.Get(context);
                Debug.Assert(validationResults != null, "The RootLevelValidationData hash set was null");

                //Gather data at root level first
                ProcessAtRootLevel(interopBody, validationResults);

                validationResults = null;
                validationResults = this.NestedChildrenValidationData.Get(context);
                Debug.Assert(validationResults != null, "The NestedChildrenValidationData hash set was null");

                //Next, process nested children of the Body
                if (interopBody is System.Workflow.ComponentModel.CompositeActivity)
                {
                    ProcessNestedChildren(interopBody, validationResults);
                }

                return;
            }

            void ProcessAtRootLevel(System.Workflow.ComponentModel.Activity interopBody, HashSet<InteropValidationEnum> validationResults)
            {
                Debug.Assert(interopBody != null, "Interop Body is null");
                Debug.Assert(validationResults != null, "The HashSet of validation results is null");

                if (interopBody.PersistOnClose)
                {
                    validationResults.Add(InteropValidationEnum.PersistOnClose);
                }

                Type interopBodyType = interopBody.GetType();
                if (interopBodyType == typeof(System.Workflow.ComponentModel.TransactionScopeActivity))
                {
                    validationResults.Add(InteropValidationEnum.TransactionScope);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.CodeActivity))
                {
                    validationResults.Add(InteropValidationEnum.Code);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.DelayActivity))
                {
                    validationResults.Add(InteropValidationEnum.Delay);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.InvokeWebServiceActivity))
                {
                    validationResults.Add(InteropValidationEnum.InvokeWebService);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.InvokeWorkflowActivity))
                {
                    validationResults.Add(InteropValidationEnum.InvokeWorkflow);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.PolicyActivity))
                {
                    validationResults.Add(InteropValidationEnum.Policy);
                }
                else if (interopBodyType.FullName == "System.Workflow.Activities.SendActivity")
                {
                    validationResults.Add(InteropValidationEnum.Send);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.SetStateActivity))
                {
                    validationResults.Add(InteropValidationEnum.SetState);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.WebServiceFaultActivity))
                {
                    validationResults.Add(InteropValidationEnum.WebServiceFault);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.WebServiceInputActivity))
                {
                    validationResults.Add(InteropValidationEnum.WebServiceInput);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.WebServiceOutputActivity))
                {
                    validationResults.Add(InteropValidationEnum.WebServiceOutput);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.CompensateActivity))
                {
                    validationResults.Add(InteropValidationEnum.Compensate);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.SuspendActivity))
                {
                    validationResults.Add(InteropValidationEnum.Suspend);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.TerminateActivity))
                {
                    validationResults.Add(InteropValidationEnum.Terminate);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.ThrowActivity))
                {
                    validationResults.Add(InteropValidationEnum.Throw);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.ConditionedActivityGroup))
                {
                    validationResults.Add(InteropValidationEnum.ConditionedActivityGroup);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.EventHandlersActivity))
                {
                    validationResults.Add(InteropValidationEnum.EventHandlers);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.EventHandlingScopeActivity))
                {
                    validationResults.Add(InteropValidationEnum.EventHandlingScope);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.IfElseActivity))
                {
                    validationResults.Add(InteropValidationEnum.IfElse);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.ListenActivity))
                {
                    validationResults.Add(InteropValidationEnum.Listen);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.ParallelActivity))
                {
                    validationResults.Add(InteropValidationEnum.Parallel);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.ReplicatorActivity))
                {
                    validationResults.Add(InteropValidationEnum.Replicator);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.SequenceActivity))
                {
                    validationResults.Add(InteropValidationEnum.Sequence);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.CompensatableSequenceActivity))
                {
                    validationResults.Add(InteropValidationEnum.CompensatableSequence);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.EventDrivenActivity))
                {
                    validationResults.Add(InteropValidationEnum.EventDriven);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.IfElseBranchActivity))
                {
                    validationResults.Add(InteropValidationEnum.IfElseBranch);
                }
                else if (interopBodyType.FullName == "System.Workflow.Activities.ReceiveActivity")
                {
                    validationResults.Add(InteropValidationEnum.Receive);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.SequentialWorkflowActivity))
                {
                    validationResults.Add(InteropValidationEnum.SequentialWorkflow);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.StateFinalizationActivity))
                {
                    validationResults.Add(InteropValidationEnum.StateFinalization);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.StateInitializationActivity))
                {
                    validationResults.Add(InteropValidationEnum.StateInitialization);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.StateActivity))
                {
                    validationResults.Add(InteropValidationEnum.State);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.StateMachineWorkflowActivity))
                {
                    validationResults.Add(InteropValidationEnum.StateMachineWorkflow);
                }
                else if (interopBodyType == typeof(System.Workflow.Activities.WhileActivity))
                {
                    validationResults.Add(InteropValidationEnum.While);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.CancellationHandlerActivity))
                {
                    validationResults.Add(InteropValidationEnum.CancellationHandler);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.CompensatableTransactionScopeActivity))
                {
                    validationResults.Add(InteropValidationEnum.CompensatableTransactionScope);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.CompensationHandlerActivity))
                {
                    validationResults.Add(InteropValidationEnum.CompensationHandler);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.FaultHandlerActivity))
                {
                    validationResults.Add(InteropValidationEnum.FaultHandler);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.FaultHandlersActivity))
                {
                    validationResults.Add(InteropValidationEnum.FaultHandlers);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.SynchronizationScopeActivity))
                {
                    validationResults.Add(InteropValidationEnum.SynchronizationScope);
                }
                else if (interopBodyType == typeof(System.Workflow.ComponentModel.ICompensatableActivity))
                {
                    validationResults.Add(InteropValidationEnum.ICompensatable);
                }
            }

            void ProcessNestedChildren(System.Workflow.ComponentModel.Activity interopBody, HashSet<InteropValidationEnum> validationResults)
            {
                Debug.Assert(interopBody != null, "Interop Body is null");
                Debug.Assert(validationResults != null, "The HashSet of validation results is null");
                bool persistOnClose = false;

                foreach (System.Workflow.ComponentModel.Activity activity in interopBody.CollectNestedActivities())
                {
                    if (activity.PersistOnClose)
                    {
                        persistOnClose = true;
                    }

                    if (activity is System.Workflow.ComponentModel.TransactionScopeActivity)
                    {
                        validationResults.Add(InteropValidationEnum.TransactionScope);
                    }
                    else if (activity is System.Workflow.Activities.InvokeWorkflowActivity)
                    {
                        validationResults.Add(InteropValidationEnum.InvokeWorkflow);
                    }
                    // SendActivity is sealed
                    else if (activity.GetType().FullName == "System.Workflow.Activities.SendActivity")
                    {
                        validationResults.Add(InteropValidationEnum.Send);
                    }
                    else if (activity is System.Workflow.Activities.WebServiceFaultActivity)
                    {
                        validationResults.Add(InteropValidationEnum.WebServiceFault);
                    }
                    else if (activity is System.Workflow.Activities.WebServiceInputActivity)
                    {
                        validationResults.Add(InteropValidationEnum.WebServiceInput);
                    }
                    else if (activity is System.Workflow.Activities.WebServiceOutputActivity)
                    {
                        validationResults.Add(InteropValidationEnum.WebServiceOutput);
                    }
                    else if (activity is System.Workflow.ComponentModel.CompensateActivity)
                    {
                        validationResults.Add(InteropValidationEnum.Compensate);
                    }
                    else if (activity is System.Workflow.ComponentModel.SuspendActivity)
                    {
                        validationResults.Add(InteropValidationEnum.Suspend);
                    }
                    else if (activity is System.Workflow.Activities.CompensatableSequenceActivity)
                    {
                        validationResults.Add(InteropValidationEnum.CompensatableSequence);
                    }
                    // ReceiveActivity is sealed
                    else if (activity.GetType().FullName == "System.Workflow.Activities.ReceiveActivity")
                    {
                        validationResults.Add(InteropValidationEnum.Receive);
                    }
                    else if (activity is System.Workflow.ComponentModel.CompensatableTransactionScopeActivity)
                    {
                        validationResults.Add(InteropValidationEnum.CompensatableTransactionScope);
                    }
                    else if (activity is System.Workflow.ComponentModel.CompensationHandlerActivity)
                    {
                        validationResults.Add(InteropValidationEnum.CompensationHandler);
                    }
                    else if (activity is System.Workflow.ComponentModel.ICompensatableActivity)
                    {
                        validationResults.Add(InteropValidationEnum.ICompensatable);
                    }
                }

                if (persistOnClose)
                {
                    validationResults.Add(InteropValidationEnum.PersistOnClose);
                }
            }
        }

        //This needs to be in sync with the table in the spec
        //We use this internally to keep a hashset of validation data
        enum InteropValidationEnum
        {
            Code,
            Delay,
            InvokeWebService,
            InvokeWorkflow,
            Policy,
            Send,
            SetState,
            WebServiceFault,
            WebServiceInput,
            WebServiceOutput,
            Compensate,
            Suspend,
            ConditionedActivityGroup,
            EventHandlers,
            EventHandlingScope,
            IfElse,
            Listen,
            Parallel,
            Replicator,
            Sequence,
            CompensatableSequence,
            EventDriven,
            IfElseBranch,
            Receive,
            SequentialWorkflow,
            StateFinalization,
            StateInitialization,
            State,
            StateMachineWorkflow,
            While,
            CancellationHandler,
            CompensatableTransactionScope,
            CompensationHandler,
            FaultHandler,
            FaultHandlers,
            SynchronizationScope,
            TransactionScope,
            ICompensatable,
            PersistOnClose,
            Terminate,
            Throw
        }

        class ObtainType : CodeActivity<Type>
        {
            public ObtainType()
            {
            }

            public InArgument<Activity> Input
            {
                get;
                set;
            }

            protected override Type Execute(CodeActivityContext context)
            {
                return this.Input.Get(context).GetType();
            }
        }

        abstract class InteropProperty : PropertyDescriptor
        {
            Interop owner;
            bool isValid;

            public InteropProperty(Interop owner, string name, Attribute[] propertyInfoAttributes)
                : base(name, propertyInfoAttributes)
            {
                this.owner = owner;
                this.isValid = true;
            }

            public override Type ComponentType
            {
                get
                {
                    ThrowIfInvalid();
                    return this.owner.GetType();
                }
            }

            protected internal Interop Owner
            {
                get
                {
                    return this.owner;
                }
            }

            public override bool CanResetValue(object component)
            {
                ThrowIfInvalid();
                return false;
            }

            public override void ResetValue(object component)
            {
                ThrowIfInvalid();
            }

            public override bool ShouldSerializeValue(object component)
            {
                ThrowIfInvalid();
                return false;
            }

            protected void ThrowIfInvalid()
            {
                if (!this.isValid)
                {
                    throw new InvalidOperationException(ExecutionStringManager.InteropInvalidPropertyDescriptor);
                }
            }

            internal void Invalidate()
            {
                this.isValid = false;
            }
        }

        class ArgumentProperty : InteropProperty
        {
            string argumentName;
            Argument argument;

            public ArgumentProperty(Interop owner, string argumentName, Argument argument, Attribute[] attributes)
                : base(owner, argumentName, attributes)
            {
                this.argumentName = argumentName;
                this.argument = argument;
            }

            public override bool IsReadOnly
            {
                get
                {
                    ThrowIfInvalid();
                    return false;
                }
            }

            public override Type PropertyType
            {
                get
                {
                    ThrowIfInvalid();
                    return GetArgument().GetType();
                }
            }

            public override object GetValue(object component)
            {
                ThrowIfInvalid();
                return GetArgument();
            }

            public override void SetValue(object component, object value)
            {
                ThrowIfInvalid();
                if (value != null)
                {
                    this.Owner.ActivityProperties[this.argumentName] = (Argument)value;
                }
                else
                {
                    this.Owner.ActivityProperties.Remove(this.argumentName);
                }
            }

            Argument GetArgument()
            {
                Argument argument;
                if (!this.Owner.ActivityProperties.TryGetValue(this.argumentName, out argument))
                {
                    argument = this.argument;
                }
                return argument;
            }
        }

        class LiteralProperty : InteropProperty
        {
            string literalName;
            Type literalType;

            public LiteralProperty(Interop owner, string literalName, Type literalType, Attribute[] attributes)
                : base(owner, literalName, attributes)
            {
                this.literalName = literalName;
                this.literalType = literalType;
            }

            public override bool IsReadOnly
            {
                get
                {
                    ThrowIfInvalid();
                    return false;
                }
            }

            public override Type PropertyType
            {
                get
                {
                    ThrowIfInvalid();
                    return this.literalType;
                }
            }

            public override object GetValue(object component)
            {
                ThrowIfInvalid();
                return GetLiteral();
            }

            public override void SetValue(object component, object value)
            {
                ThrowIfInvalid();
                this.Owner.ActivityMetaProperties[this.literalName] = value;
            }

            object GetLiteral()
            {
                object literal;
                if (this.Owner.ActivityMetaProperties.TryGetValue(this.literalName, out literal))
                {
                    return literal;
                }
                else
                {
                    return null;
                }
            }
        }

        class InteropPersistenceParticipant : PersistenceIOParticipant
        {
            public InteropPersistenceParticipant()
                : base(true, false)
            {
                this.ResourceManagers = new Dictionary<string, VolatileResourceManager>();
                this.CommittedResourceManagers = new Dictionary<Transaction, Dictionary<string, VolatileResourceManager>>();
            }

            Dictionary<string, VolatileResourceManager> ResourceManagers
            {
                get;
                set;
            }

            Dictionary<Transaction, Dictionary<string, VolatileResourceManager>> CommittedResourceManagers
            {
                get;
                set;
            }

            protected override IAsyncResult BeginOnSave(IDictionary<XName, object> readWriteValues, IDictionary<System.Xml.Linq.XName, object> writeOnlyValues, TimeSpan timeout, AsyncCallback callback, object state)
            {
                try
                {
                    foreach (VolatileResourceManager rm in this.ResourceManagers.Values)
                    {
                        rm.Commit();
                    }
                }
                finally
                {
                    this.CommittedResourceManagers.Add(Transaction.Current, this.ResourceManagers);
                    this.ResourceManagers = new Dictionary<string, VolatileResourceManager>();
                    Transaction.Current.TransactionCompleted += new TransactionCompletedEventHandler(Current_TransactionCompleted);
                }

                return new CompletedAsyncResult(callback, state);
            }

            protected override void EndOnSave(IAsyncResult result)
            {
                CompletedAsyncResult.End(result);
            }

            void Current_TransactionCompleted(object sender, TransactionEventArgs e)
            {
                if (e.Transaction.TransactionInformation.Status == TransactionStatus.Committed)
                {
                    foreach (VolatileResourceManager rm in this.CommittedResourceManagers[e.Transaction].Values)
                    {
                        rm.Complete();
                    }
                }
                else
                {
                    foreach (VolatileResourceManager rm in this.CommittedResourceManagers[e.Transaction].Values)
                    {
                        rm.ClearAllBatchedWork();
                    }
                }
                this.CommittedResourceManagers.Remove(e.Transaction);
            }

            protected override void Abort()
            {
                foreach (VolatileResourceManager rm in this.ResourceManagers.Values)
                {
                    rm.ClearAllBatchedWork();
                }

                this.ResourceManagers = new Dictionary<string, VolatileResourceManager>();
            }

            internal void Add(string activityId, VolatileResourceManager rm)
            {
                // Add and OnSave shouldn't be called at the same time.  A lock isn't needed here.
                this.ResourceManagers.Add(activityId, rm);
            }
        }

        [DataContract]
        class InteropEnlistment : IEnlistmentNotification
        {
            VolatileResourceManager resourceManager;
            Transaction transaction;

            public InteropEnlistment()
            {
            }

            public InteropEnlistment(Transaction transaction, VolatileResourceManager resourceManager)
            {
                this.resourceManager = resourceManager;
                this.transaction = transaction;
                this.IsValid = true;
            }

            public bool IsValid { get; set; }

            public void Commit(Enlistment enlistment)
            {
                this.resourceManager.Complete();
                enlistment.Done();
            }

            public void InDoubt(Enlistment enlistment)
            {
                // Following the WF3 runtime behavior - Aborting during InDoubt
                this.Rollback(enlistment);
            }

            public void Prepare(PreparingEnlistment preparingEnlistment)
            {
                using (System.Transactions.TransactionScope ts = new System.Transactions.TransactionScope(this.transaction))
                {
                    this.resourceManager.Commit();
                    ts.Complete();
                }
                preparingEnlistment.Prepared();
            }

            public void Rollback(Enlistment enlistment)
            {
                this.resourceManager.ClearAllBatchedWork();
                enlistment.Done();
            }
        }

        class CompletedAsyncResult : IAsyncResult
        {
            AsyncCallback callback;
            bool endCalled;
            ManualResetEvent manualResetEvent;
            object state;
            object thisLock;

            public CompletedAsyncResult(AsyncCallback callback, object state)
            {
                this.callback = callback;
                this.state = state;
                this.thisLock = new object();

                if (callback != null)
                {
                    try
                    {
                        callback(this);
                    }
                    catch (Exception e) // transfer to another thread, this is a fatal situation
                    {
                        throw new InvalidProgramException(ExecutionStringManager.AsyncCallbackThrewException, e);
                    }
                }
            }

            public static void End(IAsyncResult result)
            {
                if (result == null)
                {
                    throw new ArgumentNullException("result");
                }

                CompletedAsyncResult asyncResult = result as CompletedAsyncResult;

                if (asyncResult == null)
                {
                    throw new ArgumentException(ExecutionStringManager.InvalidAsyncResult, "result");
                }

                if (asyncResult.endCalled)
                {
                    throw new InvalidOperationException(ExecutionStringManager.EndCalledTwice);
                }

                asyncResult.endCalled = true;

                if (asyncResult.manualResetEvent != null)
                {
                    asyncResult.manualResetEvent.Close();
                }
            }

            public object AsyncState
            {
                get
                {
                    return state;
                }
            }

            public WaitHandle AsyncWaitHandle
            {
                get
                {
                    if (this.manualResetEvent != null)
                    {
                        return this.manualResetEvent;
                    }

                    lock (ThisLock)
                    {
                        if (this.manualResetEvent == null)
                        {
                            this.manualResetEvent = new ManualResetEvent(true);
                        }
                    }

                    return this.manualResetEvent;
                }
            }

            public bool CompletedSynchronously
            {
                get
                {
                    return true;
                }
            }

            public bool IsCompleted
            {
                get
                {
                    return true;
                }
            }

            object ThisLock
            {
                get
                {
                    return this.thisLock;
                }
            }
        }
    }
}