Konvertieren komplexer Bool Zustand von String zu Bool in .NET

Question

Ich muss komplexen Ausdruck von String zu Bool analysieren.

Es kann nur enthalten:
* Boolesche Werte (true/false),
* Klammer,
* UND/ODER-Operanden (& &, ||)

ZB:

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

Irgendeine Idee, wie man das erreicht?

Answer 1

Hier ist eine schlaue Evaluator-Klasse, die Ihnen die JScript.NET Eval-Funktion innerhalb von C# -Code gibt:

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; 
     } 
    } 
} 

Sie rufen dann einfach Evaluator.EvaluateToBool (Zeichenfolge). Angefangen von einem bestehenden Projekt, also möchten Sie vielleicht zwicken!

Answer 2

Das Standardverfahren besteht darin:

• tokenize der Zeichenfolge
• build ein Baum einen Operator in jedem Knoten und einen Operanden in jedem Blatt
• Besuch der Baum Auswertung des Ausdrucks

Putting

Answer 3

Die Zeichenfolge, die Sie beschrieben haben, ist ein gültiger C# -Code. Wenn Sie es also zur Laufzeit interpretieren können, sind Sie fertig. In vielen Sprachen ist dies eine eingebaute Funktion. In C# ist es nicht, aber Sie können eine 3rd-Party-Bibliothek wie diese runtime C# interpreter