private static ETree P(Queue <string> s)
{
ETree t;
double v;
if (double.TryParse(s.Peek(), out v))
{
s.Dequeue();
t = new ELeaf(v);
return(t);
}
if (s.Peek()[0] >= 'A' && s.Peek()[0] <= 'Z')
{
t = new EVar(s.Dequeue()[0]);
return(t);
}
if (s.Peek() == "(")
{
s.Dequeue();
t = E(s);
if (s.Dequeue() != ")")
{
throw new ArgumentException("parenthese issue");
}
return(t);
}
if (s.Peek() == "-")
{
s.Dequeue();
t = F(s);
return(new EUnary(EUnary.GetUnaryOpperator("-"), t));
}
throw new ArgumentException();
}
public void TestMethod()
{
Delegate test = EHandler.CreateMethod <ulong>((il) =>
{
EModel modelHandler = EModel.CreateModel <MethodStruct>().UseDefaultConstructor();
EMethod.Load(modelHandler).ExecuteMethod("GetULongMax");
}).Compile();
Func <ulong> action = (Func <ulong>)test;
Assert.Equal(ulong.MaxValue, action());
test = EHandler.CreateMethod <ulong>((il) =>
{
EModel modelHandler = EModel.CreateModel <MethodStruct>().UseDefaultConstructor();
EMethod.Load(modelHandler).ExecuteMethod("GetULongMin");
}).Compile();
action = (Func <ulong>)test;
Assert.Equal(ulong.MinValue, action());
test = EHandler.CreateMethod <string>((il) =>
{
EModel modelHandler = EModel.CreateModel <MethodStruct>().UseDefaultConstructor();
EVar param1 = "Hello";
EMethod.Load(modelHandler).ExecuteMethod <string, string>("GetString", param1, " World");
}).Compile();
Func <string> action1 = (Func <string>)test;
Assert.Equal("Hello World", action1());
}
public void TestClass()
{
ComplexClassModel model = new ComplexClassModel();
model.FieldModel = new FieldStruct();
model.PropertyModel = new PropertyStruct();
model.MethodModel = new MethodStruct();
ComplexClassModel.Model = model;
Delegate test = EHandler.CreateMethod <ComplexClassModel>((il) =>
{
EVar ulongMinHandler = ulong.MinValue;
EModel modelHandler = EModel.CreateModelFromObject(model);
modelHandler.Load("FieldModel").Set("RefField", "Hello");
modelHandler.Load("PropertyModel").Set("RefProperty", "Hello");
modelHandler.Load("PropertyModel").Set("ValueProperty", ulongMinHandler);
modelHandler.Load("Model").Load("FieldModel").Set("RefField", "Hello1");
modelHandler.Load("Model").Load("FieldModel").Set("ValueField", () => { EMethod.Load(modelHandler.DLoad("MethodModel").Operator).ExecuteMethod("GetULongMax"); });
modelHandler.Load();
}).Compile();
Func <ComplexClassModel> action = (Func <ComplexClassModel>)test;
ComplexClassModel result = action();
Assert.Equal((ulong)0, result.FieldModel.ValueField);
Assert.Equal(ulong.MinValue, result.PropertyModel.ValueProperty);
Assert.Equal("Hello", result.FieldModel.RefField);
Assert.Equal("Hello", result.PropertyModel.RefProperty);
Assert.Equal(ulong.MaxValue, ComplexClassModel.Model.FieldModel.ValueField);
Assert.Equal("Hello1", ComplexClassModel.Model.FieldModel.RefField);
//Assert.Equal("Hello1", model.FieldModel.RefField);
}
public static void TestJudge()
{
Action action = (Action)(EHandler.CreateMethod <ENull>((il) =>
{
EMethod methodInfoHelper = typeof(Console);
EVar Int_1 = 2;
EVar Int_2 = 2;
EArray objectArray = EArray.CreateArraySpecifiedLength <object>(2);
objectArray.StoreArray(0, Int_1.InStackAndPacket);
objectArray.StoreArray(1, Int_2.InStackAndPacket);
EJudge.
If(Int_1 > 2)(() =>
{
EVar str = "{0}>{1}";
methodInfoHelper.ExecuteMethod <string, object[]>("WriteLine", str, objectArray);
})
.ElseIf(Int_1 == Int_2)(() =>
{
EVar str = "{0}={1}";
methodInfoHelper.ExecuteMethod <string, object[]>("WriteLine", str, objectArray);
})
.Else(() =>
{
EVar str = "{0}<{1}";
methodInfoHelper.ExecuteMethod <string, object[]>("WriteLine", str, objectArray);
});
}).Compile());
action();
}
public void StringOperator()
{
Delegate test = EHandler.CreateMethod <string>((il) =>
{
EVar temp_var1 = "Hello ";
EVar temp_var2 = EVar.CreateVarFromObject("World");
(temp_var1 + temp_var2)();
}).Compile();
Func <string> action = (Func <string>)test;
Assert.Equal("Hello World", action());
}
public void TestInt()
{
int[] testArray = new int[] { 1, 2, 3, 4, 5 };
Delegate ShowDelegate = EHandler.CreateMethod <int>((il) =>
{
EVar result = EVar.CreateVar <int>();
EArray Model = testArray;
ELoop.For(Model, (loadCurrentElement) =>
{
result.Store(result + loadCurrentElement);
});
result.Load();
}).Compile();
Assert.Equal(15, ((Func <int>)ShowDelegate)());
}
public static void TestSingle()
{
//动态创建Action委托
Delegate newMethod = EHandler.CreateMethod <ENull>((il) =>
{
//创建没有临时变量的普通入栈变量(没有临时变量，所以自加操作没有意义)
EVar intHandler = 1;
//创建函数操作句柄
EMethod method = typeof(Console);
//输出intHandler的时候，让变量做加法运算。
method.ExecuteMethod <int>("WriteLine", intHandler + 665);
//结果:666；
}).Compile();
((Action)newMethod)();
//动态创建Action<int,string>委托
Delegate newMethod1 = EHandler.CreateMethod <ENull>((il) =>
{
//创建有临时变量的普通入栈变量(自加操作可以被自身储存) 也就是说可以使用store存储函数
//int i = 664;
EVar intHandler = EVar.CreateVarFromObject(664);
//i++;
intHandler++;
//i=i+1;
intHandler.Store(intHandler + 1);
//创建函数操作句柄
EMethod method = typeof(Console);
//输出intHandler
method.ExecuteMethod <int>("WriteLine", intHandler);
//结果:666
}).Compile();
((Action)newMethod1)();
////动态创建Action委托
//Delegate newMethod0 = EHandler.CreateMethod<ENull>((il) => { }).Compile();
////动态创建Action<string,int>委托
//Delegate newMethod1 = EHandler.CreateMethod<string,int,ENull>((il) => { }).Compile();
////动态创建Func<string>委托
//Delegate newMethod2 = EHandler.CreateMethod<string>((il) => { }).Compile();
////动态创建Func<string,TestClass>委托
//Delegate newMethod3 = EHandler.CreateMethod<string, TestClass>((il) => { }).Compile();
}
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 TestNull()
{
//动态创建Action委托
Delegate newMethod = EHandler.CreateMethod <ENull>((il) =>
{
//创建没有临时变量的普通入栈变量(没有临时变量，所以自加操作没有意义)
EVar intHandler = EVar.CreateVarFromObject("2");
//创建函数操作句柄
EMethod method = typeof(Console);
//输出intHandler
method.ExecuteMethod <string>("WriteLine", intHandler);
//填空值string=null
intHandler.Store(ENull.Value);
method.ExecuteMethod <string>("WriteLine", intHandler);
}).Compile();
((Action)newMethod)();
}
public void SOTest()
{
ComplexStructModel model = new ComplexStructModel();
model.FieldModel = new FieldClass()
{
RefField = "Hello", ValueField = ulong.MaxValue - 1
};
model.PropertyModel = new PropertyClass()
{
RefProperty = "Hello", ValueProperty = ulong.MinValue + 1
};
model.MethodModel = new MethodClass();
ComplexStructModel.Model = model;
Delegate test = EHandler.CreateMethod <ComplexStructModel>((il) =>
{
EVar ulongHandler = (ulong)1;
EVar ulongHandlerFromObject = EVar.CreateVarFromObject((ulong)1);
EVar stringHandler = " World";
EModel modelHandler = EModel.CreateModelFromObject(model);
modelHandler.Load("FieldModel").Set("ValueField", modelHandler.DLoad("FieldModel").DLoad("ValueField").Operator + (ulong)1);
modelHandler.DLoad("FieldModel").DLoad("ValueField").Operator--;
modelHandler.DLoad("FieldModel").DLoad("ValueField").Operator++;
modelHandler.Load("PropertyModel").Set("ValueProperty", modelHandler.DLoad("PropertyModel").DLoad("ValueProperty").Operator - (ulong)1);
modelHandler.DLoad("PropertyModel").DLoad("ValueProperty").Operator++;
modelHandler.DLoad("PropertyModel").DLoad("ValueProperty").Operator--;
modelHandler.Load("PropertyModel").Set("RefProperty", modelHandler.DLoad("PropertyModel").DLoad("RefProperty").Operator + " World");
modelHandler.Load("FieldModel").Set("RefField", modelHandler.DLoad("FieldModel").DLoad("RefField").Operator + stringHandler);
modelHandler.DLoad("Model").DLoad("FieldModel").DLoad("ValueField").Operator++;
modelHandler.Load();
}).Compile();
Func <ComplexStructModel> action = (Func <ComplexStructModel>)test;
ComplexStructModel result = action();
Assert.Equal(ulong.MaxValue, result.FieldModel.ValueField);
Assert.Equal(ulong.MinValue, result.PropertyModel.ValueProperty);
Assert.Equal("Hello World", result.FieldModel.RefField);
Assert.Equal("Hello World", result.PropertyModel.RefProperty);
Assert.Equal(ulong.MaxValue, ComplexStructModel.Model.FieldModel.ValueField);
}
void ExecEvAdd()
{
var sev = (EVar)EVarsList.SelectedItem;
var ev = new EVar {
Framework = sev?.Framework
};
var evbox = new EVarBox(CurrentEnvironment.FNames)
{
Title = "Add Environment Variable",
DataContext = ev
};
evbox.Closing += (sender, args) => {
var evb = (EVarBox)sender;
if (evb.DialogResult != true)
{
return;
}
if (EVars.Any(e => e.Name.Equals(ev.Name, StringComparison.OrdinalIgnoreCase)))
{
MessageBox.Show(
$"Variable '{ev.Name}' is already defined.\nPlease choose a different name.",
Strings.APP_NAME,
MessageBoxButton.OK,
MessageBoxImage.Error
);
args.Cancel = true;
}
};
if (evbox.ShowDialog() != true)
{
return;
}
CurrentEnvironment.Add(ev, sev);
CurrentEnvironment.Render(EVars);
UpdateColumnWidths(EVarsList);
EVarsList.SelectedItem = EVars.First(e => e.Name == ev.Name);
}
public void DoubleOperator()
{
Delegate test = EHandler.CreateMethod <double>((il) =>
{
EVar temp_var1 = (double)15;
EVar temp_var2 = EVar.CreateVarFromObject((double)10);
EVar temp_var3 = 3.5;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / (double)5);
temp_var2.Store(temp_var2 - temp_var3);
temp_var2.Store(temp_var2 * 3.0);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <double> action = (Func <double>)test;
Assert.Equal(4.5, action());
}
public void FloatOperator()
{
Delegate test = EHandler.CreateMethod <float>((il) =>
{
EVar temp_var1 = (float)15;
EVar temp_var2 = EVar.CreateVarFromObject((float)10);
EVar temp_var3 = (float)3.5;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / (float)5);
temp_var2.Store(temp_var2 - temp_var3);
temp_var2.Store(temp_var2 * 3.0);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <float> action = (Func <float>)test;
Assert.Equal((float)4.5, action());
}
public void LongOperator()
{
Delegate test = EHandler.CreateMethod <long>((il) =>
{
EVar temp_var1 = (long)15;
EVar temp_var2 = EVar.CreateVarFromObject((long)10);
EVar temp_var3 = (long)2;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / (long)5);
temp_var2.Store(temp_var2 * 1844674407370955161);
temp_var2.Store(temp_var2 + temp_var3);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <long> action = (Func <long>)test;
Assert.Equal(long.MaxValue, action());
}
public void ShortOperator()
{
Delegate test = EHandler.CreateMethod <short>((il) =>
{
EVar temp_var1 = (short)15;
EVar temp_var2 = EVar.CreateVarFromObject((short)10);
EVar temp_var3 = (short)2;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / 5);
temp_var2.Store(temp_var2 * 6553);
temp_var2.Store(temp_var2 + temp_var3);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <short> action = (Func <short>)test;
Assert.Equal(short.MaxValue, action());
}
public void UIntOperator()
{
Delegate test = EHandler.CreateMethod <uint>((il) =>
{
EVar temp_var1 = (uint)15;
EVar temp_var2 = EVar.CreateVarFromObject((uint)10);
EVar temp_var3 = (uint)0;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / 5);
temp_var2.Store(temp_var2 * 858993459);
temp_var2.Store(temp_var2 + temp_var3);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <uint> action = (Func <uint>)test;
Assert.Equal(uint.MaxValue, action());
}
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 ByteOperator()
{
Delegate test = EHandler.CreateMethod <byte>((il) =>
{
EVar temp_var1 = (byte)15;
EVar temp_var2 = EVar.CreateVarFromObject((byte)10);
EVar temp_var3 = (byte)5;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / 5);
temp_var2.Store(temp_var2 * 50);
temp_var2.Store(temp_var2 + temp_var3);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <byte> action = (Func <byte>)test;
Assert.Equal(byte.MaxValue, action());
}
public void ULongOperator()
{
Delegate test = EHandler.CreateMethod <ulong>((il) =>
{
EVar temp_var1 = (ulong)15;
EVar temp_var2 = EVar.CreateVarFromObject((ulong)10);
EVar temp_var3 = (ulong)0;
temp_var2.Store(temp_var1 + temp_var2);
temp_var2.Store(temp_var2 / (ulong)5);
temp_var2.Store(temp_var2 * 3689348814741910323);
temp_var2.Store(temp_var2 + temp_var3);
temp_var2--;
temp_var2++;
temp_var2.Load();
}).Compile();
Func <ulong> action = (Func <ulong>)test;
Assert.Equal(ulong.MaxValue, action());
}
public static void TestDefault()
{
Action action = (Action)(EHandler.CreateMethod <ENull>((il) =>
{
EMethod methodInfoHelper = typeof(Console);
EVar stringHandler = "16";
EVar intHandler = 10;
EVar doubleHandler = 0.00;
EJudge.If(EDefault.IsDefault(doubleHandler.TypeHandler, () => { doubleHandler.Load(); }))(() =>
{
EMethod.Load(typeof(Console)).ExecuteMethod <string>("WriteLine", "doubleHandler是默认值");
}).Else(() =>
{
doubleHandler.This();
methodInfoHelper.ExecuteMethod <double>("WriteLine");
});
}).Compile());
action();
}
public void ShowInt()
{
//测试int上限 无临时变量
Delegate test = EHandler.CreateMethod <int>((il) => {
EVar temp_var = int.MaxValue;
EMethod.Load(typeof(Console)).ExecuteMethod <int>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <int> action = (Func <int>)test;
Assert.Equal(int.MaxValue, action());
//测试int下限 有临时变量
Delegate test2 = EHandler.CreateMethod <int>((il) => {
EVar temp_var = EVar.CreateVarFromObject(int.MinValue);
EMethod.Load(typeof(Console)).ExecuteMethod <int>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <int> action2 = (Func <int>)test2;
Assert.Equal(int.MinValue, action2());
}
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 void ShowChar()
{
//测试char 无临时变量
Delegate test = EHandler.CreateMethod <char>((il) =>
{
EVar temp_var = 'a';
EMethod.Load(typeof(Console)).ExecuteMethod <char>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <char> action = (Func <char>)test;
Assert.Equal('a', action());
//测试string 有临时变量
Delegate test2 = EHandler.CreateMethod <char>((il) =>
{
EVar temp_var = EVar.CreateVarFromObject('`');
EMethod.Load(typeof(Console)).ExecuteMethod <char>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <char> action2 = (Func <char>)test2;
Assert.Equal('`', action2());
}
public void ShowString()
{
//测试string 无临时变量
Delegate test = EHandler.CreateMethod <string>((il) =>
{
EVar temp_var = string.Empty;
EMethod.Load(typeof(Console)).ExecuteMethod <string>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <string> action = (Func <string>)test;
Assert.Equal(string.Empty, action());
//测试string 有临时变量
Delegate test2 = EHandler.CreateMethod <string>((il) =>
{
EVar temp_var = EVar.CreateVarFromObject(string.Empty);
EMethod.Load(typeof(Console)).ExecuteMethod <string>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <string> action2 = (Func <string>)test2;
Assert.Equal(string.Empty, action2());
}
public void ShowBoolean()
{
//测试float上限 无临时变量
Delegate test = EHandler.CreateMethod <bool>((il) =>
{
EVar temp_var = true;
EMethod.Load(typeof(Console)).ExecuteMethod <bool>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <bool> action = (Func <bool>)test;
Assert.Equal(true, action());
//测试float下限 有临时变量
Delegate test2 = EHandler.CreateMethod <bool>((il) =>
{
EVar temp_var = EVar.CreateVarFromObject(false);
EMethod.Load(typeof(Console)).ExecuteMethod <bool>("WriteLine", temp_var);
temp_var.Load();
}).Compile();
Func <bool> action2 = (Func <bool>)test2;
Assert.Equal(false, action2());
}
public static void TestList()
{
List <string> list = new List <string>();
bool shut = list.All(func);
Console.WriteLine(shut);
Func <List <string>, Func <string, bool>, bool> ShowDelegate = (Func <List <string>, Func <string, bool>, bool>)EHandler.CreateMethod <List <string>, Func <string, bool>, bool>((il) =>
{
EVar elist = EVar.CreateVarFromParameter(0);
EVar efunc = EVar.CreateVarFromParameter(1);
EMethod.Load(elist)
.Use(typeof(Enumerable))
.AddGenricType <string>()
.ExecuteMethod <Func <string, bool> >("All", efunc);
}).Compile();
Console.WriteLine(ShowDelegate(list, (str) =>
{
if (str == "1")
{
return(true);
}
return(false);
}));
Action ShowDelegate1 = (Action)EHandler.CreateMethod <ENull>((il) =>
{
EModel model = EModel.CreateModel <Student>().UseDefaultConstructor();
EMethod.Load(model).ExecuteMethod("Show");
EMethod.Load(model).ExecuteMethod <string>("Show", "test");
}).Compile();
((Action)ShowDelegate1)();
}
/// <summary>
/// 获取Reader映射缓存方法
/// </summary>
/// <typeparam name="T">返回的类型</typeparam>
/// <param name="reader">数据库返回的DataReader</param>
/// <param name="sql">SQL语句</param>
/// <returns>动态缓存方法</returns>
private static SqlDelegate <T> .GetReaderInstance GetEmitReaderCache <T>(IDataReader reader, int startIndex, int length)
{
Type returnType = typeof(T);
if (!Cache.SqlCache.ContainsKey(returnType))
{
ModelAnalyser.Initialization(returnType);
}
SqlModel sqlModel = Cache.SqlCache[returnType];
Delegate dynamicMethod = EHandler.CreateMethod <IDataReader, T>((il) =>
{
EMethod dataHandler = typeof(IDataRecord);
EVar parameterVar = EVar.CreateVarFromParameter <IDataRecord>(0);
if (returnType == typeof(object) || returnType == typeof(string) || returnType == typeof(byte[]) || (returnType.IsValueType && returnType.IsPrimitive) || il.IsNullable(returnType))
{
if (returnType.IsValueType && returnType.IsPrimitive)
{
LoadStrongTypeValue(returnType, parameterVar, startIndex);
}
else
{
EJudge.If(() => { EMethod.Load(parameterVar).ExecuteMethod <int>("IsDBNull", startIndex); })(() =>
{
if (il.IsNullable(returnType))
{
EModel model = EModel.CreateModel(returnType).UseDefaultConstructor();
model.Load();
}
else
{
ENull.LoadNull();
}
}).Else(() =>
{
LoadStrongTypeValue(returnType, parameterVar, startIndex);
});
}
}
else
{
EModel model = EModel.CreateModel <T>().UseDefaultConstructor();
for (int i = startIndex; i < startIndex + length; i += 1)
{
string tempName = sqlModel.GetRealName(reader.GetName(i));
Type type = null;
if (!model.Struction.Properties.ContainsKey(tempName) && !model.Struction.Fields.ContainsKey(tempName))
{
continue;
}
else
{
type = sqlModel.Struction.ModelTypeCache[tempName];
}
if (type.IsValueType && type.IsPrimitive)
{
model.Set(tempName, () =>
{
LoadStrongTypeValue(type, parameterVar, i);
});
}
else
{
EJudge.IfTrue(() => { EMethod.Load(parameterVar).ExecuteMethod <int>("IsDBNull", i); })(() =>
{
model.Set(tempName, () =>
{
LoadStrongTypeValue(type, parameterVar, i);
});
});
}
}
model.Load();
}
}).Compile(typeof(SqlDelegate <T> .GetReaderInstance));
return((SqlDelegate <T> .GetReaderInstance)dynamicMethod);
}
public static void TestOperaotr()
{
Delegate showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12);
EVar emit_B = EVar.CreateWithoutTempVar(13);
method.ExecuteMethod <int>("WriteLine", emit_A + emit_B);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12);
EVar emit_B = EVar.CreateWithoutTempVar(13);
method.ExecuteMethod <int>("WriteLine", emit_A - emit_B);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12);
EVar emit_B = EVar.CreateWithoutTempVar(4);
method.ExecuteMethod <int>("WriteLine", emit_A * emit_B);
}).Compile();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12.04);
EVar emit_B = EVar.CreateWithoutTempVar(4.00);
method.ExecuteMethod <double>("WriteLine", emit_A / emit_B);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(12);
EVar emit_B = EVar.CreateWithoutTempVar(5);
method.ExecuteMethod <int>("WriteLine", emit_A % emit_B);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(8);
EVar emit_B = EVar.CreateWithoutTempVar(4);
method.ExecuteMethod <int>("WriteLine", emit_A >> 1);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(8);
EVar emit_B = EVar.CreateWithoutTempVar(4);
method.ExecuteMethod <int>("WriteLine", emit_A << 1);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(8);
EVar emit_B = EVar.CreateWithoutTempVar(4);
method.ExecuteMethod <int>("WriteLine", emit_A | emit_B);
}).Compile();
((Action)showResult)();
showResult = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
EVar emit_A = EVar.CreateWithoutTempVar(8);
EVar emit_B = EVar.CreateWithoutTempVar(4);
method.ExecuteMethod <int>("WriteLine", emit_A & emit_B);
}).Compile();
((Action)showResult)();
}
private static bool LoadStrongTypeValue(Type type, EVar model, int Index)
{
string fastMethodName = "GetValue";
if (type == typeof(string))
{
fastMethodName = "GetString";
}
else if (type == typeof(int) || type == typeof(int?))
{
fastMethodName = "GetInt32";
}
else if (type == typeof(DateTime) || type == typeof(DateTime?))
{
fastMethodName = "GetDateTime";
}
else if (type == typeof(double) || type == typeof(double?))
{
fastMethodName = "GetDouble";
}
else if (type == typeof(bool) || type == typeof(double?))
{
fastMethodName = "GetBoolean";
}
else if (type == typeof(byte) || type == typeof(byte?))
{
fastMethodName = "GetByte";
}
else if (type == typeof(long) || type == typeof(long?))
{
fastMethodName = "GetInt64";
}
else if (type == typeof(Guid) || type == typeof(Guid?))
{
fastMethodName = "GetGuid";
}
else if (type == typeof(float) || type == typeof(float?))
{
fastMethodName = "GetFloat";
}
else if (type == typeof(char) || type == typeof(char?))
{
fastMethodName = "GetChar";
}
else if (type == typeof(short) || type == typeof(short?))
{
fastMethodName = "GetInt16";
}
else if (type == typeof(decimal) || type == typeof(decimal?))
{
fastMethodName = "GetDecimal";
}
else if (type == typeof(byte[]))
{
fastMethodName = "GetSqlBytes";
}
EMethod.Load(model).ExecuteMethod <int>(fastMethodName, Index);
if (fastMethodName != "GetValue")
{
return(false);
}
return(true);
}
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;
}
