if("Y<0") 如何变成 if(Y<0) ?

Question

有以下需求：
if("Y<0")
{g=60%;}
if("0≤Y≤100%")
{g=110%;}
if("Y>0 && g≤100%")
{g=90%;}
引号里面都是传过来的字符串，会随时间变化。
上面是字符串，当然运行不了，达不到目的，怎样才能转化成下面的语句？
if(Y<0)
{g=60%;}
if(0≤Y≤100%)
{g=110%;}
if(Y>0 && g≤100%)
{g=90%;}
如果您会的话，占用您一小会时间，帮小弟解答一下，感激不尽！

Answer 1

这个得分析字符串然后在逻辑判断。
js和python上都可以实现 要不移植过去？

Answer 2

//假设传过来的 "Y<0" 这样的是一个字符串 conditionStringif("Y<0")
   {g=60%;}
if("0≤Y≤100%")
   {g=110%;}
if("Y>0 && g≤100%")
   {g=90%;}//改成
Switch(conditionString)
{
    case "Y<0":
        g=60%;
    case "0≤Y≤100%":
        g=110%;
    //...略
}

Answer 3

用Switch语句，可以直接使用string类型作用判断条件。

Answer 4

没规律的话，你 if 下面的执行语句的依据是什么？
你是依据什么认为
if("Y<0") 则 {g=60%;}
if("0≤Y≤100%") 则 {g=110%;}这里的逻辑依据是什么？g=60%， g=110% 这个也是从参数传递过来的？

Answer 5

他的意思是if()里是个字符串类型，不能作为传入if的判断条件，字符串本身可能不带引号

Answer 6

//假设传过来的 "Y<0" 这样的是一个字符串 conditionStringif("Y<0")
   {g=60%;}
if("0≤Y≤100%")
   {g=110%;}
if("Y>0 && g≤100%")
   {g=90%;}//改成
Switch(conditionString)
{
    case "Y<0":
        g=60%;
        break;
    case "0≤Y≤100%":
        g=110%;
        break;
     //...略 
}//惭愧，break 丢了

Answer 7

好像很少有这样传条件的，你可以对字符串中的每个字符进行判断，如果是"<"就用<，其它同理

Answer 8

用户在界面上的文本框输入条件Y<0，然后执行g=60%
条件0≤Y≤100%，然后执行g=110%
条件Y>0 && g≤100%，然后执行g=90%
当然到程序里面条件就成字符串了。
现在只需要把：
if("Y<0")
{g=60%;}
if("0≤Y≤100%")
{g=110%;}
if("Y>0 && g≤100%")
{g=90%;}
转换成：
if(Y<0)
{g=60%;}
if(0≤Y≤100%)
{g=110%;}
if(Y>0 && g≤100%)
{g=90%;}
即可。

Answer 9

传过来的字符串变动的话，用if判断方便。
用其它的比如case只能是字符串不变动才可以。

Answer 10

case 怎么会是字符串不变动呢？用switch的case不比if方便？
case 怎么会只能是字符串不变动才可以呢？
case 怎么会只能是字符串不变动才可以呢？
case 怎么会只能是字符串不变动才可以呢？
....
Switch(parameter).. case.. 中的 parameter 是个变量！变量的名字不变，变量的值，随你变！你是孙悟空都没问题！你想变就变！去翻书看看..

Answer 11

传值前判断不了，因为程序里面先要计算数据，计算完了之后，才能根据数据加上条件得成结论。
比如
if("Y<0")
{g=60%;}
程序里面最后根据各类数据算出Y的值，
比如算出Y=-20，然后就是Y<0，然后执行g=60%
再比如算出Y=0.2，然后就是0≤Y≤100%，然后执行g=110%

Answer 12

既然你已经算出了Y的值了，你为什么还要给Y的值区间变成字符串形式"0≤Y≤100%"？
你先好好理理你的思路，我觉得你思维混乱了，陷入了死胡同，跳出这个胡同想想，有没有别的方法实现你的程序逻辑？不要死扣在怎么把 "0≤Y≤100%" 变成 0≤Y≤100% 的问题上.或者，把你程序的原始业务需求告诉大家，让大家帮你看看有没有好的解决思路。

Answer 13

你也说了，传值没有规律的，那就只能自己制造规定了，你想用if的话，就必须自定义你的if关键字的判断依据，而不能用c#的if，如果你想你的方案可行的话，还有另一个办法，就是当用户输入条件后，程序必须编译通过（这个要你自己实现，不能靠c#本身自带的编译器）；
OK，LZ知道你自己的方案要做下去难度有多高了吧，呜呜。。

Answer 14

