public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
StringBuilder sb = new StringBuilder();
int b = sr.Read();
if (b == -1 || b != START_MARK)
{
throw new FormatException("不是有效的时间开始");
}
while ((b = sr.Read()) != -1)
{
char c = (char)b;
if (c == END_MARK)
{
return(new Element(FormatTime(sb.ToString()),
index, ElementType.DATE));
}
if (DATE_CHARS.IndexOf(c) == -1)
{
throw new FormatException("时间类型不能包函非法字符：" + c);
}
sb.Append(c);
}
throw new FormatException("不是有效的时间结束");
}
/// <summary>
/// Prepara o leitor de expressões para lidar com o maior número de objectos possível.
/// </summary>
/// <returns>O leitor de expressões.</returns>
private ExpressionReader <AMathematicsObject, string, string> PrepareExpressionReader()
{
var result = new ExpressionReader <AMathematicsObject, string, string>(new MathematicsObjectParser(this.mediator));
result.RegisterBinaryOperator("equal", this.Assign, 0);
result.RegisterBinaryOperator("plus", this.Add, 2);
result.RegisterBinaryOperator("times", this.Multiply, 3);
result.RegisterBinaryOperator("minus", this.Subtract, 2);
result.RegisterBinaryOperator("over", this.Divide, 3);
result.RegisterUnaryOperator("minus", this.Symmetric, 2);
result.RegisterBinaryOperator("hat", this.Exponentiate, 4);
result.RegisterBinaryOperator("double_equal", this.AreEqual, 1);
result.RegisterBinaryOperator("great_than", this.GreaterThan, 1);
result.RegisterBinaryOperator("great_equal", this.GreaterOrEqualThan, 1);
result.RegisterBinaryOperator("less_than", this.LesserThan, 1);
result.RegisterBinaryOperator("less_equal", this.LesserOrEqualThan, 1);
result.RegisterBinaryOperator("double_or", this.LogicalDisjunction, 2);
result.RegisterBinaryOperator("double_and", this.LogicalConjunction, 3);
result.RegisterExpressionDelimiterTypes("left_parenthesis", "right_parenthesis");
result.RegisterSequenceDelimiterTypes("left_parenthesis", "right_parenthesis");
result.RegisterSequenceDelimiterTypes("left_bracket", "right_bracket");
result.RegisterExternalDelimiterTypes("left_bracket", "right_bracket");
result.RegisterExternalDelimiterTypes("left_brace", "right_brace");
result.RegisterExternalDelimiterTypes("double_quote", "double_quote");
result.AddVoid("blancks");
return(result);
}
public void Start()
{
this.connection = new SqlConnection(SQLHelpers.GetConnectionString(SQLServer, SQLUser, SQLPassword, SQLUseSQLAuth, SQLDatabase));
Grid sortGrid = new Grid
{
Value = config["SortGrid"]
};
SortClause = "";
foreach (var row in sortGrid.Rows)
{
SortClause += " " + row["SortColumn"].ToString() + " " + row["SortOrder"] + ",";
}
if (!String.IsNullOrWhiteSpace(SortClause))
{
SortClause = " ORDER BY " + SortClause.TrimEnd(',');
}
WhereClause = "";
if (Filters != "null" && !string.IsNullOrWhiteSpace(Filters))
{
filterExpression = ExpressionReader.Evaluate(Filters);
WhereClause = filterExpression.ConvertToSQL();
if (!string.IsNullOrWhiteSpace(WhereClause))
{
WhereClause = "WHERE " + WhereClause;
}
}
TopClause = MaxRows > 0 ? "TOP " + MaxRows : "";
}
public SetParser(IParse <ObjectType, string, ESymbolSetType> elementsParser)
{
if (elementsParser == null)
{
throw new ArgumentNullException("elementsParser");
}
else
{
this.expressionReader = new ExpressionReader <HashSet <ObjectType>, string, ESymbolSetType>(
new HashSetParser(elementsParser));
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.OPAR, ESymbolSetType.CPAR);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.LBRACK, ESymbolSetType.RBRACK);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.LANGLE, ESymbolSetType.RANGLE);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.LBRACK, ESymbolSetType.RANGLE);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.LANGLE, ESymbolSetType.RBRACK);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.VBAR, ESymbolSetType.VBAR);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.VBAR, ESymbolSetType.RANGLE);
this.expressionReader.RegisterExternalDelimiterTypes(ESymbolSetType.LANGLE, ESymbolSetType.VBAR);
this.expressionReader.RegisterBinaryOperator(ESymbolSetType.COMMA, this.Concatenate, 0);
this.expressionReader.AddVoid(ESymbolSetType.SPACE);
this.expressionReader.AddVoid(ESymbolSetType.CHANGE_LINE);
}
}
public void ReadNullActionResultThrowsException()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = null;
Assert.Throws<ArgumentNullException>(() => reader.Read(args));
}
public static char ESCAPE_MARK = '\\'; //转义符号
public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
var sb = new StringBuilder();
int b = sr.Read();
if (b == -1 || b != START_MARK)
{
throw new FormatException("不是有效的字符窜开始");
}
while ((b = sr.Read()) != -1)
{
char c = (char)b;
if (c == ESCAPE_MARK)
{//遇到转义字符
c = GetEscapeValue((char)sr.Read());
}
else if (c == END_MARK)
{//遇到非转义的引号
return(new Element(sb.ToString(), index, ElementType.STRING));
}
sb.Append(c);
}
throw new FormatException("不是有效的字符窜结束");
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="MathematicsInterpreter"/>.
/// </summary>
public MathematicsInterpreter()
{
this.currentResult = new MathematicsInterpreterResult();
this.mediator = new MathematicsInterpreterMediator();
this.expressionReader = this.PrepareExpressionReader();
this.InitStates();
this.Reset();
}
public void ReadNullObjectThrowsException()
{
var reader = new ExpressionReader();
Expression <Func <TestApiController, object> > args = null;
Assert.Throws <ArgumentNullException>(() => reader.Read(args));
}
public void ReadDoesNotGetAreaName()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
Assert.That(result.ContainsKey("area"), Is.False);
}
public void ReadDoesNotGetAreaNameWHenNotPresent()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
Assert.That(result.Area, Is.Empty);
}
public void ReadDoesNotGetAreaNameWHenNotPresent()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.Index();
var result = reader.Read(args);
Assert.That(result.Area, Is.Empty);
}
public static string DOUBLE_MARKS = "dD"; //double的结尾标志
public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
string s = string.Empty;
int b = -1;
while ((b = sr.Read()) != -1)
{
char c = (char)b;
if (NUMBER_CHARS.IndexOf(c) == -1)
{
if (LONG_MARKS.IndexOf(c) >= 0)
{
if (s.IndexOf(".") >= 0)
{//有小数点
throw new FormatException("long类型不能有小数点");
}
return(new Element(s.ToString(), index, ElementType.LONG));
}
else if (FLOAT_MARKS.IndexOf(c) >= 0)
{
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.FLOAT));
}
else if (DOUBLE_MARKS.IndexOf(c) >= 0)
{
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.DOUBLE));
}
else
{
sr.Reset();
if (s.IndexOf(".") >= 0)
{//没有结束标志，有小数点，为double
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.DOUBLE));
}
else
{//没有结束标志，无小数点，为int
return(new Element(s.ToString(), index, ElementType.INT));
}
}
}
s += c;
sr.Mark(0);
}
//读到结未
if (s.IndexOf(".") >= 0)
{//没有结束标志，有小数点，为double
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.DOUBLE));
}
else
{//没有结束标志，无小数点，为int
return(new Element(s.ToString(), index, ElementType.INT));
}
}
public void ReadGetsActionFromAttributeWhenPresent()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.MethodName();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Test"));
Assert.That(result.Action, Is.EqualTo("ActionNameAttribute"));
}
public void Test012()
{
var xpr = new ExpressionReader();
var expr = Expression.Convert(Expression.Default(typeof(int)), typeof(decimal));
var result = xpr.GetTrueUnderlyingType(expr);
Assert.AreEqual(result, typeof(int));
}
public void Test011()
{
var xpr = new ExpressionReader();
var expr = Expression.UnaryPlus(Expression.Default(typeof(int)));
var result = xpr.GetTrueUnderlyingType(expr);
Assert.AreEqual(result, typeof(int));
}
public void CanReadVoidMethod()
{
var reader = new ExpressionReader();
Expression <Action <MemberController> > args = c => c.DoNothing();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Member"));
Assert.That(result.Action, Is.EqualTo("DoNothing"));
}
public void CanReadVoidMethod()
{
var reader = new ExpressionReader();
Expression<Action<MemberController>> args = c => c.DoNothing();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Member"));
Assert.That(result.Action, Is.EqualTo("DoNothing"));
}
public void ReadGetsApiControllerAndAction()
{
var reader = new ExpressionReader();
Expression<Func<TestApiController, object>> args = c => c.Get();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("TestApi"));
Assert.That(result.Action, Is.EqualTo("Get"));
}
public void ReadGetsControllerAndAction()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.Index();
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("Test"));
Assert.That(result["action"], Is.EqualTo("Index"));
}
public void ReadReturnsValidRouteValues()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.Index();
var result = reader.Read(args);
result.CheckDataOk();
Assert.That(result.DataOk, Is.True);
}
public void ReadReturnsDictionary()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.Index();
var result = reader.Read(args);
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.GreaterThan(0));
}
public void ReadGetsControllerAndAction()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("Test"));
Assert.That(result["action"], Is.EqualTo("Index"));
}
public void ReadGetsApiControllerAndAction()
{
var reader = new ExpressionReader();
Expression <Func <TestApiController, object> > args = c => c.Get();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("TestApi"));
Assert.That(result.Action, Is.EqualTo("Get"));
}
public void ReadReturnsDictionary()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.GreaterThan(0));
}
public void ReadGetsMethodParams()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.GetItem(42);
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("Test"));
Assert.That(result["action"], Is.EqualTo("GetItem"));
Assert.That(result["id"], Is.EqualTo("42"));
}
public void ReadGetsMethodParam()
{
var reader = new ExpressionReader();
Expression <Func <TestApiController, object> > args = c => c.Post(42);
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("TestApi"));
Assert.That(result.Action, Is.EqualTo("Post"));
Assert.That(result.Values.FindByName("id").Value, Is.EqualTo(42));
}
public void ReadGetsMethodParam()
{
var reader = new ExpressionReader();
Expression <Func <TestApiController, object> > args = c => c.Post(42);
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("TestApi"));
Assert.That(result["action"], Is.EqualTo("Post"));
Assert.That(result["id"], Is.EqualTo("42"));
}
public void ReadGetsMethodParam()
{
var reader = new ExpressionReader();
Expression<Func<TestApiController, object>> args = c => c.Post(42);
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("TestApi"));
Assert.That(result.Action, Is.EqualTo("Post"));
Assert.That(result.Values.FindByName("id").Value, Is.EqualTo(42));
}
public void ReadGetsAreaNameWhenPresent()
{
var reader = new ExpressionReader();
Expression<Func<Areas.SomeArea.Controllers.TestController, ActionResult>> args = c => c.Index();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Test"));
Assert.That(result.Action, Is.EqualTo("Index"));
Assert.That(result.Area, Is.EqualTo("SomeArea"));
}
public void ReadGetsAreaNameWhenPresent()
{
var reader = new ExpressionReader();
Expression <Func <Areas.SomeArea.Controllers.TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Test"));
Assert.That(result.Action, Is.EqualTo("Index"));
Assert.That(result.Area, Is.EqualTo("SomeArea"));
}
public void ReadGetsMethodParams()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.GetItem(42);
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Test"));
Assert.That(result.Action, Is.EqualTo("GetItem"));
Assert.That(result.Values.ValueByName("id"), Is.EqualTo(42));
}
public void ReadGetsMethodParam()
{
var reader = new ExpressionReader();
Expression<Func<TestApiController, object>> args = c => c.Post(42);
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("TestApi"));
Assert.That(result["action"], Is.EqualTo("Post"));
Assert.That(result["id"], Is.EqualTo("42"));
}
public void ReadReturnsValidRouteValues()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
result.CheckDataOk();
Assert.That(result.DataOk, Is.True);
}
public void ReadGetsMethodParams()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.GetItem(42);
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Test"));
Assert.That(result.Action, Is.EqualTo("GetItem"));
Assert.That(result.Values.ValueByName("id"), Is.EqualTo(42));
}
public void ReadGetsAreaName()
{
var reader = new ExpressionReader();
Expression <Func <Areas.SomeArea.TestController, ActionResult> > args = c => c.Index();
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("Test"));
Assert.That(result["action"], Is.EqualTo("Index"));
Assert.That(result["area"], Is.EqualTo("SomeArea"));
}
public void ReadGetsMethodParams()
{
var reader = new ExpressionReader();
Expression <Func <TestController, ActionResult> > args = c => c.GetItem(42);
var result = reader.Read(args);
Assert.That(result["controller"], Is.EqualTo("Test"));
Assert.That(result["action"], Is.EqualTo("GetItem"));
Assert.That(result["id"], Is.EqualTo("42"));
}
public void Test004()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var expr = xgr.FromFunc(() => default(IQueryable <int>).Where(x => x > 10));
var result = xpr.GetLambda(expr);
Assert.AreEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(LambdaExpression));
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="BoolExpressionParser"/>.
/// </summary>
public BoolExpressionParser()
{
this.expressionReader = new ExpressionReader <bool, string, string>(
new BoolParser <string>());
this.expressionReader.RegisterBinaryOperator("double_or", Or, 0);
this.expressionReader.RegisterBinaryOperator("double_and", And, 1);
this.expressionReader.RegisterUnaryOperator("tild", Not, 0);
this.expressionReader.RegisterExpressionDelimiterTypes("left_parenthesis", "right_parenthesis");
this.expressionReader.AddVoid("blancks");
this.expressionReader.AddVoid("space");
this.expressionReader.AddVoid("carriage_return");
this.expressionReader.AddVoid("new_line");
}
public static string SPLITOR_CHAR = "(),";//所有分割符
public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
int b = sr.Read();
char c = (char)b;
if (b == -1 || SPLITOR_CHAR.IndexOf(c) == -1)
{
throw new FormatException("不是有效的分割字符");
}
return(new Element(c.ToString(), index,
ElementType.SPLITOR));
}
public void Test001()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var expr = xgr.FromFunc(()=>default(IQueryable<int>).Where(x=>x > 10));
var expr2 = ((MethodCallExpression)expr.Body).Arguments[1];
var body = xpr.GetLambda(expr2);
Assert.AreNotEqual(expr2, body);
Assert.IsInstanceOfType(body, typeof(LambdaExpression));
}
public void Test010()
{
var xpr = new ExpressionReader();
var xcr = new ExpressionComparer();
var expr = Expression.UnaryPlus(Expression.Default(typeof(int)));
var result = xpr.StripConvert(expr);
Assert.AreEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(UnaryExpression));
Assert.IsTrue(xcr.AreEqual(Expression.UnaryPlus(Expression.Default(typeof(int))), result));
}
public void Test001()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var expr = xgr.FromFunc(() => default(IQueryable <int>).Where(x => x > 10));
var expr2 = ((MethodCallExpression)expr.Body).Arguments[1];
var body = xpr.GetLambda(expr2);
Assert.AreNotEqual(expr2, body);
Assert.IsInstanceOfType(body, typeof(LambdaExpression));
}
public void Test005()
{
var xpr = new ExpressionReader();
var xcr = new ExpressionComparer();
var expr = Expression.Convert(Expression.Convert(Expression.Default(typeof(byte)), typeof(short)), typeof(int));
var result = xpr.StripConvert(expr);
Assert.AreNotEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(DefaultExpression));
Assert.IsTrue(xcr.AreEqual(Expression.Default(typeof(byte)), result));
}
public void ReadApiReturnsRouteValues()
{
var reader = new ExpressionReader();
Expression<Func<TestApiController, object>> args = c => c.Get();
var result = reader.Read(args);
Assert.That(result, Is.Not.Null);
Assert.That(result.Controller, Is.EqualTo("TestApi"));
Assert.That(result.Action, Is.EqualTo("Get"));
Assert.That(result.Area, Is.Empty);
Assert.That(result.Values, Is.Not.Null);
Assert.That(result.Values.Count, Is.EqualTo(0));
}
public void Test003()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Call(
typeof(Queryable),
"Where",
new[] { typeof(int) },
Expression.Default(typeof(IQueryable<int>)),
Expression.Constant(
Expression.Lambda<Func<int, bool>>(
Expression.GreaterThan(param1, Expression.Constant(10)),
param1
)
)
);
var result = xpr.GetLambda(expr);
Assert.IsNull(result);
}
public void Test002()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Call(
typeof(Queryable),
"Where",
new [] { typeof(int) },
Expression.Default(typeof(IQueryable<int>)),
Expression.Constant(
Expression.Lambda<Func<int, bool>>(
Expression.GreaterThan(param1, Expression.Constant(10)),
param1
)
)
);
var expr2 = expr.Arguments[1];
var result = xpr.GetLambda(expr2);
Assert.AreNotEqual(expr2, result);
Assert.IsInstanceOfType(result, typeof(LambdaExpression));
}
public void Test010()
{
var xpr = new ExpressionReader();
var xcr = new ExpressionComparer();
var expr = Expression.UnaryPlus(Expression.Default(typeof(int)));
var result = xpr.StripConvert(expr);
Assert.AreEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(UnaryExpression));
Assert.IsTrue(xcr.AreEqual(Expression.UnaryPlus(Expression.Default(typeof(int))), result));
}
public void Test011()
{
var xpr = new ExpressionReader();
var expr = Expression.UnaryPlus(Expression.Default(typeof(int)));
var result = xpr.GetTrueUnderlyingType(expr);
Assert.AreEqual(result, typeof(int));
}
public void Test013()
{
var xpr = new ExpressionReader();
var xcr = new ExpressionComparer();
var expr = Expression.Convert(
Expression.Convert(
Expression.Default(typeof(int)),
typeof(decimal)),
typeof(long)
);
var result = xpr.GetTrueUnderlyingType(expr);
Assert.AreEqual(result, typeof(int));
}
public void Test004()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var expr = xgr.FromFunc(() => default(IQueryable<int>).Where(x => x > 10));
var result = xpr.GetLambda(expr);
Assert.AreEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(LambdaExpression));
}
public void Test005()
{
var xpr = new ExpressionReader();
var xcr = new ExpressionComparer();
var expr = Expression.Convert(Expression.Convert(Expression.Default(typeof(byte)), typeof(short)), typeof(int));
var result = xpr.StripConvert(expr);
Assert.AreNotEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(DefaultExpression));
Assert.IsTrue(xcr.AreEqual(Expression.Default(typeof(byte)), result));
}
public void ReadGetsActionFromAttributeWhenPresent()
{
var reader = new ExpressionReader();
Expression<Func<TestController, ActionResult>> args = c => c.MethodName();
var result = reader.Read(args);
Assert.That(result.Controller, Is.EqualTo("Test"));
Assert.That(result.Action, Is.EqualTo("ActionNameAttribute"));
}
