static void Main(string[] args)
{
Console.Title = "表达式测试";
Console.WriteLine("Please input expression...");
string cmd = Console.ReadLine();
while (cmd.ToLower() != "exit")
{
if (string.IsNullOrEmpty(cmd) == false)
{
try
{
Console.WriteLine("This result is \n{0}", ExpressionParser.Calculate(cmd, UserFunctionImpl, null));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
cmd = Console.ReadLine();
}
}
public static IList <Member> GetCalculatedGroupMembers(string condition)
{
var allMembers = MemberAdapter.Instance.LoadAll();
var result = allMembers.FindAll(p => { return((bool)ExpressionParser.Calculate(condition, new CalculateUserFunction(CalulateFunction), p)); });
return(result);
}
public void CalculateTypeNameFunctionTest()
{
object result = ExpressionParser.Calculate("TypeName", BuiltInFuncWrapper.Instance, "World");
Console.WriteLine(result);
Assert.AreEqual(typeof(BuiltInFuncWrapper).FullName, result);
}
public void CalculateStaticAddFunctionTest()
{
object result = ExpressionParser.Calculate("StaticAdd(3, 4)", BuiltInFuncWrapper.Instance, null);
Console.WriteLine(result);
Assert.AreEqual(7, result);
}
public void CalculateGenderNameFunctionTest()
{
object result = ExpressionParser.Calculate("GenderName(2)", BuiltInFuncWrapper.Instance, null);
Console.WriteLine(result);
Assert.AreEqual("Female", result);
}
bool MatchesFilter(string text)
{
if (_filter == null)
{
return(true);
}
return(_filter.Calculate(filter => MatchesFilter(text, filter)));
}
public void CalculateCombineFunctionTest()
{
object result = ExpressionParser.Calculate("Combine(\"Hello \")", BuiltInFuncWrapper.Instance, "World");
Console.WriteLine(result);
Assert.AreEqual("Hello World", result);
}
public void CalculateUserDictionaryTest()
{
object age = ExpressionParser.Calculate("Users(\"Age\")");
Console.WriteLine(age);
Assert.AreEqual(42, age);
}
public void IIFMatchSecondTest()
{
List <int> list = new List <int>();
Assert.AreEqual(2, ExpressionParser.Calculate("IIF(3 > 4, data1, data2)",
InternalCalculateFunction, list));
Assert.AreEqual(1, list.Count);
}
public void InFunctionMatchSecondTest()
{
List <int> list = new List <int>();
Assert.IsTrue((bool)ExpressionParser.Calculate("IN(2, data1, data2, 5, 7, 9)",
InternalCalculateFunction, list));
Assert.AreEqual(2, list.Count);
}
private IEnumerable <(double x, double y)> PrepareData()
{
double coef = Function.MaxX / Diagram.Quantity;
for (int i = 0; i <= Diagram.Quantity; i++)
{
yield return(
x : i * coef,
y : ExpressionParser.Calculate(Function.Expression, i * coef));
}
}
private string FindActivityKeyByActivityDescription(IWfProcessDescriptor processDesp, WfCreateActivityParam currentCap, string toActivityDesp)
{
WfCreateActivityFunctionContext context = new WfCreateActivityFunctionContext(processDesp, this, currentCap);
int sn = 0;
if (int.TryParse(toActivityDesp, out sn))
{
toActivityDesp = string.Format("SN({0})", sn);
}
return((string)ExpressionParser.Calculate(toActivityDesp, new CalculateUserFunction(WfCreateActivityBuiltInFunctions.Instance.Calculate), context));
}
private void buttonApply_Click(object sender, EventArgs e)
{
try
{
_filter = new ExpressionParser(textBoxFilter.Text);
_filter.Calculate(str => true);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Invalid filter!", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
refreshLists();
}
private void FilterUsersByConditions(SCConditionCollection conditions, SchemaObjectCollection result, string description)
{
ProcessProgress.Current.MaxStep += conditions.Count;
ProcessProgress.Current.Response();
foreach (SCCondition condition in conditions)
{
if (condition.Condition.IsNotEmpty() && condition.Status == SchemaObjectStatus.Normal)
{
try
{
foreach (SCUser user in this.Context.AllObjects)
{
this.Context.CurrentObject = user;
try
{
//计算表达式
object booleanResult = ExpressionParser.Calculate(condition.Condition, new CalculateUserFunction(CalculateUserFunction), this.Context);
if ((booleanResult is bool) == false)
{
throw new FormatException("指定的表达式未能解析为Bool值:" + Environment.NewLine + condition.Condition);
}
if ((bool)booleanResult)
{
result.AddNotExistsItem(user);
}
}
finally
{
this.Context.CurrentObject = null;
}
}
}
catch (ParsingException ex)
{
ProcessProgress.Current.Error.WriteLine("解析{0}的条件{1}出错: {2}", description, condition.Condition, ex.Message);
}
}
}
ProcessProgress.Current.Increment();
ProcessProgress.Current.Response();
}
public bool Evaluate()
{
bool result = true;
if (string.IsNullOrEmpty(this._Condition) == false)
{
try
{
result = (bool)ExpressionParser.Calculate(this._Condition, new CalculateUserFunction(WfContext.Current.OnCalculateUserFunction), null);
}
catch (System.Exception ex)
{
ExceptionHelper.FalseThrow(false, "±í´ïʽ½âÎö´íÎó£º({0})\n{1}", this._Condition, ex.Message);
}
}
return(result);
}
public bool Evaluate(CalculateUserFunction cuf)
{
bool result = true;
if (string.IsNullOrEmpty(this._Expression) == false)
{
try
{
result = (bool)ExpressionParser.Calculate(this._Expression,
cuf,
this);
}
catch (System.Exception ex)
{
ExceptionHelper.FalseThrow(false,
Translator.Translate(WfHelper.CultureCategory, "表达式解析错误：({0})\n{1}", this._Expression, ex.Message));
}
}
return(result);
}
private void FilterItemsByConditions(SCConditionCollection conditions, SchemaObjectCollection result, string description)
{
ProcessProgress.Current.MaxStep += conditions.Count;
ProcessProgress.Current.Response();
foreach (SCCondition condition in conditions)
{
if (condition.Condition.IsNotEmpty() && condition.Status == SchemaObjectStatus.Normal)
{
try
{
foreach (SchemaObjectBase obj in this.Context.AllObjects)
{
this.Context.CurrentObject = obj;
try
{
//计算表达式
if ((bool)ExpressionParser.Calculate(condition.Condition, new CalculateUserFunction(CalculateObjectFunction), this.Context))
{
result.AddNotExistsItem(obj);
}
}
finally
{
this.Context.CurrentObject = null;
}
}
}
catch (ParsingException ex)
{
ProcessProgress.Current.Error.WriteLine("解析{0}的条件{1}出错: {2}", description, condition.Condition, ex.Message);
}
}
}
ProcessProgress.Current.Increment();
ProcessProgress.Current.Response();
}
public void SimpleNotInFunctionTest()
{
Assert.IsFalse((bool)ExpressionParser.Calculate("IN(6, 1, 3, 5, 7, 9)"));
}
public void SimpleInFunctionTest()
{
Assert.IsTrue((bool)ExpressionParser.Calculate("IN(3, 1, 3, 5, 7, 9)"));
}
private static bool EvaluateExp(string exp, ExpContext context)
{
return((bool)ExpressionParser.Calculate(exp, new CalculateUserFunction(ExpCalculateUserFunction), context));
}
