C#解析逻辑字符串【x>y&&a>b||p=r】
解析逻辑字符串并动态替换值："[field]>3&&[field2]<78". field、field2为动态替换值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace ConsoleApplication2
{
public class ExpressionParser
{
#region Fields
/// <summary>
/// 将表达式以&&或者||切割
/// group[1]和group[3]为单个逻辑表达式 group[2]为右边的运算符【&&或||】
/// </summary>
private static readonly Regex regCutItem = new Regex(@"(.*?)([&|\|]{2})|(\S.*)");
/// <summary>
/// 将每个单独的item匹配出小分子 例子:3>2 => [3,>,2]
/// </summary>
private static readonly Regex regCutMolecule = new Regex(@"(.*?)([>|<]=?|=)(.*)");
/// <summary>
/// 验证每个单独的item是否合法
/// </summary>
private static readonly Regex regValidMolecult = new Regex(@"^([\w\[\]]*?)([>|<]=?|=)([\w\[\]]*)$");
/// <summary>
/// 提取表达式中的小括号内容 (如有小括号嵌套 需重复匹配;最先获取最内部括号内容,由内向外获取)
/// </summary>
private static readonly Regex regSmallBracket = new Regex(@"\([^(]*?\)");
/// <summary>
/// 提取单个单个小分子的字段值
/// </summary>
private static readonly Regex regGetField = new Regex(@"^\s*?\[(\S+)\]\s*?$");
private static readonly string trueText = "1=1";
private static readonly string falseText = "1=2";
#endregion
#region Methods
/// <summary>
/// 判断表达式的有效性
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public static bool JudgeValid(string expression)
{
if (string.IsNullOrEmpty(expression)) new ArgumentException("is null or empty", "expression");
bool haveBracketite = regSmallBracket.IsMatch(expression);
//匹配出所有括号内的内容验证是否合法,合法则remove掉
while (regSmallBracket.IsMatch(expression))
{
MatchCollection collection = regSmallBracket.Matches(expression);
foreach (Match bracketite in collection)
{
int index = 0; string opL = string.Empty, opR = string.Empty;
//匹配到的值 带括号(8>5&&7>3.....)
string expBracketite = bracketite.Value;
index = expression.IndexOf(expBracketite);
//括号内容前的连接运算符
if (index >= 2) opL = expression.Substring(index - 2, 2);
//括号内容后的连接运算符
if (expression.Length > index + expBracketite.Length + 2) opR = expression.Substring(index + expBracketite.Length, 2);
//如果连接符不为&&或||则不符合表达式规则
if (!string.IsNullOrEmpty(opL) && opL != "&&" && opL != "||") return false;
if (!string.IsNullOrEmpty(opR) && opR != "&&" && opR != "||") return false;
MatchCollection items = regCutItem.Matches(expBracketite.Substring(1, expBracketite.Length - 2));
//如果集合数小于1 则括号之间内容为空或者内容不符合规则
if (items.Count < 1) return false;
int indexOfItem1 = 0;
foreach (Match item in items)
{
indexOfItem1++;
//获取表达式
string expItem = indexOfItem1 == items.Count ? item.Groups[3].Value : item.Groups[1].Value;
//验证表达式的有效性
if (!regValidMolecult.IsMatch(expItem)) return false;
}
//remove括号内的表达式以及括号前的连接运算符
expression = expression.Remove(index < 2 ? index : index - 2, expBracketite.Length + (index < 2 ? index : 2));
}
}
//验证去除括号内容后剩下表达式的有效性
MatchCollection expItems = regCutItem.Matches(expression);
//如果表达式没有括号且匹配结果数小于1 则表达式内容不符合规则
if (!haveBracketite && expItems.Count < 1) return false;
int indexOfItem = 0;
foreach (Match item in expItems)
{
indexOfItem++;
//获取表达式
string expItem = indexOfItem == expItems.Count ? item.Groups[3].Value : item.Groups[1].Value;
//验证表达式的有效性
if (!regValidMolecult.IsMatch(expItem)) return false;
}
return true;
}
/// <summary>
/// 获取表达式结果
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="prm"></param>
/// <returns></returns>
public static bool GetResult(string expression, Dictionary<string, object> prm)
{
if (!JudgeValid(expression)) throw new Exception("invalid expression");
//匹配出所有括号内的内容计算结果并根据结果替换对应的值
while (regSmallBracket.IsMatch(expression))
{
MatchCollection collection = regSmallBracket.Matches(expression);
foreach (Match bracketite in collection)
{
//表达式内容赋值
string expBracketite = bracketite.Value;
int index = expression.IndexOf(expBracketite);
//获取表达式计算后的结果
bool result = MosaicLambda(expBracketite.Substring(1, expBracketite.Length - 2), prm);
//根据结果将括号内表达式替换成不同字符串
expression = expression.Remove(index, expBracketite.Length).Insert(index, result ? trueText : falseText);
}
}
return MosaicLambda(expression, prm);
}
/// <summary>
/// 获取表达式结果
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
static bool GetResult(string expression)
{
return GetResult(expression, new Dictionary<string, object>());
}
/// <summary>
/// 拼接动态Lambda并获取结果
/// </summary>
/// <param name="expression"></param>
/// <param name="prm"></param>
/// <returns></returns>
static bool MosaicLambda(string expression, Dictionary<string, object> prm)
{
//Fields
Expression lambda = null;
string connector = null;
MatchCollection items = regCutItem.Matches(expression);
int indexOfItem = 0;
foreach (Match item in items)
{
indexOfItem++;
Expression left = null, right = null;
BinaryExpression binary = null;
//获取表达式
string expItem = indexOfItem == items.Count ? item.Groups[3].Value : item.Groups[1].Value;
Match Molecule = regCutMolecule.Matches(expItem)[0];
//判断左边是否是字段
if (regGetField.IsMatch(Molecule.Groups[1].Value))
{
string field = regGetField.Matches(Molecule.Groups[1].Value)[0].Groups[1].Value;
if (!prm.ContainsKey(field)) throw new Exception($"未提供必须字段[{field}]");
left = Expression.Constant(prm[field]);
}
else
{
object v = null;
Type t = TryGetType(Molecule.Groups[1].Value, out v);
left = Expression.Constant(v, t);
}
//判断右边是否是字段
if (regGetField.IsMatch(Molecule.Groups[3].Value))
{
string field = regGetField.Matches(Molecule.Groups[3].Value)[0].Groups[1].Value;
if (!prm.ContainsKey(field)) throw new Exception($"未提供必须字段[{field}]");
right = Expression.Constant(prm[field]);
}
else
{
object v = null;
Type t = TryGetType(Molecule.Groups[3].Value, out v);
right = Expression.Constant(v, t);
}
if (left.Type != right.Type) throw new Exception("尝试比较两个不同数据类型的值");
//根据操作符选择合适的方法进行装载
switch (Molecule.Groups[2].Value)
{
case ">":
binary = Expression.GreaterThan(left, right);
break;
case ">=":
binary = Expression.GreaterThanOrEqual(left, right);
break;
case "=":
binary = Expression.Equal(left, right);
break;
case "<=":
binary = Expression.LessThanOrEqual(left, right);
break;
case "<":
binary = Expression.LessThan(left, right);
break;
default: throw new Exception("invalid charactor");
}
//根据上一个item设置的连接符进行相应的操作
if (connector == null) lambda = binary;
else
{
switch (connector)
{
case "&&":
lambda = Expression.And(lambda, binary);
break;
case "||":
lambda = Expression.Or(lambda, binary);
break;
default: throw new Exception("invalid charactor");
}
}
//And|Or赋值
connector = item.Groups[2].Value;
}
return Expression.Lambda<Func<bool>>(lambda).Compile().Invoke();
}
static Type TryGetType(string v, out object obj)
{
int i = default(int); float f = default(float); double d = default(double);
if (int.TryParse(v, out i)) { obj = i; return typeof(int); }
if (float.TryParse(v, out f)) { obj = f; return typeof(float); }
if (double.TryParse(v, out d)) { obj = d; return typeof(double); }
obj = v;
return typeof(string);
}
#endregion
}
}