我现在程序里面算出Y值了，然后下来我要根据算出的Y值算出g值，但是算出的Y值不同则g的值不同。
用户现在规定
1，  Y<0 则 g=60%
2，  0≤Y≤100% 则g=Y/Z,这里Z是另外一个数值，也已经算出。
3，  Y>0 && g≤100 则g=90%   这是根据2的条件0≤Y≤100%算出g后，如果g≤100 则g=90% 

Answer 15

正则匹配 Y ,< , > , = 数字  

Answer 16

我现在程序里面算出Y值了，然后下来我要根据算出的Y值算出g值，但是算出的Y值不同则g的值不同。
用户现在规定
1， Y<0 则 g=60%
2， 0≤Y≤100% 则g=Y/Z,这里Z是另外一个数值，也已经算出。
3， Y>0 && g≤100% 则g=90% 这是根据2的条件0≤Y≤100%算出g后，如果g≤100% 则g=90%  用户的规定会随时会更改的，有可能明天就变成
2,  0≤Y≤90% 则g=Y/Z

Answer 17

我觉得没必要一定要将"0≤Y≤100%" 变成 0≤Y≤100%
你就不能拆开来吗？
像我们写简单的数学题进行运算，我们让用户填写A和B，再选择运算符号C，那就可以算出D
如果你的变量y是固定的了，还有什么不能固定的，如果有出现你意外的情况，那只能说明你考虑的不够充分

Answer 18

编程思路里，有一个叫做“以小代大”的心法，就是用具体的（甚至是片面的）东西来代替模糊不确定的东西。也许可以帮你。string strInput = ... ;//接收来用户输入
float Yt; //临时变量,只用于条件判断
float gt; //临时变量,只用于条件判断if(strInput=="Y<0")
{Yt = -1;}
if(strInput=="0≤Y≤100%")
{Yt=0.5}
if(strInput=="Y>0 && g≤100%")
{Yt=1;gt=0.5}
if(Yt<0)
{g=60%;}
if(0≤Yt≤100%)
{g=110%;}
if(Yt>0 && gt≤100%)
{g=90%;}

Answer 19

我明白你的意思了。你要的东东叫做“c#动态解析编译”，有一个类是 CSharpCodeProvider，你自己参考一下这个吧，再查查MSDN，应该能解决，祝你成功！ http://social.microsoft.com/Forums/pt-BR/visualcshartzhchs/thread/bf513409-e25e-4631-847b-407fbf371557

Answer 20

if中的条件不是动态的可以用Switch就ok,如果if中的条件是动态的就可以调用C#的编程器来执行就ok了，具体参照我的资源文件里有动态代码执行

Answer 21

可以通过Microsoft.CSharp里的类来进行动态编译

Answer 22

.Replace("\"","")  这样行不？

Answer 23

LZ是不是字串要提供给使用者输入的条件？譬如使用者可以随意输入"5<Y<8"这样的条件，然后代码可以解析？

Answer 24

关键在于你对问题的理解角度：
举个例子：string str=if("Y<0")
此时你用str.Split();因为"的前面和后面只有是'('和'）'。
现在你知道该怎么做了吧。相当于将字符串重构。因为通过左右括号你能获取"的索引。
所以说，解决一个问题往往会有很多变通的方法，从多个角度出发进行思考吧，呵呵！

Answer 25

你这个问题可以用CodeDOM来解决，你搜索一下，有很多的文章讲解，就类似与在dotnet内部使用脚本语言一样，你可以动态拼接出来一些语句，然后动态编译并执行它。

Answer 26

