Convierta la condición de bool compleja de cadena a bool en .NET

Question

Necesito analizar la expresión compleja de una cadena a otra.

Sólo puede contener:
* valores booleanos (verdadero/falso),
* paréntesis,
* Y/O operandos (& &, ||)

Ejem:

bool.Parse("((true || false) && (false || false)) || (true || false)" 

¿Alguna idea de cómo lograr esto?

Answer 1

Aquí hay una astuta clase de evaluadores que le da la función JScript.NET Eval dentro del código C#:

static public class Evaluator 
{ 
    private const string _jscriptSource = 
     @"package Evaluator 
     { 
      class Evaluator 
      { 
       public function Eval(expr : String) : String 
       { 
       return eval(expr); 
       } 
      } 
     }"; 

    static private object _evaluator; 
    static private Type _evaluatorType; 

    [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline", 
     Justification = "Can't be done inline - too complex")] 
    static Evaluator() 
    { 
     InstantiateInternalEvaluator(); 
    } 

    static private void InstantiateInternalEvaluator() 
    { 
     JScriptCodeProvider compiler = new JScriptCodeProvider(); 

     CompilerParameters parameters; 
     parameters = new CompilerParameters(); 
     parameters.GenerateInMemory = true; 

     CompilerResults results; 
     results = compiler.CompileAssemblyFromSource(parameters, _jscriptSource); 

     Assembly assembly = results.CompiledAssembly; 
     _evaluatorType = assembly.GetType("Evaluator.Evaluator"); 

     _evaluator = Activator.CreateInstance(_evaluatorType); 
    } 

    static public int EvaluateToInteger(string statement) 
    { 
     string s = EvaluateToString(statement); 
     return int.Parse(s); 
    } 

    static public double EvaluateToDouble(string statement) 
    { 
     string s = EvaluateToString(statement); 
     return double.Parse(s); 
    } 

    static public decimal ForceEvaluateToDecimal(string statement) 
    { 
     decimal result; 
     bool s = Decimal.TryParse(statement, out result); 
     return result; 
    } 

    static public decimal EvaluateToDecimal(string statement) 
    { 
     string s = EvaluateToString(statement); 
     return decimal.Parse(s); 
    } 

    static public string EvaluateToString(string statement) 
    { 
     object o = EvaluateToObject(statement); 
     return o.ToString(); 
    } 

    static public bool EvaluateToBool(string statement) 
    { 
     object o = EvaluateToObject(statement); 
     return (bool)o; 
    } 

    static public object EvaluateToObject(string statement) 
    { 
     try 
     { 
      return _evaluatorType.InvokeMember(
       "Eval", 
       BindingFlags.InvokeMethod, 
       null, 
       _evaluator, 
       new object[] {statement} 
       ); 
     } 
     catch (Exception) 
     { 
      InstantiateInternalEvaluator(); 
      return null; 
     } 
    } 
} 

Usted acaba de llamar a Evaluator.EvaluateToBool (cadena). Levantado de un proyecto existente, ¡por lo que es posible que desee ajustarlo!

Answer 2

El método estándar es:

• tokenize la cadena
• construir un árbol de poner un operador en cada nodo y un operando en cada hoja
• visitar el árbol de evaluación de la expresión

Answer 3

La cadena que describió es un código C# válido, por lo que si puede interpretarla en tiempo de ejecución, ya está. En muchos idiomas, esta es una función incorporada. En C# no lo es, pero puede usar una biblioteca de terceros como esta runtime C# interpreter