Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Activities/System/Activities/ActivityContext.cs

@@ -0,0 +1,450 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//-----------------------------------------------------------------------------
+
+namespace System.Activities
+{
+    using System;
+    using System.Activities.Runtime;
+    using System.Activities.Tracking;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Runtime;
+
+    [Fx.Tag.XamlVisible(false)]
+    public class ActivityContext
+    {
+        ActivityInstance instance;
+        ActivityExecutor executor;
+        bool isDisposed;
+        long instanceId;
+
+        // Used by subclasses that are pooled.
+        internal ActivityContext()
+        {
+        }
+
+        // these can only be created by the WF Runtime
+        internal ActivityContext(ActivityInstance instance, ActivityExecutor executor)
+        {
+            Fx.Assert(instance != null, "valid activity instance is required");
+
+            this.instance = instance;
+            this.executor = executor;
+            this.Activity = this.instance.Activity;
+            this.instanceId = instance.InternalId;
+        }
+
+        internal LocationEnvironment Environment
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return this.instance.Environment;
+            }
+        }
+
+        internal bool AllowChainedEnvironmentAccess
+        {
+            get;
+            set;
+        }
+
+        internal Activity Activity
+        {
+            get;
+            private set;
+        }
+
+        internal ActivityInstance CurrentInstance
+        {
+            get
+            {
+                return this.instance;
+            }
+        }
+
+        internal ActivityExecutor CurrentExecutor
+        {
+            get
+            {
+                return this.executor;
+            }
+        }
+
+        public string ActivityInstanceId
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return this.instanceId.ToString(CultureInfo.InvariantCulture);
+            }
+        }
+
+        public Guid WorkflowInstanceId
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return this.executor.WorkflowInstanceId;
+            }
+        }
+
+        public WorkflowDataContext DataContext
+        {
+            get
+            {
+                ThrowIfDisposed();
+
+                // Argument expressions don't have visbility into public variables at the same scope.
+                // However fast-path expressions use the parent's ActivityInstance instead of
+                // creating their own, so we need to give them a DataContext without variables
+                bool includeLocalVariables = !this.instance.IsResolvingArguments;
+
+                if (this.instance.DataContext == null ||
+                    this.instance.DataContext.IncludesLocalVariables != includeLocalVariables)
+                {
+                    this.instance.DataContext
+                        = new WorkflowDataContext(this.executor, this.instance, includeLocalVariables);
+                }
+
+                return this.instance.DataContext;
+            }
+        }
+
+        internal bool IsDisposed
+        {
+            get
+            {
+                return this.isDisposed;
+            }
+        }
+
+        public T GetExtension<T>()
+            where T : class
+        {
+            ThrowIfDisposed();
+            return this.executor.GetExtension<T>();
+        }
+
+        internal Location GetIgnorableResultLocation(RuntimeArgument resultArgument)
+        {
+            return this.executor.GetIgnorableResultLocation(resultArgument);
+        }
+
+        internal void Reinitialize(ActivityInstance instance, ActivityExecutor executor)
+        {
+            Reinitialize(instance, executor, instance.Activity, instance.InternalId);
+        }
+
+        internal void Reinitialize(ActivityInstance instance, ActivityExecutor executor, Activity activity, long instanceId)
+        {
+            this.isDisposed = false;
+            this.instance = instance;
+            this.executor = executor;
+            this.Activity = activity;
+            this.instanceId = instanceId;
+        }
+
+        // extra insurance against misuse (if someone stashes away the execution context to use later)
+        internal void Dispose()
+        {
+            this.isDisposed = true;
+            this.instance = null;
+            this.executor = null;
+            this.Activity = null;
+            this.instanceId = 0;
+        }
+
+        internal void DisposeDataContext()
+        {
+            if (this.instance.DataContext != null)
+            {
+                this.instance.DataContext.DisposeEnvironment();
+                this.instance.DataContext = null;
+            }
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        public Location<T> GetLocation<T>(LocationReference locationReference)
+        {
+            ThrowIfDisposed();
+
+            if (locationReference == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("locationReference");
+            }
+
+            Location location = locationReference.GetLocation(this);
+
+            Location<T> typedLocation = location as Location<T>;
+
+            if (typedLocation != null)
+            {
+                return typedLocation;
+            }
+            else
+            {
+                Fx.Assert(location != null, "The contract of LocationReference is that GetLocation never returns null.");
+
+                if (locationReference.Type == typeof(T))
+                {
+                    return new TypedLocationWrapper<T>(location);
+                }
+                else
+                {
+                    throw FxTrace.Exception.AsError(new InvalidOperationException(SR.LocationTypeMismatch(locationReference.Name, typeof(T), locationReference.Type)));
+                }
+            }
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        public T GetValue<T>(LocationReference locationReference)
+        {
+            ThrowIfDisposed();
+
+            if (locationReference == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("locationReference");
+            }
+
+            return GetValueCore<T>(locationReference);
+        }
+
+        internal T GetValueCore<T>(LocationReference locationReference)
+        {
+            Location location = locationReference.GetLocationForRead(this);
+
+            Location<T> typedLocation = location as Location<T>;
+
+            if (typedLocation != null)
+            {
+                // If we hit this path we can avoid boxing value types
+                return typedLocation.Value;
+            }
+            else
+            {
+                Fx.Assert(location != null, "The contract of LocationReference is that GetLocation never returns null.");
+
+                return TypeHelper.Convert<T>(location.Value);
+            }
+        }
+
+        public void SetValue<T>(LocationReference locationReference, T value)
+        {
+            ThrowIfDisposed();
+
+            if (locationReference == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("locationReference");
+            }
+
+            SetValueCore<T>(locationReference, value);
+        }
+
+        internal void SetValueCore<T>(LocationReference locationReference, T value)
+        {
+            Location location = locationReference.GetLocationForWrite(this);
+
+            Location<T> typedLocation = location as Location<T>;
+
+            if (typedLocation != null)
+            {
+                // If we hit this path we can avoid boxing value types
+                typedLocation.Value = value;
+            }
+            else
+            {
+
+                if (!TypeHelper.AreTypesCompatible(value, locationReference.Type))
+                {
+                    throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CannotSetValueToLocation(value != null ? value.GetType() : typeof(T), locationReference.Name, locationReference.Type)));
+                }
+
+                location.Value = value;
+            }
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "Generic needed for type inference")]
+        public T GetValue<T>(OutArgument<T> argument)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("argument");
+            }
+
+            argument.ThrowIfNotInTree();
+
+            return GetValueCore<T>(argument.RuntimeArgument);
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "Generic needed for type inference")]
+        public T GetValue<T>(InOutArgument<T> argument)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("argument");
+            }
+
+            argument.ThrowIfNotInTree();
+
+            return GetValueCore<T>(argument.RuntimeArgument);
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "Generic needed for type inference")]
+        public T GetValue<T>(InArgument<T> argument)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("argument");
+            }
+
+            argument.ThrowIfNotInTree();
+
+            return GetValueCore<T>(argument.RuntimeArgument);
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        public object GetValue(Argument argument)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("argument");
+            }
+
+            argument.ThrowIfNotInTree();
+
+            return GetValueCore<object>(argument.RuntimeArgument);
+        }
+
+        // Soft-Link: This method is referenced through reflection by
+        // ExpressionUtilities.TryRewriteLambdaExpression.  Update that
+        // file if the signature changes.
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "We explicitly provide a RuntimeArgument overload to avoid requiring the object type parameter.")]
+        public object GetValue(RuntimeArgument runtimeArgument)
+        {
+            ThrowIfDisposed();
+
+            if (runtimeArgument == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("runtimeArgument");
+            }
+
+            return GetValueCore<object>(runtimeArgument);
+        }
+
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "Generic needed for type inference")]
+        public void SetValue<T>(OutArgument<T> argument, T value)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                // We want to shortcut if the argument is null
+                return;
+            }
+
+            argument.ThrowIfNotInTree();
+
+            SetValueCore(argument.RuntimeArgument, value);
+        }
+
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "Generic needed for type inference")]
+        public void SetValue<T>(InOutArgument<T> argument, T value)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                // We want to shortcut if the argument is null
+                return;
+            }
+
+            argument.ThrowIfNotInTree();
+
+            SetValueCore(argument.RuntimeArgument, value);
+        }
+
+        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
+            Justification = "Generic needed for type inference")]
+        public void SetValue<T>(InArgument<T> argument, T value)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                // We want to shortcut if the argument is null
+                return;
+            }
+
+            argument.ThrowIfNotInTree();
+
+            SetValueCore(argument.RuntimeArgument, value);
+        }
+
+        public void SetValue(Argument argument, object value)
+        {
+            ThrowIfDisposed();
+
+            if (argument == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("argument");
+            }
+
+            argument.ThrowIfNotInTree();
+
+            SetValueCore(argument.RuntimeArgument, value);
+        }
+
+        internal void TrackCore(CustomTrackingRecord record)
+        {
+            Fx.Assert(!this.isDisposed, "not usable if disposed");
+            Fx.Assert(record != null, "expect non-null record");
+
+            if (this.executor.ShouldTrack)
+            {
+                record.Activity = new ActivityInfo(this.instance);
+                record.InstanceId = this.WorkflowInstanceId;
+                this.executor.AddTrackingRecord(record);
+            }
+        }
+
+        internal void ThrowIfDisposed()
+        {
+            if (this.isDisposed)
+            {
+                throw FxTrace.Exception.AsError(
+                    new ObjectDisposedException(this.GetType().FullName, SR.AECDisposed));
+            }
+        }
+    }
+}