private Expression <Func <ActivityContext, TResult> > CompileLocationExpression(CodeActivityPublicEnvironmentAccessor publicAccessor, out string validationError)
{
Expression <Func <ActivityContext, TResult> > expressionTreeToReturn = null;
validationError = null;
try
{
expressionTreeToReturn = VisualBasicHelper.Compile <TResult>(this.ExpressionText, publicAccessor, true);
// inspect the expressionTree to see if it is a valid location expression(L-value)
string extraErrorMessage = null;
if (!publicAccessor.ActivityMetadata.HasViolations && (expressionTreeToReturn == null || !ExpressionUtilities.IsLocation(expressionTreeToReturn, typeof(TResult), out extraErrorMessage)))
{
string errorMessage = SR.InvalidLValueExpression;
if (extraErrorMessage != null)
{
errorMessage += ":" + extraErrorMessage;
}
expressionTreeToReturn = null;
validationError = SR.CompilerErrorSpecificExpression(this.ExpressionText, errorMessage);
}
}
catch (SourceExpressionException e)
{
validationError = e.Message;
}
return(expressionTreeToReturn);
}
public static Expression <Func <ActivityContext, T> > Compile <T>(string expressionText, CodeActivityMetadata metadata)
{
HashSet <VisualBasicImportReference> allImportReferences = GetAllImportReferences(metadata.Environment.Root);
VisualBasicHelper helper = new VisualBasicHelper(expressionText);
HashSet <AssemblyName> refAssemNames = new HashSet <AssemblyName>();
HashSet <string> namespaceImportsNames = new HashSet <string>();
foreach (VisualBasicImportReference reference in allImportReferences)
{
if (reference.EarlyBoundAssembly != null)
{
namespaceImportsNames.Add(reference.Import);
if (helper.referencedAssemblies == null)
{
helper.referencedAssemblies = new HashSet <Assembly>();
}
helper.referencedAssemblies.Add(reference.EarlyBoundAssembly);
}
else
{
if (reference.AssemblyName != null)
{
refAssemNames.Add(reference.AssemblyName);
}
namespaceImportsNames.Add(reference.Import);
}
}
helper.Initialize(refAssemNames, namespaceImportsNames);
return(helper.Compile <T>(metadata));
}
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));
}
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
this.expressionTree = null;
try
{
this.expressionTree = VisualBasicHelper.Compile <TResult>(this.ExpressionText, metadata);
}
catch (SourceExpressionException exception)
{
metadata.AddValidationError(exception.Message);
}
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
expressionTree = null;
invoker = new CompiledExpressionInvoker(this, false, metadata);
if (metadata.Environment.CompileExpressions)
{
return;
}
// If ICER is not implemented that means we haven't been compiled
var publicAccessor = CodeActivityPublicEnvironmentAccessor.Create(metadata);
try
{
expressionTree = VisualBasicHelper.Compile <TResult>(this.ExpressionText, publicAccessor, false);
}
catch (SourceExpressionException e)
{
metadata.AddValidationError(e.Message);
}
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
this.expressionTree = null;
try
{
this.expressionTree = VisualBasicHelper.Compile <TResult>(this.ExpressionText, metadata);
string extraErrorMessage = null;
if (!metadata.HasViolations && ((this.expressionTree == null) || !ExpressionUtilities.IsLocation(this.expressionTree, typeof(TResult), out extraErrorMessage)))
{
string invalidLValueExpression = System.Activities.SR.InvalidLValueExpression;
if (extraErrorMessage != null)
{
invalidLValueExpression = invalidLValueExpression + ":" + extraErrorMessage;
}
this.expressionTree = null;
metadata.AddValidationError(System.Activities.SR.CompilerErrorSpecificExpression(this.ExpressionText, invalidLValueExpression));
}
}
catch (SourceExpressionException exception)
{
metadata.AddValidationError(exception.Message);
}
}
