private static void AttachNewInstance(Type compiledResultType, DynamicActivity dynamicActivity)
{
/*
* https://docs.microsoft.com/en-us/dotnet/framework/windows-workflow-foundation/csharp-expressions
*/
// Create an instance of the new compiled expression type.
ICompiledExpressionRoot
compiledExpressionRoot =
Activator
.CreateInstance
(
compiledResultType
, new object[]
{
dynamicActivity
}
) as ICompiledExpressionRoot;
// Attach it to the activity.
CompiledExpressionInvoker
.SetCompiledExpressionRootForImplementation
(
dynamicActivity
, compiledExpressionRoot
);
}
static void CompileExpressions(DynamicActivity dynamicActivity)
{
var activityName = dynamicActivity.Name;
var activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot";
var activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
var settings = new TextExpressionCompilerSettings
{
Activity = dynamicActivity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = "CSharpExpression",
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = true
};
var results = new TextExpressionCompiler(settings).Compile();
if (results.HasErrors)
{
throw new Exception("Compilation failed.");
}
var compiledExpressionRoot = Activator.CreateInstance(results.ResultType, new object[] { dynamicActivity }) as ICompiledExpressionRoot;
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpressionRoot);
}
private ICompiledExpressionRoot GetCompiledExpressionRoot()
{
if (this.rootInstance != null && this.rootInstance.Activity != null)
{
ICompiledExpressionRoot compiledExpressionRoot;
Activity rootActivity = this.rootInstance.Activity;
if (QualifiedId.TryGetElementFromRoot(rootActivity, this.compiledRootActivityQualifiedId, out Activity compiledRootActivity) &&
QualifiedId.TryGetElementFromRoot(rootActivity, this.expressionActivityQualifiedId, out Activity expressionActivity))
{
if (CompiledExpressionInvoker.TryGetCompiledExpressionRoot(expressionActivity, compiledRootActivity, out compiledExpressionRoot))
{
//
// Revalidate to make sure we didn't hit an ID shift
if (compiledExpressionRoot.CanExecuteExpression(this.expressionText, true /* this is always a reference */, this.locationReferences, out this.expressionId))
{
return(compiledExpressionRoot);
}
}
}
//
// We were valid when this location was generated so an ID shift occurred (likely due to a dynamic update)
// Need to search all of the ICERs for one that can execute this expression.
if (FindCompiledExpressionRoot(rootActivity, out compiledExpressionRoot))
{
return(compiledExpressionRoot);
}
}
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UnableToLocateCompiledLocationContext(this.expressionText)));
}
public static void CompileExpressions(DynamicActivity dynamicActivity, params Assembly[] references)
{
// See https://docs.microsoft.com/en-us/dotnet/framework/windows-workflow-foundation/csharp-expressions
string activityName = dynamicActivity.Name;
string activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot";
string activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
TextExpressionCompilerSettings settings = new TextExpressionCompilerSettings
{
Activity = dynamicActivity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = null,
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = true
};
// add assembly references
TextExpression.SetReferencesForImplementation(dynamicActivity, references.Select(a => (AssemblyReference)a).ToList());
// Compile the C# expression.
var results = new TextExpressionCompiler(settings).Compile();
if (results.HasErrors)
{
throw new Exception("Compilation failed.");
}
// attach compilation result to live activity
var compiledExpression = (ICompiledExpressionRoot)Activator.CreateInstance(results.ResultType, new object[] { dynamicActivity });
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpression);
}
public void SetCompiledExpressionRootForImplementation()
{
var writeLine = new WriteLine {
Text = new InArgument <string>(new VisualBasicValue <string>("[s]"))
};
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(writeLine, new Expressions());
WorkflowInvoker.Invoke(writeLine);
}
static void CreateCompiledActivity(DynamicActivity dynamicActivity, Type resultType)
{
ICompiledExpressionRoot compiledExpressionRoot =
Activator.CreateInstance(resultType,
new Object[] { dynamicActivity }) as ICompiledExpressionRoot;
// Attach it to the activity.
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(
dynamicActivity, compiledExpressionRoot);
}
/// <summary>
/// Compile the Expressions in workflow
/// </summary>
/// <param name="id">The workflow Id</param>
/// <param name="activity">The workflow activity for build the expressions</param>
static void CompileExpressions(string id, Activity activity)
{
Type t = GetType(id, activity);
ICompiledExpressionRoot compiledExpressionRoot =
Activator.CreateInstance(t,
new object[] { activity }) as ICompiledExpressionRoot;
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(
activity, compiledExpressionRoot);
}
// NOTE : Static method here causes memory leak in the TextExpressioncCompiler ;)
void CompileExpressionsImpl(Activity dynamicActivity, Guid resourceID)
{
// http://msdn.microsoft.com/en-us/library/jj591618.aspx
// activity.Name is the Namespace.Type of the activity that contains the C# expressions.
// activity.Name must be in the form Namespace.Type
string activityName = ToNamespaceTypeString(dynamicActivity.GetType());
// Split activityName into Namespace and Type and append _CompiledExpressionRoot to the type name to represent
// the new type that represents the compiled expressions. Take everything after the last . for the type name.
var activityType = activityName.Replace(" ", "_").Split('.').Last() + "_CompiledExpressionRoot";
// Take everything before the last . for the namespace.
var activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
var settings = new TextExpressionCompilerSettings
{
Activity = dynamicActivity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = null,
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = true
};
TextExpressionCompilerResults results;
if (Resultscache.ContainsKey(resourceID))
{
results = Resultscache[resourceID];
}
//// Compile the C# expression.
else
{
var compiler = new TextExpressionCompiler(settings);
results = compiler.Compile(); // Nasty MS memory leak ;(
Resultscache.TryAdd(resourceID, results);
}
if (results.HasErrors)
{
var err = new StringBuilder("Compilation failed.\n");
foreach (var message in results.CompilerMessages)
{
err.AppendFormat("{0} : {1} ({2}) --> {3}\n", message.Number, message.IsWarning ? "WARNING" : "ERROR ", message.SourceLineNumber, message.Message);
}
throw new Exception(err.ToString());
}
var compiledExpressionRoot = Activator.CreateInstance(results.ResultType, dynamicActivity) as ICompiledExpressionRoot;
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpressionRoot);
}
static Type CompileExpressions(DynamicActivity dynamicActivity)
{
// activityName is the Namespace.Type of the activity that contains the
// C# expressions. For Dynamic Activities this can be retrieved using the
// name property , which must be in the form Namespace.Type.
String activityName = dynamicActivity.Name;
// Split activityName into Namespace and Type.Append _CompiledExpressionRoot to the type name
// to represent the new type that represents the compiled expressions.
// Take everything after the last . for the type name.
String activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot";
// Take everything before the last . for the namespace.
String activityNamespace = String.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
// Create a TextExpressionCompilerSettings.
TextExpressionCompilerSettings settings = new TextExpressionCompilerSettings
{
Activity = dynamicActivity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = null,
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = true
};
// Compile the C# expression.
TextExpressionCompilerResults results =
new TextExpressionCompiler(settings).Compile();
// Any compilation errors are contained in the CompilerMessages.
if (results.HasErrors)
{
throw new Exception("Compilation failed.");
}
// Create an instance of the new compiled expression type.
ICompiledExpressionRoot compiledExpressionRoot =
Activator.CreateInstance(results.ResultType,
new Object[] { dynamicActivity }) as ICompiledExpressionRoot;
// Attach it to the activity.
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(
dynamicActivity, compiledExpressionRoot);
return(results.ResultType);
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
expressionTree = null;
invoker = new CompiledExpressionInvoker(this, true, metadata);
if (metadata.Environment.CompileExpressions)
{
return;
}
string validationError;
// If ICER is not implemented that means we haven't been compiled
var publicAccessor = CodeActivityPublicEnvironmentAccessor.Create(metadata);
expressionTree = CompileLocationExpression(publicAccessor, out validationError);
if (validationError != null)
{
metadata.AddValidationError(validationError);
}
}
public void WorkflowHelperCompileExpressionsWithActivityExpectedCompilesExpressionsAddsToCacheThenInvalidate()
{
const string ExpressionParams = "(\"\",AmbientDataList)";
var fsa = new DsfFlowSwitchActivity
{
ExpressionText = GlobalConstants.InjectedSwitchDataFetchOld + ExpressionParams
};
var fda = new DsfFlowDecisionActivity
{
ExpressionText = GlobalConstants.InjectedDecisionHandlerOld + ExpressionParams
};
var startNode = new FlowStep {
Action = new CommentActivityForTest()
};
var chart = new Flowchart {
StartNode = startNode
};
chart.Nodes.Add(startNode);
chart.Nodes.Add(new FlowDecision(fda));
chart.Nodes.Add(new FlowSwitch <string> {
Expression = fsa
});
var workflow = new DynamicActivity
{
Implementation = () => chart
};
var guid = Guid.NewGuid();
new WorkflowHelper().CompileExpressions(workflow, guid);
// No exception thrown means compilation worked
var compiledExpressionRoot = CompiledExpressionInvoker.GetCompiledExpressionRootForImplementation(workflow) as ICompiledExpressionRoot;
Assert.AreEqual(GlobalConstants.Resultscache.Count, 1);
GlobalConstants.InvalidateCache(guid);
Assert.AreEqual(GlobalConstants.Resultscache.Count, 0);
Assert.IsNotNull(compiledExpressionRoot);
}
private static void Compile(IDynamicActivity dynamicActivity, LocationReferenceEnvironment environment)
{
#if NET45
string language = null;
if (RequiresCompilation(dynamicActivity, environment, out language))
{
TextExpressionCompiler compiler = new TextExpressionCompiler(GetCompilerSettings(dynamicActivity, language));
TextExpressionCompilerResults results = compiler.Compile();
if (results.HasErrors)
{
StringBuilder messages = new StringBuilder();
messages.Append("\r\n");
messages.Append("\r\n");
foreach (TextExpressionCompilerError message in results.CompilerMessages)
{
messages.Append("\t");
if (results.HasSourceInfo)
{
messages.Append(string.Concat(" ", SR.ActivityXamlServiceLineString, " ", message.SourceLineNumber, ": "));
}
messages.Append(message.Message);
}
messages.Append("\r\n");
messages.Append("\r\n");
InvalidOperationException exception = new InvalidOperationException(SR.ActivityXamlServicesCompilationFailed(messages.ToString()));
foreach (TextExpressionCompilerError message in results.CompilerMessages)
{
exception.Data.Add(message, message.Message);
}
throw FxTrace.Exception.AsError(exception);
}
Type compiledExpressionRootType = results.ResultType;
ICompiledExpressionRoot compiledExpressionRoot = Activator.CreateInstance(compiledExpressionRootType, new object[] { dynamicActivity }) as ICompiledExpressionRoot;
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpressionRoot);
}
#endif
}
private static void Compile(IDynamicActivity dynamicActivity, ActivityXamlServicesSettings settings)
{
string language = null;
if (!RequiresCompilation(dynamicActivity, settings.LocationReferenceEnvironment, out language))
{
return;
}
var cSharpCompiler = settings.CSharpCompiler ?? new CSharpAheadOfTimeCompiler();
var compiler = new TextExpressionCompiler(GetCompilerSettings(dynamicActivity, language, cSharpCompiler));
var results = compiler.Compile();
if (results.HasErrors())
{
var messages = new StringBuilder();
messages.Append("\r\n");
messages.Append("\r\n");
foreach (TextExpressionCompilerError message in results.CompilerMessages)
{
messages.Append("\t");
messages.Append(string.Concat(" ", SR.ActivityXamlServiceLineString, " ", message.SourceLineNumber, ": "));
messages.Append(message.Message);
}
messages.Append("\r\n");
messages.Append("\r\n");
InvalidOperationException exception = new InvalidOperationException(SR.ActivityXamlServicesCompilationFailed(messages.ToString()));
foreach (TextExpressionCompilerError message in results.CompilerMessages)
{
exception.Data.Add(message, message.Message);
}
throw FxTrace.Exception.AsError(exception);
}
Type compiledExpressionRootType = results.ResultType;
ICompiledExpressionRoot compiledExpressionRoot = Activator.CreateInstance(compiledExpressionRootType, new object[] { dynamicActivity }) as ICompiledExpressionRoot;
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpressionRoot);
}
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);
}
}
static WorkflowService CreatetWorkflowServiceAndSetCompiledExpressionRoot(string supportedVersionXamlxfilePath, Stream activityStream, XName defaultServiceName)
{
WorkflowService service = CreatetWorkflowService(activityStream, defaultServiceName);
if (service != null)
{
// CompiledExpression is not supported on Configuration Based Activation (CBA) scenario.
if (ServiceHostingEnvironment.IsHosted && !ServiceHostingEnvironment.IsConfigurationBased)
{
// We use ServiceHostingEnvironment.FullVirtualPath (instead of the constructor string) because we’re passing this path to BuildManager,
// which may not understand the file type referenced by the constructor string (e.g. .xaml).
ICompiledExpressionRoot expressionRoot = XamlBuildProviderExtension.GetExpressionRoot(supportedVersionXamlxfilePath, service, ServiceHostingEnvironment.FullVirtualPath);
if (expressionRoot != null)
{
CompiledExpressionInvoker.SetCompiledExpressionRoot(service.Body, expressionRoot);
}
}
}
return(service);
}
private bool FindCompiledExpressionRoot(Activity activity, out ICompiledExpressionRoot compiledExpressionRoot)
{
if (CompiledExpressionInvoker.TryGetCompiledExpressionRoot(activity, this.forImplementation, out compiledExpressionRoot))
{
if (compiledExpressionRoot.CanExecuteExpression(this.expressionText, true /* this is always a reference */, this.locationReferences, out this.expressionId))
{
return(true);
}
}
foreach (Activity containedActivity in WorkflowInspectionServices.GetActivities(activity))
{
if (FindCompiledExpressionRoot(containedActivity, out compiledExpressionRoot))
{
return(true);
}
}
compiledExpressionRoot = null;
return(false);
}
private static void AttachNewInstance(Type compiledResultType, DynamicActivity dynamicActivity)
{
// Create an instance of the new compiled expression type.
ICompiledExpressionRoot
compiledExpressionRoot =
Activator
.CreateInstance
(
compiledResultType
, new object[]
{
dynamicActivity
}
) as ICompiledExpressionRoot;
// Attach it to the activity.
CompiledExpressionInvoker
.SetCompiledExpressionRootForImplementation
(
dynamicActivity
, compiledExpressionRoot
);
}
private static void Compile(Activity activity)
{
string activityName = activity.GetType().ToString();
string activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot";
string activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
var settings = new TextExpressionCompilerSettings
{
Activity = activity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = null,
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = false,
#if NET5_0
Compiler = new CSharpAotCompiler()
#endif
};
var results = new TextExpressionCompiler(settings).Compile();
if (results.HasErrors)
{
foreach (var m in results.CompilerMessages)
{
System.Diagnostics.Debug.WriteLine(m.Message);
}
throw new Exception("Compilation failed.");
}
var compiledExpressionRoot = Activator.CreateInstance(results.ResultType, new object[] { activity }) as ICompiledExpressionRoot;
CompiledExpressionInvoker.SetCompiledExpressionRoot(activity, compiledExpressionRoot);
}
static void CompileExpressions(Activity activity)
{
// activityName is the Namespace.Type of the activity that contains the C# expressions.
var activityName = activity.GetType().ToString();
// Split activityName into Namespace and Type.Append _CompiledExpressionRoot to the type name
// to represent the new type that represents the compiled expressions.
// Take everything after the last . for the type name.
var activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot";
// Take everything before the last . for the namespace.
var activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
// Create a TextExpressionCompilerSettings.
var settings = new TextExpressionCompilerSettings {
Activity = activity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = null,
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = false
};
// Compile the C# expression.
var results =
new TextExpressionCompiler(settings).Compile();
// Any compilation errors are contained in the CompilerMessages.
if (results.HasErrors)
{
throw new Exception("Compilation failed.");
}
// Create an instance of the new compiled expression type.
var compiledExpressionRoot = Activator.CreateInstance(results.ResultType, new object[] { activity }) as ICompiledExpressionRoot;
// Attach it to the activity.
CompiledExpressionInvoker.SetCompiledExpressionRoot(activity, compiledExpressionRoot);
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
this.invoker = new CompiledExpressionInvoker(this, false, metadata);
}
public void Compile(string activityNamespace, string activityName, Activity activity, bool forImplementation = true)
{
if (_refAssemblies != null)
{
var references = _refAssemblies.Select(a => new AssemblyReference {
Assembly = a
}).ToArray();
if (!forImplementation)
{
TextExpression.SetReferences(activity, references);
}
else
{
TextExpression.SetReferencesForImplementation(activity, references);
}
}
if (_usingNamespaces != null)
{
var namespaces = _usingNamespaces.ToArray();
if (!forImplementation)
{
TextExpression.SetNamespaces(activity, namespaces);
}
else
{
TextExpression.SetNamespacesForImplementation(activity, namespaces);
}
}
var settings = new TextExpressionCompilerSettings
{
Activity = activity,
Language = "C#",
ActivityName = activityName,
ActivityNamespace = activityNamespace,
RootNamespace = "dd",
GenerateAsPartialClass = false,
AlwaysGenerateSource = false,
ForImplementation = forImplementation,
Compiler = new CSharpAheadOfTimeCompiler(),
};
var results = new TextExpressionCompiler(settings).Compile();
if (results.HasErrors)
{
throw new Exception("Compilation failed.");
}
if (results.ResultType == null)
{
return;
}
var compiledExpressionRoot =
Activator.CreateInstance(results.ResultType, activity) as ICompiledExpressionRoot;
if (!forImplementation)
{
CompiledExpressionInvoker.SetCompiledExpressionRoot(activity, compiledExpressionRoot);
}
else
{
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(activity, compiledExpressionRoot);
}
}