C# 是可以动态执行字符串语句的。给你个示例：using System;
using System.Data;
using System.Configuration;
using System.Text;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using System.Reflection;namespace Eval
{
    /// <summary>
    /// 本类用来将字符串转为可执行文本并执行
    /// 从别处复制，勿随意更改！
    /// </summary>
    public class Evaluator
    {
        #region 构造函数
        /// <summary>
        /// 可执行串的构造函数
        /// </summary>
        /// <param name="items">
        /// 可执行字符串数组
        /// </param>
        public Evaluator(EvaluatorItem[] items)
        {
            ConstructEvaluator(items); //调用解析字符串构造函数进行解析
        }
        /// <summary>
        /// 可执行串的构造函数
        /// </summary>
        /// <param name="returnType">返回值类型</param>
        /// <param name="expression">执行表达式</param>
        /// <param name="name">执行字符串名称</param>
        public Evaluator(Type returnType, string expression, string name)
        {
            //创建可执行字符串数组
            EvaluatorItem[] items = { new EvaluatorItem(returnType, expression, name) };
            ConstructEvaluator(items); //调用解析字符串构造函数进行解析
        }
        /// <summary>
        /// 可执行串的构造函数
        /// </summary>
        /// <param name="item">可执行字符串项</param>
        public Evaluator(EvaluatorItem item)
        {
            EvaluatorItem[] items = { item };//将可执行字符串项转为可执行字符串项数组
            ConstructEvaluator(items); //调用解析字符串构造函数进行解析
        }
        /// <summary>
        /// 解析字符串构造函数
        /// </summary>
        /// <param name="items">待解析字符串数组</param>
        private void ConstructEvaluator(EvaluatorItem[] items)
        {
            //创建C#编译器实例
            ICodeCompiler comp = (new CSharpCodeProvider().CreateCompiler());
            //编译器的传入参数
            CompilerParameters cp = new CompilerParameters();            cp.ReferencedAssemblies.Add("system.dll"); //添加程序集 system.dll 的引用
            cp.ReferencedAssemblies.Add("system.data.dll"); //添加程序集 system.data.dll 的引用
            cp.ReferencedAssemblies.Add("system.xml.dll"); //添加程序集 system.xml.dll 的引用
            cp.GenerateExecutable = false; //不生成可执行文件
            cp.GenerateInMemory = true; //在内存中运行            StringBuilder code = new StringBuilder(); //创建代码串
            /*
             *  添加常见且必须的引用字符串
             */
            code.Append("using System; \n");
            code.Append("using System.Data; \n");
            code.Append("using System.Data.SqlClient; \n");
            code.Append("using System.Data.OleDb; \n");
            code.Append("using System.Xml; \n");            code.Append("namespace EvalGuy { \n"); //生成代码的命名空间为EvalGuy，和本代码一样            code.Append("  public class _Evaluator { \n"); //产生 _Evaluator 类，所有可执行代码均在此类中运行
            foreach (EvaluatorItem item in items) //遍历每一个可执行字符串项
            {
                code.AppendFormat("    public {0} {1}() ", //添加定义公共函数代码
                                  item.ReturnType.Name, //函数返回值为可执行字符串项中定义的返回值类型
                                  item.Name); //函数名称为可执行字符串项中定义的执行字符串名称
                code.Append("{ "); //添加函数开始括号
                code.AppendFormat("{0}", item.Expression);//添加函数体，返回可执行字符串项中定义的表达式的值
                code.Append("}\n"); //添加函数结束括号
            }
            code.Append("} }"); //添加类结束和命名空间结束括号            //得到编译器实例的返回结果
            CompilerResults cr = comp.CompileAssemblyFromSource(cp, code.ToString());            if (cr.Errors.HasErrors) //如果有错误
            {
                StringBuilder error = new StringBuilder(); //创建错误信息字符串
                error.Append("编译有错误的表达式: "); //添加错误文本
                foreach (CompilerError err in cr.Errors) //遍历每一个出现的编译错误
                {
                    error.AppendFormat("{0}\n", err.ErrorText); //添加进错误文本，每个错误后换行
                }
                throw new Exception("编译错误: " + error.ToString());//抛出异常
            }
            Assembly a = cr.CompiledAssembly; //获取编译器实例的程序集
            _Compiled = a.CreateInstance("EvalGuy._Evaluator"); //通过程序集查找并声明 EvalGuy._Evaluator 的实例
        }
        #endregion        #region 公有成员
        /// <summary>
        /// 执行字符串并返回整型值
        /// </summary>
        /// <param name="name">执行字符串名称</param>
        /// <returns>执行结果</returns>
        public int EvaluateInt(string name)
        {
            return (int)Evaluate(name);
        }
        /// <summary>
        /// 执行字符串并返回字符串型值
        /// </summary>
        /// <param name="name">执行字符串名称</param>
        /// <returns>执行结果</returns>
        public string EvaluateString(string name)
        {
            return (string)Evaluate(name);
        }
        /// <summary>
        /// 执行字符串并返回布尔型值
        /// </summary>
        /// <param name="name">执行字符串名称</param>
        /// <returns>执行结果</returns>
        public bool EvaluateBool(string name)
        {
            return (bool)Evaluate(name);
        }
        /// <summary>
        /// 执行字符串并返 object 型值
        /// </summary>
        /// <param name="name">执行字符串名称</param>
        /// <returns>执行结果</returns>
        public object Evaluate(string name)
        {
            MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用
            return mi.Invoke(_Compiled, null); //执行 mi 所引用的方法
        }
        #endregion        #region 静态成员
        /// <summary>
        /// 执行表达式并返回整型值
        /// </summary>
        /// <param name="code">要执行的表达式</param>
        /// <returns>运算结果</returns>
        static public int EvaluateToInteger(string code)
        {
            Evaluator eval = new Evaluator(typeof(int), code, staticMethodName);//生成 Evaluator 类的对像
            return (int)eval.Evaluate(staticMethodName); //执行并返回整型数据
        }
        /// <summary>
        /// 执行表达式并返回字符串型值
        /// </summary>
        /// <param name="code">要执行的表达式</param>
        /// <returns>运算结果</returns>
        static public string EvaluateToString(string code)
        {
            Evaluator eval = new Evaluator(typeof(string), code, staticMethodName);//生成 Evaluator 类的对像
            return (string)eval.Evaluate(staticMethodName); //执行并返回字符串型数据
        }
        /// <summary>
        /// 执行表达式并返回布尔型值
        /// </summary>
        /// <param name="code">要执行的表达式</param>
        /// <returns>运算结果</returns>
        static public bool EvaluateToBool(string code)
        {
            Evaluator eval = new Evaluator(typeof(bool), code, staticMethodName);//生成 Evaluator 类的对像
            return (bool)eval.Evaluate(staticMethodName); //执行并返回布尔型数据
        }
        /// <summary>
        /// 执行表达式并返回 object 型值
        /// </summary>
        /// <param name="code">要执行的表达式</param>
        /// <returns>运算结果</returns>
        static public object EvaluateToObject(string code)
        {
            Evaluator eval = new Evaluator(typeof(object), code, staticMethodName);//生成 Evaluator 类的对像
            return eval.Evaluate(staticMethodName); //执行并返回 object 型数据
        }
        #endregion        #region 私有成员
        /// <summary>
        /// 静态方法的执行字符串名称
        /// </summary>
        private const string staticMethodName = "__foo";
        /// <summary>
        /// 用于动态引用生成的类，执行其内部包含的可执行字符串
        /// </summary>
        object _Compiled = null;
        #endregion
    }
    /// <summary>
    /// 可执行字符串项（即一条可执行字符串）
    /// </summary>
    public class EvaluatorItem
    {
        /// <summary>
        /// 返回值类型
        /// </summary>
        public Type ReturnType;
        /// <summary>
        /// 执行表达式
        /// </summary>
        public string Expression;
        /// <summary>
        /// 执行字符串名称
        /// </summary>
        public string Name;
        /// <summary>
        /// 可执行字符串项构造函数
        /// </summary>
        /// <param name="returnType">返回值类型</param>
        /// <param name="expression">执行表达式</param>
        /// <param name="name">执行字符串名称</param>
        public EvaluatorItem(Type returnType, string expression, string name)
        {
            ReturnType = returnType;
            Expression = expression;
            Name = name;
        }
    }
}
使用示例： textBox1.Text = string.Format("执行结果: {0}", Evaluator.EvaluateToObject(richTextBox1.Text));

