public static void TestClassAndStruct()
{
//动态创建Action委托
Delegate newMethod = EHandler.CreateMethod <ENull>((il) =>
{
EModel model = null;
//测试类的字段
//model = EModel.CreateModel<ClassField>().UseDefaultConstructor();
//测试类的属性
//model = EModel.CreateModel<ClassProperty>().UseDefaultConstructor();
//测试结构体的字段
model = EModel.CreateModel <StructField>();
//测试结构体的属性
//model = EModel.CreateModel<StructProperty>();
model.Set("PublicName", "This is Public-Name");
model.Set("PrivateName", "This is Private-Name");
model.Set("PublicAge", 666);
model.Set("PrivateAge", 666);
EMethod method = typeof(Console);
method.ExecuteMethod <string>("WriteLine", model.DLoadValue("PrivateName").DelayAction);
method.ExecuteMethod <string>("WriteLine", model.LoadValue("PublicName"));
method.ExecuteMethod <int>("WriteLine", model.LoadValue("PublicAge"));
method.ExecuteMethod <int>("WriteLine", model.LoadValue("PrivateAge"));
}).Compile();
((Action)newMethod)();
}
public static void TestIf()
{
Delegate showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(10);
EVar emit_B = EVar.CreateVarFromObject(20);
TestClass t = new TestClass()
{
Field = 10
};
t.PropertyName = "3";
EModel model = EModel.CreateModelFromObject(t);
EJudge.If(emit_A == model.DLoadValue("Field").Operator)(() =>
{
method.ExecuteMethod <string>("WriteLine", "相等");
}).ElseIf(emit_A > emit_B)(() =>
{
method.ExecuteMethod <int>("WriteLine", emit_A);
}).Else(() =>
{
method.ExecuteMethod <int>("WriteLine", emit_B);
});
EVar string_A = "6";
EVar string_B = "2";
EJudge.If(string_A == "1")(() =>
{
method.ExecuteMethod <string>("WriteLine", string_A);
}).ElseIf(string_A == model.DLoadValue("PropertyName").Operator)(() =>
{
method.ExecuteMethod <string>("WriteLine", string_A);
}).Else(() =>
{
method.ExecuteMethod <string>("WriteLine", string_B);
});
}).Compile();
((Action)showResult)();
}
public static void TestOperator()
{
Delegate showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12);
EVar emit_B = EVar.CreateVarFromObject(13);
method.ExecuteMethod <int>("WriteLine", emit_A + emit_B);
method.ExecuteMethod <int>("WriteLine", emit_A + 1);
method.ExecuteMethod <int>("WriteLine", 1 + 1);
method.ExecuteMethod <int>("WriteLine", emit_B++);
}).Compile();
((Action)showResult)();
TestClass t = new TestClass();
t.Field = 10;
t.Property = 20;
TestStruct t2 = new TestStruct();
t2.Field = 90;
t2.Property = 80;
t.Next = t2;
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12);
EVar emit_B = EVar.CreateVarFromObject(13);
EModel model = EModel.CreateModelFromObject(t);
method.ExecuteMethod <int>("WriteLine", model.DLoadValue("Field").DelayAction);
method.ExecuteMethod <int>("WriteLine", (model.DLoadValue("Field").Operator++).DelayAction);
method.ExecuteMethod <int>("WriteLine", model.DLoadValue("Field") + emit_A);
method.ExecuteMethod <int>("WriteLine", model.DLoadValue("Field").Operator + 10);
method.ExecuteMethod <int>("WriteLine", (model.DLoad("Next").DLoadValue("Property").Operator++).DelayAction);
method.ExecuteMethod <int>("WriteLine", (model.DLoad("Next").DLoadValue("Property").Operator + 10));
method.ExecuteMethod <int>("WriteLine", emit_B + model.DLoadValue("Property").Operator);
method.ExecuteMethod <int>("WriteLine", emit_B++);
}).Compile();
((Action)showResult)();
}
public void TestField()
{
FieldStruct model = new FieldStruct();
model.ValueField = 100;
model.RefField = "Test";
FieldStruct.StaticRefField = "Static";
FieldStruct.StaticValueField = 200;
Delegate test = EHandler.CreateMethod <FieldStruct>((il) =>
{
EModel modelHandler = EModel.CreateModelFromObject(model);
modelHandler.Set("ValueField", modelHandler.DLoadValue("ValueField").Operator + modelHandler.DLoadValue("StaticValueField").DelayAction);
modelHandler.Set("StaticValueField", modelHandler.DLoadValue("ValueField").Operator + modelHandler.DLoadValue("StaticValueField").DelayAction);
modelHandler.Set("RefField", modelHandler.DLoadValue("RefField").Operator + modelHandler.DLoadValue("StaticRefField").DelayAction);
modelHandler.Load();
}).Compile();
Func <FieldStruct> action = (Func <FieldStruct>)test;
FieldStruct result = action();
Assert.Equal((ulong)300, result.ValueField);
Assert.Equal((ulong)500, FieldStruct.StaticValueField);
Assert.Equal("TestStatic", result.RefField);
}
public void TestField()
{
FieldClass model = new FieldClass();
model.ValueField = ulong.MaxValue;
model.RefField = "Test";
FieldClass.StaticRefField = "Static";
FieldClass.StaticValueField = ulong.MinValue;
Delegate test = EHandler.CreateMethod <FieldClass>((il) =>
{
EModel modelHandler = EModel.CreateModelFromObject(model);
modelHandler.Set("ValueField", ulong.MaxValue);
modelHandler.Set("StaticValueField", ulong.MinValue);
modelHandler.Set("RefField", modelHandler.DLoadValue("RefField").Operator + modelHandler.DLoadValue("StaticRefField").DelayAction);
modelHandler.Load();
}).Compile();
Func <FieldClass> action = (Func <FieldClass>)test;
FieldClass result = action();
Assert.Equal(ulong.MaxValue, result.ValueField);
Assert.Equal(ulong.MinValue, FieldClass.StaticValueField);
Assert.Equal("TestStatic", result.RefField);
}
public static void TestWhile()
{
Delegate showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(16);
EVar emit_B = EVar.CreateVarFromObject(20);
ELoop.While(emit_A < emit_B)(() =>
{
method.ExecuteMethod <int>("WriteLine", emit_B);
emit_B--;
});
TestClass t = new TestClass()
{
Field = 10
};
EModel model = EModel.CreateModelFromObject(t);
ELoop.While(model.DLoadValue("Field").Operator < emit_B)(() =>
{
//这里需要传递委托，不传递委托则返回的是model类型而不是int类型
method.ExecuteMethod <int>("WriteLine", model.DLoadValue("Field").DelayAction);
model.DLoadValue("Field").Operator++;
});
ELoop.While(model.DLoadValue("Field").Operator != 25)(() =>
{
method.ExecuteMethod <int>("WriteLine", model.DLoadValue("Field").DelayAction);
model.DLoadValue("Field").Operator++;
});
}).Compile();
((Action)showResult)();
}
public static void Create(Type TypeHandler)
{
Delegate func = EHandler.CreateMethod <object, bool>((il) =>
{
LocalBuilder builder = il.DeclareLocal(TypeHandler);
il.REmit(OpCodes.Ldarg_0);
il.REmit(OpCodes.Unbox_Any, TypeHandler);
il.REmit(OpCodes.Stloc_S, builder);
EVar returnTrueResult = true;
EVar returnFalseResult = false;
EModel model = EModel.CreateModelFromBuilder(builder, TypeHandler);
#region Property
Dictionary <string, PropertyInfo> properties = model.Struction.Properties;
foreach (var item in properties)
{
DebugHelper.WriteLine("检测" + item.Key + "是否为默认值:");
Type type = item.Value.PropertyType;
if (type.IsValueType && type.IsPrimitive)
{
EJudge.If(EDefault.IsDefault(type, () => { model.LPropertyValue(item.Key); }))(() =>
{
}).Else(() =>
{
MethodHelper.ReturnValue(false);
});
}
else if (type.IsClass)
{
EJudge.If(ENull.IsNull(() => { model.LPropertyValue(item.Key); }))(() =>
{
}).Else(() =>
{
MethodHelper.ReturnValue(false);
});
}
}
#endregion
#region Fields
Dictionary <string, FieldInfo> fields = model.Struction.Fields;
foreach (var item in fields)
{
DebugHelper.WriteLine("检测" + item.Key + "是否为默认值:");
Type type = item.Value.FieldType;
if (type.IsValueType && type.IsPrimitive)
{
EJudge.If(EDefault.IsDefault(type, model.DLoadValue(item.Key).DelayAction))(() =>
{
}).Else(() =>
{
MethodHelper.ReturnValue(false);
});
}
else if (type.IsClass)
{
EJudge.If(ENull.IsNull(model.DLoadValue(item.Key).DelayAction))(() =>
{
}).Else(() =>
{
MethodHelper.ReturnValue(false);
});
}
}
#endregion
il.EmitBoolean(true);
}, "Check").Compile(typeof(CheckStructDelegate));
ClassCache.CheckStructDict[TypeHandler] = (CheckStructDelegate)func;
}
