C#转换字符串以在逻辑条件下使用

Question

是否可以将字符串转换为运算符以在逻辑条件中使用.

例如

if(x Convert.ToOperator(">") y) {}

要么

if(x ">" as Operator y){}

我很欣赏这可能不是标准练习题,因此我对那些问我为什么要做这样的事情的答案不感兴趣.

提前致谢

编辑:好的我同意,只是公平地给出一些背景.

我们有围绕反射和XML构建的系统.为了方便起见,我希望能够说出类似的话.

<Value = "Object1.Value" Operator = ">" Condition = "0"/>

编辑:感谢您的评论,我在这里无法正确解释.我想我的问题是通过"你不能"回答的,这绝对是好的(我想的).感谢您的意见.

编辑:Sod it我将要去.

想象一下以下内容

<Namespace.LogicRule Value= "Object1.Value" Operator=">" Condition="0">  

这将反映到一个类中,所以现在我想通过调用来测试条件

bool LogicRule.Test()

这就是它需要聚集在一起的地方.

编辑:

好的,所以从未看过Lambdas或Expressions,我想我会照看@ jrista的建议.

我的系统允许对Enums进行解析,因此Expressions因ExpressionType Enum而具有吸引力.

所以我创建了以下类来测试这个想法:

    public class Operation
    {
        private object _Right;
        private object _Left;
        private ExpressionType _ExpressionType;
        private string _Type;

        public object Left
        {
            get { return _Left; }
            set { _Left = value; }
        }

        public object Right
        {
            get { return _Right; }
            set { _Right = value; }
        }

        public string Type
        {
            get { return _Type; }
            set { _Type = value; }
        }

        public ExpressionType ExpressionType
        {
            get { return _ExpressionType; }
            set { _ExpressionType = value; }
        }

        public bool Evaluate()
        {
            var param = Expression.Parameter(typeof(int), "left");
            var param2 = Expression.Parameter(typeof(int), "right");

            Expression<Func<int, int, bool>> expression = Expression.Lambda<Func<int, int, bool>>(
               Expression.MakeBinary(ExpressionType, param, param2), param, param2);

            Func<int, int, bool> del = expression.Compile();

            return del(Convert.ToInt32(Left), Convert.ToInt32(Right));

        }
    }

显然这只适用于Int32现在和基本的ExpressionTypes,我不确定我可以使它通用吗？我之前从未使用过表达式,但这似乎有效.

然后可以用我们的XML方式声明这种方式

Operation<Left="1" Right="2" ExpressionType="LessThan" Type="System.Int32"/>

Answer 1

你可以这样做:

public static bool Compare<T>(string op, T x, T y) where T:IComparable
{
 switch(op)
 {
  case "==" : return x.CompareTo(y)==0;
  case "!=" : return x.CompareTo(y)!=0;
  case ">"  : return x.CompareTo(y)>0;
  case ">=" : return x.CompareTo(y)>=0;
  case "<"  : return x.CompareTo(y)<0;
  case "<=" : return x.CompareTo(y)<=0;
 }
}

Answer 2

编辑

正如JaredPar指出的那样,我的建议不会起作用,因为你不能将运算符应用于泛型......

所以你需要为你想要比较/计算的每个类型都有特定的实现...

public int Compute (int param1, int param2, string op) 
{
    switch(op)
    {
        case "+": return param1 + param2;
        default: throw new NotImplementedException();
    }
}

public double Compute (double param1, double param2, string op) 
{
    switch(op)
    {
        case "+": return param1 + param2;
        default: throw new NotImplementedException();
    }
}

弊

你可以这样做.

您还需要尝试/捕获所有这些以确保无论T是什么,都支持特定操作.

请注意,如果我问你为什么可能需要这样做.你在写一些数学解析器吗？

public T Compute<T> (T param1, T param2, string op) where T : struct
{
    switch(op)
    {
        case "+":
            return param1 + param2;
        default:
             throw new NotImplementedException();
    }
}

public bool Compare<T> (T param1, T param2, string op) where T : struct
{
    switch (op)
    {
        case "==":
             return param1 == param2;
        default:
             throw new NotImplementedException();
    }
}