WF4:如何计算仅在运行时已知的表达式

我最终使用了以下活动。它无法访问工作流的变量，而是接受单个参数"Value"，该参数可在动态表达式中由相同名称使用。除此之外，它工作得很好。

public class Evaluate<TIn, TOut> : NativeActivity<TOut>
{
    [RequiredArgument]
    public InArgument<string> ExpressionText { get; set; }
    [RequiredArgument]
    public InArgument<TIn> Value { get; set; }
    protected override void Execute(NativeActivityContext context)
    {
        var result = new ExpressionEvaluator<TIn, TOut>(ExpressionText.Get(context)).EvalWith(Value.Get(context));
        Result.Set(context, result);
    }
}
public class ExpressionEvaluator<TIn, TOut> : Activity<TOut>
{
    [RequiredArgument]
    public InArgument<TIn> Value { get; set; }
    public ExpressionEvaluator(string predicate)
    {
        VisualBasic.SetSettingsForImplementation(this, VbSettings);
        Implementation = () => new Assign<TOut>
        {
            Value = new InArgument<TOut>(new VisualBasicValue<TOut>(predicate)),
            To = new ArgumentReference<TOut>("Result")
        };
    }
    public TOut EvalWith(TIn value)
    {
        return WorkflowInvoker.Invoke(this, new Dictionary<string, object> { { "Value", value } });
    }
    private static readonly VisualBasicSettings VbSettings;
    static ExpressionEvaluator()
    {
        VbSettings = new VisualBasicSettings();
        AddImports(typeof(TIn), VbSettings.ImportReferences);
        AddImports(typeof(TOut), VbSettings.ImportReferences);
    }
    private static void AddImports(Type type, ISet<VisualBasicImportReference> imports)
    {
        if (type.IsPrimitive || type == typeof(void) || type.Namespace == "System")
            return;
        var wasAdded = imports.Add(new VisualBasicImportReference { Assembly = type.Assembly.GetName().Name, Import = type.Namespace });
        if (!wasAdded)
            return;
        if (type.BaseType != null)
            AddImports(type.BaseType, imports); 
        foreach (var interfaceType in type.GetInterfaces())
            AddImports(interfaceType, imports);
        foreach (var property in type.GetProperties())
            AddImports(property.PropertyType, imports);
        foreach (var method in type.GetMethods())
        {
            AddImports(method.ReturnType, imports);
            foreach (var parameter in method.GetParameters())
                AddImports(parameter.ParameterType, imports);
            if (method.IsGenericMethod)
            {
                foreach (var genericArgument in method.GetGenericArguments())
                    AddImports(genericArgument, imports);
            }
        }
        if (type.IsGenericType)
        {
            foreach (var genericArgument in type.GetGenericArguments())
                AddImports(genericArgument, imports);
        }
    }
}

编辑：更新了类以包括完整的程序集和命名空间导入，以免您收到可怕的（和无用的）错误消息：

未声明"值"。由于其保护级别，它可能无法访问。

此外，将 ExpressionEvaluator 类移到外部并使其公开，以便可以在 WF 外部使用它，如下所示：

new ExpressionEvaluator<int, double>("Value * Math.PI").EvalWith(2);

这将返回：

6.28318530717959

我建议为此使用不同的框架。一个好的方法是使用nCalc。

http://ncalc.codeplex.com/它可以解析任何表达式并计算结果，包括静态或动态参数和自定义函数。

我们使用它在运行时评估不同类型的表达式。

如果你的"谓词"是一个众所周知的字符串，并且不需要是运行时计算的表达式，你当然可以做这样的事情，扔掉InArgument并避免构造函数：

public class Eval<T, TResult> : Activity<TResult>
{
    public string Expression { get; set; }
    [RequiredArgument]
    public InArgument<T> Value { get; set; }
    protected override Func<Activity> Implementation
    {
        get
        {
            if (string.IsNullOrEmpty(Expression))
            {
                return base.Implementation;
            }
            return () => new Assign<TResult>
            {
                Value = new InArgument<TResult>(new VisualBasicValue<TResult>(Expression)),
                To = new ArgumentReference<TResult>("Result")
            };
        }
        set
        {
            throw new NotSupportedException();
        }
    }
}

并这样称呼它：

var activity = new Eval<int, int>() { Expression = "Value + 2" };
var inputArgs = new Dictionary<string, object>()
{
    { "Value", 5 }
};
Console.WriteLine("RESULT: " + WorkflowInvoker.Invoke<int>(activity, inputArgs));

编辑：检查即使没有Predicate.ExpressionText注释，它也没有效果：

public class NativeEval<T, TResult> : NativeActivity<TResult>
{
    [RequiredArgument]
    public InArgument<string> ExpressionText { get; set; }
    [RequiredArgument]
    public InArgument<T> Value { get; set; }
    private Assign Assign { get; set; }
    private VisualBasicValue<TResult> Predicate { get; set; }
    private Variable<TResult> ResultVar { get; set; }
    protected override void CacheMetadata(NativeActivityMetadata metadata)
    {
        base.CacheMetadata(metadata);
        Predicate = new VisualBasicValue<TResult>("ExpressionText.Length");
        ResultVar = new Variable<TResult>("ResultVar");
        Assign = new Assign { To = new OutArgument<TResult>(ResultVar), Value = new InArgument<TResult>(Predicate) };
        metadata.AddImplementationVariable(ResultVar);
        metadata.AddImplementationChild(Assign);
    }
    protected override void Execute(NativeActivityContext context)
    {
        // this line, commented or not, is the same!
        Predicate.ExpressionText = ExpressionText.Get(context);
        context.ScheduleActivity(Assign, new CompletionCallback(AssignComplete));
    }
    private void AssignComplete(NativeActivityContext context, ActivityInstance completedInstance)
    {
        // the result will always be the ExpressionText.Length 
        Result.Set(context, ResultVar.Get(context));
    }
}

当您获得Execute()方法时，更改子实现不起作用。执行模式处于打开状态，无法更改子树。