Convertir une condition booléenne complexe de chaîne en booléenne .NET

Question

J'ai besoin d'analyser une expression complexe de chaîne à bool.

Il ne peut contenir:
* Les valeurs booléennes (vrai/faux),
* entre parenthèses,
* ET/OU opérandes (& &, ||)

Ex:

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

Une idée de comment y parvenir?

Answer 1

Voici une classe d'évaluation astucieuse qui vous donne la fonction JScript.NET Eval au sein du code 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; 
     } 
    } 
} 

Vous appelez simplement Evaluator.EvaluateToBool (string). Soulevé d'un projet existant, alors vous voudrez peut-être modifier!

Answer 2

La méthode standard consiste à:

• tokenize la chaîne
• construire un arbre en mettant un opérateur dans chaque noeud et un opérande dans chaque feuille
• visiter l'arborescence évaluation de l'expression

Answer 3

La chaîne que vous avez décrite est un code C# valide, donc si vous pouvez l'interpréter à l'exécution, vous avez terminé. Dans de nombreuses langues, il s'agit d'une fonction intégrée. En C# ce n'est pas le cas, mais vous pouvez utiliser une bibliothèque tierce comme celle-ci runtime C# interpreter