Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Activities/Microsoft/VisualBasic/Activities/VisualBasicValue.cs

@@ -0,0 +1,151 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//-----------------------------------------------------------------------------
+
+namespace Microsoft.VisualBasic.Activities
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Activities;
+    using System.Activities.Expressions;
+    using System.Activities.ExpressionParser;
+    using System.Activities.XamlIntegration;
+    using System.Linq.Expressions;
+    using System.Windows.Markup;
+    using System.ComponentModel;
+    using System.Runtime;
+
+    [DebuggerStepThrough]
+    public sealed class VisualBasicValue<TResult> : CodeActivity<TResult>, IValueSerializableExpression, IExpressionContainer, ITextExpression
+    {
+        Expression<Func<ActivityContext, TResult>> expressionTree;
+        Func<ActivityContext, TResult> compiledExpression;
+        CompiledExpressionInvoker invoker; 
+
+        public VisualBasicValue() 
+            : base()
+        {
+            this.UseOldFastPath = true;
+        }
+
+        public VisualBasicValue(string expressionText)
+            : this()
+        {
+            this.ExpressionText = expressionText;
+        }
+
+        public string ExpressionText
+        {
+            get;
+            set;
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public string Language
+        {
+            get
+            {
+                return VisualBasicHelper.Language;
+            }
+        }
+
+        public bool RequiresCompilation
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        protected override TResult Execute(CodeActivityContext context)
+        {
+            if (!this.invoker.IsStaticallyCompiled)
+            {
+                if (this.expressionTree != null)
+                {
+                    if (this.compiledExpression == null)
+                    {
+                        this.compiledExpression = this.expressionTree.Compile();
+                    }
+                    return this.compiledExpression(context);
+                }
+                else
+                {
+                    return default(TResult);
+                }
+            }
+            else
+            {
+                return (TResult)this.invoker.InvokeExpression(context);
+            }
+        }
+
+        protected override void CacheMetadata(CodeActivityMetadata metadata)
+        {
+            this.expressionTree = null;
+            this.invoker = new CompiledExpressionInvoker(this, false, metadata);
+            if (this.invoker.IsStaticallyCompiled == true)
+            {
+                return;
+            }
+
+            // If ICER is not implemented that means we haven't been compiled
+
+            CodeActivityPublicEnvironmentAccessor publicAccessor = CodeActivityPublicEnvironmentAccessor.Create(metadata);            
+            try
+            {
+                this.expressionTree = VisualBasicHelper.Compile<TResult>(this.ExpressionText, publicAccessor, false);
+            }
+            catch (SourceExpressionException e)
+            {
+                metadata.AddValidationError(e.Message);
+            }
+        }
+
+        public bool CanConvertToString(IValueSerializerContext context)
+        {
+            // we can always convert to a string 
+            return true;
+        }
+
+        public string ConvertToString(IValueSerializerContext context)
+        {
+            // Return our bracket-escaped text
+            return "[" + this.ExpressionText + "]";
+        }
+
+        public Expression GetExpressionTree()
+        {            
+            if (this.IsMetadataCached)
+            {
+                if (this.expressionTree == null)
+                {
+                    // it's safe to create this CodeActivityMetadata here,
+                    // because we know we are using it only as lookup purpose.
+                    CodeActivityMetadata metadata = new CodeActivityMetadata(this, this.GetParentEnvironment(), false);
+                    CodeActivityPublicEnvironmentAccessor publicAccessor = CodeActivityPublicEnvironmentAccessor.CreateWithoutArgument(metadata);
+                    try
+                    {                                                
+                        this.expressionTree = VisualBasicHelper.Compile<TResult>(this.ExpressionText, publicAccessor, false);
+                    }
+                    catch (SourceExpressionException e)
+                    {
+                        throw FxTrace.Exception.AsError(new InvalidOperationException(SR.VBExpressionTamperedSinceLastCompiled(e.Message))); 
+                    }
+                    finally
+                    {
+                        metadata.Dispose();
+                    }                   
+                }
+
+                Fx.Assert(this.expressionTree.NodeType == ExpressionType.Lambda, "Lambda expression required");
+                return ExpressionUtilities.RewriteNonCompiledExpressionTree((LambdaExpression)this.expressionTree);
+            }
+            else
+            {
+                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.ActivityIsUncached)); 
+            }
+        }
+    }
+}