【有难度，期待高手解答】如何用C#实现将字符串"(3 > 2) && (1 < 2 || 1 > 3)"的逻辑判断结果为true or false。

Question

最好不用反射，反射损耗性能。当然有不损耗性能的反射方案也中。谢谢各位高手！！！再请高手帮忙解答个问题，关于Castal＋反射实现动态组件容器框架方案的。http://community.csdn.net/Expert/topic/4573/4573370.xml?temp=.7729761

Answer 1

如何用C#实现将字符串"(3 > 2) && (1 < 2 || 1 > 3)"的逻辑判断结果为true or false。

Answer 2

bool cc=((3 > 2) && (1 < 2 || 1 > 3） )

Answer 3

答案是 true 啊，还有什么可能想的嘛

Answer 4

转到SQL语句中。
or:using System;namespace XIYV.Compute
{
 /// <summary>
 /// SimpleRPN 的摘要说明。
 /// </summary>
 public sealed class SimpleRPN
 {
  private SimpleRPN(){}
  /// <summary>
  /// Reverse Polish Notation
  /// 算术逆波兰表达式.生成.
  /// </summary>
  /// <param name="s"></param>
  /// <returns></returns>
  private static string BuildingRPN(string s)
  {
   System.Text.StringBuilder sb=new System.Text.StringBuilder(s);
   System.Collections.Stack sk=new System.Collections.Stack();
   System.Text.StringBuilder re=new System.Text.StringBuilder();
   char c=' ';
   //sb.Replace(" ","");//一开始,我只去掉了空格.后来我不想不支持函数和常量能滤掉的全OUT掉.
   for(int i=0;i<sb.Length;i++)
   {
    c=sb;
    if(char.IsDigit(c))//数字当然要了.
     re.Append(c);
    //if(char.IsWhiteSpace(c)||char.IsLetter(c))//如果是空白,那么不要.现在字母也不要.
     //continue;
    switch(c)//如果是其它字符...列出的要,没有列出的不要.
    {
     case '+':
     case '-':
     case '*':
     case '/':
     case '%':
     case '^':
     case '!':
     case '(':
     case ')':
     case '.':
      re.Append(c);
      break;
     default:
      continue;
    }
   }
   sb=new System.Text.StringBuilder(re.ToString());
   #region 对负号进行预转义处理.负号变单目运算符求反.
   for(int i=0;i<sb.Length-1;i++)
    if(sb=='-'&&(i==0||sb[i-1]=='('))
     sb='!';//字符转义.
   #endregion
   #region 将中缀表达式变为后缀表达式.   re=new System.Text.StringBuilder();
   for(int i=0;i<sb.Length;i++)
   {
    if(char.IsDigit(sb)||sb=='.')//如果是数值.
    {
     re.Append(sb);//加入后缀式
    }
    else if(sb=='+'
     ||sb=='-'
     ||sb=='*'
     ||sb=='/'
     ||sb=='%'
     ||sb=='^'
     ||sb=='!')//.
    {
     #region 运算符处理
     while (sk.Count>0) //栈不为空时 
     { 
      c = (char)sk.Pop(); //将栈中的操作符弹出.
      if (c == '(') //如果发现左括号.停.
      {
       sk.Push(c); //将弹出的左括号压回.因为还有右括号要和它匹配.
       break; //中断.
      } 
      else
      { 
       if(Power(c)<Power(sb))//如果优先级比上次的高,则压栈.
       {
        sk.Push(c);
        break;
       }
       else
       {
        re.Append(' ');
        re.Append(c);
       }
       //如果不是左括号,那么将操作符加入后缀式中.
      } 
     } 
     sk.Push(sb); //把新操作符入栈.
     re.Append(' ');
     #endregion
    }
    else if(sb=='(')//基本优先级提升
    {
     sk.Push('(');
     re.Append(' ');
    }
    else if(sb==')')//基本优先级下调
    {
     while (sk.Count>0) //栈不为空时 
     { 
      c = (char)sk.Pop(); //pop Operator 
      if (c != '(') 
      { 
       re.Append(' ');
       re.Append(c);//加入空格主要是为了防止不相干的数据相临产生解析错误.
       re.Append(' ');
      }
      else
       break;
     } 
    }
    else
     re.Append(sb);
   }
   while(sk.Count>0)//这是最后一个弹栈啦.
   {
    re.Append(' ');
    re.Append(sk.Pop());
   }
   #endregion   re.Append(' ');
   return FormatSpace(re.ToString());//在这里进行一次表达式格式化.这里就是后缀式了.
  }  /// <summary>
  /// 算术逆波兰表达式计算.
  /// </summary>
  /// <param name="s"></param>
  /// <returns></returns>
  public static string ComputeRPN(string s)
  {
   
   string S=BuildingRPN(s);
   string tmp="";
   System.Collections.Stack sk=new System.Collections.Stack();
   char c=' ';
   System.Text.StringBuilder Operand=new System.Text.StringBuilder();
   double x,y;
   for(int i=0;i<S.Length;i++)
   {
    c=S;
    if(char.IsDigit(c)||c=='.')
    {//数据值收集.
     Operand.Append(c);
    }
    else if(c==' '&&Operand.Length>0)
    {
     #region 运算数转换
     try
     {
      tmp=Operand.ToString();
      if(tmp.StartsWith("-"))//负数的转换一定要小心...它不被直接支持.
      {//现在我的算法里这个分支可能永远不会被执行.
       sk.Push(-((double)Convert.ToDouble(tmp.Substring(1,tmp.Length-1))));
      }
      else
      {
       sk.Push(Convert.ToDouble(tmp));
      }
     }
     catch
     {
      return "发现异常数据值.";
     }
     Operand=new System.Text.StringBuilder();
     #endregion
    }
    else if(c=='+'//运算符处理.双目运算处理.
     ||c=='-'
     ||c=='*'
     ||c=='/'
     ||c=='%'
     ||c=='^')
    {
     #region 双目运算
     if(sk.Count>0)/*如果输入的表达式根本没有包含运算符.或是根本就是空串.这里的逻辑就有意义了.*/
     {
      y=(double)sk.Pop();
     }
     else
     {
      sk.Push(0);
      break;
     }
     if(sk.Count>0)
      x=(double)sk.Pop();
     else
     {
      sk.Push(y);
      break;
     }
     switch(c)
     {
      case '+':
       sk.Push(x+y);
       break;
      case '-':
       sk.Push(x-y);
       break;
      case '*':
       sk.Push(x*y);
       break;
      case '/':
       sk.Push(x/y);
       break;
      case '%':
       sk.Push(x%y);
       break;
      case '^':
//       if(x>0)
//       {我原本还想,如果被计算的数是负数,又要开真分数次方时如何处理的问题.后来我想还是算了吧.
        sk.Push(System.Math.Pow(x,y));
//       }
//       else
//       {
//        double t=y;
//        string ts="";
//        t=1/(2*t);
//        ts=t.ToString();
//        if(ts.ToUpper().LastIndexOf('E')>0)
//        {
//         ;
//        }
//       }
       break;
     }
     #endregion
    }
    else if(c=='!')//单目取反.)
    {
     sk.Push(-((double)sk.Pop()));
    }
   }
   if(sk.Count>1)
    return "运算没有完成.";
   if(sk.Count==0)
    return "结果丢失..";
   return sk.Pop().ToString();
  }
  /// <summary>
  /// 优先级别测试函数.
  /// </summary>
  /// <param name="opr"></param>
  /// <returns></returns>
  private static int Power(char opr)
  {
   switch(opr)
   {
    case '+':
    case '-':
     return 1;
    case '*':
    case '/':
     return 2;
    case '%':
    case '^':
    case '!':
     return 3;
    default:
     return 0;
   }
  }
  /// <summary>
  /// 规范化逆波兰表达式. 
  /// </summary>
  /// <param name="s"></param>
  /// <returns></returns>
  private static string FormatSpace(string s)
  {
   System.Text.StringBuilder ret=new System.Text.StringBuilder();
   for(int i=0;i<s.Length;i++)
   {
    if(!(s.Length>i+1&&s==' '&&s[i+1]==' '))
     ret.Append(s);
    else
     ret.Append(s);
   }
   return ret.ToString();//.Replace('!','-');
  }
 }
 /*这里给出的测试用例虽然不多.但如都能成功计算也不容易.
(6+9-8+5-8)*(2+5+8)/7+5
(1+2+3+4+5+6+7+8+9)*(1+2+3+4+5+6+7+8+9)/(9+8+7+6)*3-2-2+5/7-3
(-3+4+9)*(-3)*7/(-5*2)
-(6+9-8+5-8)*(2+5+8)
1+2+3+4+5+6+7+8+9
1*2*3*4*5*6*7*8*9
1-2-3-4-5-6-7-8-9
1/2/3/4/5/6/7/8/9
(6+9-8+5-8)*(2+5+8)
 */
}

Answer 5

传到客户端，用javascript的eval（"(3 > 2) && (1 < 2 || 1 > 3)"）执行结果

Answer 6

找到解决办法了
http://www.cnblogs.com/montaque/archive/2005/12/28/306407.html
J#实现，可以计算数学表达式和逻辑表达式。仰天长嗥～～～～～～～～～～～～～～～
为什么每次都是我自己问问题自己答啊，就是不结贴，气死管理员~~>_<~~~~`

Answer 7

这可是C#的实现：http://snowdust.cnblogs.com/articles/311728.html
结不结帖？using System;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Text;
using Microsoft.CSharp;namespace CSharp
{
 /**//// <summary>
 /// 模块名称：计算表达式的类
 /// </summary>
 public class Calculate
 {
  /**//// <summary>
  /// 构造函数
  /// </summary>
  public Calculate()
  {  }  public static object Calc(string expression) 
  { 
   string className = "Calc"; 
   string methodName = "Run"; 
   expression=expression.Replace("/","*1.0/");
             
   // 创建编译器实例。 
   ICodeCompiler complier = (new CSharpCodeProvider().CreateCompiler()); 
   // 设置编译参数。 
   CompilerParameters paras = new CompilerParameters(); 
   paras.GenerateExecutable = false; 
   paras.GenerateInMemory = true; 
 
   // 创建动态代码。 
   StringBuilder classSource = new StringBuilder();  
   classSource.Append("public class "+ className +"\n"); 
   classSource.Append("{\n"); 
   classSource.Append("    public object " + methodName + "()\n"); 
   classSource.Append("    {\n"); 
   classSource.Append("        return "+ expression + ";\n"); 
   classSource.Append("    }\n"); 
   classSource.Append("}"); 
 
   // 编译代码。 
   CompilerResults result = complier.CompileAssemblyFromSource(paras, classSource.ToString()); 
             
   // 获取编译后的程序集。 
   Assembly assembly = result.CompiledAssembly; 
  
   // 动态调用方法。 
   object eval = assembly.CreateInstance(className); 
   MethodInfo method = eval.GetType().GetMethod(methodName); 
   object reobj = method.Invoke(eval, null); 
   GC.Collect();
   return reobj;
  }
 }
}

Answer 8

CodeDom+反射太慢了～～～～～

Answer 9

放在sql 语句的where 掉件后面即可！

Answer 10

XmlDocument doc = new XmlDocument();
XPathNavigator nav = doc.CreateNavigator()
nav.Evaluate("(3 > 2) && (1 < 2 || 1 > 3)");