static void AddMember(ExpressionContext ctx, Type type)
{
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.GetField;
foreach (var m in type.GetMembers(bindingFlags))
{
var attr = m.GetCustomAttribute <ExportMemberAttribute>();
string name = string.IsNullOrEmpty(attr.Name) ? m.Name : attr.Name;
if (m is MethodInfo)
{
ctx.AddVariable(typeof(MethodInfo), name);
ctx.SetVariable(name, m);
}
else if (m is FieldInfo)
{
var fInfo = (FieldInfo)m;
ctx.AddVariable(fInfo.FieldType, name);
ctx.SetVariable(name, fInfo.GetValue(null));
}
else if (m is PropertyInfo)
{
var pInfo = (PropertyInfo)m;
ctx.AddVariable(pInfo.PropertyType, name);
ctx.SetVariable(name, pInfo.GetGetMethod().Invoke(null, null));
}
}
}
public void Block_SetVariable2()
{
var ctx = new ExpressionContext();
ctx.AddVariable <int>("int1", 1);
var int2 = Variable <int>("int2");
var int3 = Variable <int>("int3");
var expr = Block(
new ParameterExpression[] { int2 },
new Expression[] {
Assign(int2, Constant(2)),
Block(new ParameterExpression[] { int3 },
new Expression[] {
Assign(int3, Constant(3)),
Assign(Variable <int>("int1"), Add(int2, int3))
})
});
//System.Linq.Expressions.Expression
var result = Eval(expr, ctx);
Assert.IsTrue(ctx.ContainsVariable("int1"));
Assert.IsFalse(ctx.ContainsVariable("int2"));
Assert.IsFalse(ctx.ContainsVariable("int3"));
Assert.AreEqual(5, ctx.GetVariable("int1"));
Assert.AreEqual(null, result);
}
public void MethodCall_Overload()
{
var ctx = new ExpressionContext();
var obj = new MethodClass();
var objType = obj.GetType();
ctx.AddVariable <MethodClass>("target", obj);
var varTarget = Variable(objType, "target");
var result = Eval(new Dictionary <string, object>()
{
{ "target", obj }
},
Call(varTarget, "OverloadMethod", Constant(1)), ctx);
Assert.AreEqual(1, result);
result = Eval(new Dictionary <string, object>()
{
{ "target", obj }
},
Call(varTarget, "OverloadMethod", Constant("hello world")), ctx);
Assert.AreEqual("hello world", result);
}
public void Block_SetVariable()
{
var int1 = Variable <int>("int1");
var int2 = Variable <int>("int2");
var expr = Block(
new ParameterExpression[] {
int2
},
new Expression[] {
Assign(int2, Constant(2)),
Assign(int1, int2)
});
var ctx = new ExpressionContext();
ctx.AddVariable <int>("int1", 1);
var result = Eval(expr, ctx);
Assert.IsTrue(ctx.ContainsVariable("int1"));
Assert.IsFalse(ctx.ContainsVariable("int2"));
Assert.AreEqual(2, ctx.GetVariable("int1"));
Assert.AreEqual(null, result);
}
public void Logic()
{
CheckExpr("1<2", true);
CheckExpr("2<1", false);
CheckExpr("1<=2", true);
CheckExpr("2<=1", false);
CheckExpr("2>1", true);
CheckExpr("1>2", false);
CheckExpr("2>=1", true);
CheckExpr("1>=2", false);
CheckExpr("1==1", true);
CheckExpr("1==2", false);
CheckExpr("1!=2", true);
CheckExpr("1!=1", false);
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable <int>("a");
ctx.SetVariable("a", 1);
CheckExpr("a==1", true, ctx);
ctx = new ExpressionContext();
ctx.AddVariable <float>("a");
ctx.SetVariable("a", 1.1f);
CheckExpr("a==1.1", true, ctx);
}
private void TestVariable(string name, object value)
{
var ctx = new ExpressionContext();
ctx.AddVariable(value.GetType(), name, value);
Assert.IsTrue(ctx.ContainsVariable(name));
Assert.IsFalse(ctx.ContainsVariable("_" + name));
Assert.AreEqual(value, ctx.GetVariable(name));
}
public void Call_Static()
{
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable <MethodInfo>("Static_Add");
var mInfo = typeof(MyClass).GetMethod("Static_Add", BindingFlags.Public | BindingFlags.Static);
ctx.SetVariable("Static_Add", mInfo);
CheckExpr("Static_Add(1,2)", 3L, ctx);
}
public void Call_()
{
var dt = DateTime.Parse("1/2/2017 03:04:05");
var sss = dt.ToString();
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable(typeof(TestClass), "instance", new TestClass());
CompileContext compile = new CompileContext();
compile.AddVariable(typeof(TestClass), "instance");
Run(Resource1.call, compile, ctx);
}
public void Call_InstanceMethod()
{
var varObj = Variable <CallClass>("obj");
var expr = Call(varObj, "Hello");
var compile = new CompileContext();
var ctx = new ExpressionContext();
ctx.AddVariable <CallClass>("obj", new CallClass());
var result = compile.Compile(expr)(ctx);
Assert.AreEqual("Instance: Hello World", result);
}
public void TestInstanceFunc()
{
object result;
MyObj obj = new MyObj(1);
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable <Func <long, long> >("add");
ctx.SetVariable("add", new Func <long, long>(obj.Add));
CompileContext comple = new CompileContext(ctx);
var expr = ScriptExpressionReader.Instance.Parse("add(2)", comple);
result = comple.Compile(expr)(ctx);
Assert.AreEqual(result, 3L);
}
public void Call()
{
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable <MyClass>("obj");
ctx.SetVariable("obj", new MyClass()
{
});
CheckExpr("obj.Negate(1)", -1L, ctx);
CheckExpr("obj.Add(1,2)", 3L, ctx);
CheckExpr("obj.Add_ABC(1,2,3)", 6L, ctx);
// CheckExpr("obj.Sum_Params(1,2,3)", 6L, ctx);
CheckExpr("obj.Add(1,2)+obj.Add(3,4)", 10L, ctx);
}
public void Call_DelegateArgs1()
{
var varObj = Variable <string>("del");
var expr = Call(varObj, typeof(string), Constant("My"));
var compile = new CompileContext();
var ctx = new ExpressionContext();
ctx.AddVariable("del", new Func <string, string>((say) =>
{
return(say + ": Hello World");
}));
var result = compile.Compile(expr)(ctx);
Assert.AreEqual("My: Hello World", result);
}
public void Func_Var_Nest_Func()
{
var varI = Variable <int>("i");
var funcExpr = Function("func_i", Block(new ParameterExpression[] { varI },
Assign(varI, Constant(2)),
Return(Call(Function(null, Return(varI), typeof(int)), typeof(int)))), typeof(int));
var compile = new CompileContext();
//using (compile.BeginScope())
//{
compile.AddVariable <int>("i");
var tmp = compile.Compile(Call(funcExpr, typeof(int)));
var ctx = new ExpressionContext();
ctx.AddVariable <int>("i", 1);
var result = tmp(ctx);
Assert.AreEqual(2, result);
//}
}
public void Member()
{
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable <MyClass>("obj");
ctx.SetVariable("obj", new MyClass()
{
IntField = 1,
IntProperty = 2,
Next = new MyClass()
{
IntField = 3,
IntProperty = 4,
}
});
CheckExpr("obj.IntField", 1, ctx);
CheckExpr("obj.IntProperty", 2, ctx);
CheckExpr("obj.Next.IntField", 3, ctx);
CheckExpr("obj.Next.IntProperty", 4, ctx);
}
public void Type_Convert()
{
MyValue my = new MyValue("a");
string myStr = my;
Assert.AreEqual("a", myStr);
my = myStr;
Assert.AreEqual("a", my.Value);
MyValue2 my2 = new MyValue2("a2");
myStr = my2;
//my2 = myStr;//can't convert
Assert.AreEqual("a2", myStr);
MyValue3 my3 = myStr;
myStr = my3;
Func <object, Type, object> convert = (value, toType) =>
{
Type fromType = value.GetType();
InvocationDelegate eval;
var compile = new CompileContext();
compile.OverrideOperator(typeof(MyValue));
compile.AddVariable(fromType, "a");
using (compile.BeginScope())
{
var expr = Convert(Variable(fromType, "a"), toType);
eval = compile.Compile(expr);
}
ExpressionContext ctx = new ExpressionContext();
ctx.AddVariable(fromType, "a");
ctx.SetVariable("a", value);
return(eval(ctx));
};
object result;
result = convert(new MyValue("Hello World"), typeof(string));
Assert.AreEqual("Hello World", result);
result = convert("Hello World", typeof(MyValue));
Assert.AreEqual("Hello World", ((MyValue)result).Value);
result = convert(new MyValue2("Hello World"), typeof(string));
Assert.AreEqual("Hello World", result);
try
{
result = convert("Hello World", typeof(MyValue2));
Assert.AreEqual("Hello World", ((MyValue2)result).Value);
Assert.Fail();
}
catch (OperatorNotImplementedException ex) { }
result = convert(new MyValue3("Hello World"), typeof(string));
Assert.AreEqual("Hello World", result);
result = convert("Hello World", typeof(MyValue3));
Assert.AreEqual("Hello World", ((MyValue3)result).Value);
}
