视你是否愿意接受的程度而定,我要说,最可行的办法是,在你对所显示的投入进行调和之后,利用思考获取方法参考。

首先,你可以把问题分成小小小小小小小小小小问题。

Let s say you are aiming for something like this:

static void Main(string[] args)
{
    string rules = 
        "Check(Morning):Say(Good morning)|" +
        "Check(Afternoon):Say(Good afternoon)|" +
        "Check(Evening):Say(Good night)";

    // next, you need some **object instances** which will 
    // provide a context for your "test" and "action" methods.
    // you don t want to use static methods if you
    // went through the pain of defining such an architecture!

    // let s say that a "Tester" object has a "Check" method,
    // and an "Executor" object has a "Say" method:

    var tester = new Tester("Afternoon");
    var executor = new Executor();

    // since I suck at regular expressions,
    // I am using plain string methods to split
    // the expression into tokens. You might want
    // to add some validation

    foreach (var rule in rules.Split( | ))
    {
        var result = Parse(rule, tester, executor);
        if (result.TestPassed)
        {
            result.Execute();
            break;
        }
    }
}

上文使用的“结果”将具有这样的接口:

public interface IResult
{
    // returns true if a test is fulfilled
    bool TestPassed { get; }

    // executes the related action
    void Execute();
}

And, if you want to delegate actual actions to some unknown methods, a reasonable way to implement it would be something like this:

public class Result : IResult
{
    #region IResult Members

    private readonly Func<bool> _testMethod;
    public bool TestPassed
    {
        get { return _testMethod(); }
    }

    private readonly Action _actionMethod;
    public void Execute()
    {
        _actionMethod();
    }

    #endregion

    public Result(Func<bool> testMethod, Action actionMethod)
    {
        _testMethod = testMethod;
        _actionMethod = actionMethod;
    }
}

What s left is to use some reflection to get the actual methods out of your strings:

private static IResult Parse(string rule, object tester, object executor)
{
    // split into test/action
    var tokens = rule.Split( : );

    // extract the method/parameter part for each expression
    var test = GetMethodAndParams(tokens[0]);
    var action = GetMethodAndParams(tokens[1]);

    // use reflection to find actual methods
    var testMethod = tester.GetType().GetMethod(test.Method);
    var actionMethod = executor.GetType().GetMethod(action.Method);

    // return delegates which will simply invoke these methods
    return new Result
    (
        () => (bool)testMethod.Invoke(tester, new object[] { test.Param }),
        () => actionMethod.Invoke(executor, new object[] { action.Param })
    );
}

越来越多的是你的方案。 你们应当能够作为演习来填补失踪的部件。 如果存在问题,我可以稍后更新答案。

“GetMethodAndParams方法”应当将含有该方法名称及其作为便衣物的斜体的图形(或您的习惯类别)中显示的投入分解成图。 。

它想像你想要一种模式,即TryParse()。 在此情况下,您将修改检查方法,使其具有价值(例如@)。

int result;

if(Check( Value , out result))
    ShowImage(result);
else(Check( Value2 , out result))
    OtherFunction(result);

Finally I m back here to post what I ve done few weeks ago to solve this situation. It was easy.

Regex类别提供了很少的选择,其中一个选择是Explicit Catpure>,所有形式(?)的溪流都可以作为强有力的分类参数处理,这样,如果名称的“Is NotEmptyorNull”集团当时就具备了这一功能,而且使用Enum.Parse(”)的形式可以推广。

Snipet:

Regex rx = new Regex(@"(?<function>Check|BooleanOp)( (?<param>[w]+) ){1}:(?<action>[w]+){1}", RegexOptions.ExplicitCapture);

Match m;
Dictionary<FunctionArray, String> actions = new Dictionary<FunctionArray, String>();

if((m=rx.Match(strStream)).Success)
{
   actions.Add((FunctionArray)Enum.Parse(typeof(FunctionArray), m.Groups["function"].value, true), m.Groups["param"].value);
}

当然,失去了行动部分,因此,我用能够处理作为作出决定来源的职能和价值观的专门建筑改进了理论。

感谢大家。 Ed.