Answer 27

var engine = Microsoft.JScript.Vsa.VsaEngine.CreateEngine();
var value  = Microsoft.JScript.Eval.JScriptEvaluate("Y < 0", engine);
if(Convert.ToBoolean(value)){
......
}

Answer 28

还是觉得用switch是最好的，如果不行，就写一个新的类，专门用来转化形式如“a<b<b”这样的字符串~大不了就用正则表达式，或者一个一个字母截下来替换~

Answer 29

楼主,写个xml文件怎么样
<conditions>  
   <condition>
       <name>Y<0</name>
       <val>60%</val>
   </condition>
</conditions> 

Answer 30

条件变化是只要调整xml文件即可

Answer 31

不妨你先把程序中抽象的级别再提高一点。
假定有这么一个function
bool func(y,string sConfiation);这里边可以实现你那个串中的判断， 返回真或假，
这里边要解析一下，因为只是个简单的关系，很容易解析。
这样的你程序会变为以下形式：
if(func(y,"Y<0")
{g=60%;}
if(func(y,"0≤Y≤100%"))
{g=110%;}
if(func(Y,"Y>0 &amp;&amp; g≤100%"))
{g=90%;}对于最后那个复杂的，如果你觉得难于解析，不妨把参数拆开传入。
试试看。

Answer 32

switch   刚才想复杂了~

Answer 33

作为一个程序员，楼主的这个想法就不应该有。哪儿有让用户去“写代码”的！！你还不如去开发个“更易语言”让用户使用呢。怕用户的需求变动，就把系统配置写成动态的，让用户自定义。
给用户一个设置页面（或窗体），让管理员用户输入“Y<口 则g=60%"，口中得到的数值，保存起来，保存在数据库、xml文件、ini、甚至系统注册表中都可以。程序每次启动，都从保存的地方读出来，等待用户输入一个y值进行大小判断。不要钻现在这个牛角尖了。

Answer 34

问题已解决。用的是Microsoft.CSharp