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); } }