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 TestString()
{
string[] testArray = new string[] { "0", "1", "2", "3", "4", "5" };
for (int i = 0; i < testArray.Length; i += 1)
{
Delegate ShowDelegate = EHandler.CreateMethod <string>((il) =>
{
EArray Model = testArray;
Model.LoadArray(i);
}).Compile();
Assert.Equal(i.ToString(), ((Func <string>)ShowDelegate)());
}
}
/// <summary>
/// 使用Natasha根据参数数组信息生成Command高速构建缓存
/// </summary>
/// <typeparam name="T">实际执行函数返回的类型</typeparam>
/// <param name="sql">SQL语句</param>
/// <param name="values">object参数数组</param>
/// <returns>动态方法</returns>
private static SqlDelegate <T> .GetCommandByObject GetEmitCommandCache <T>(string sql, object[] values)
{
Type returnType = typeof(T);
if (!Cache.SqlCache.ContainsKey(returnType))
{
ModelAnalyser.Initialization(returnType);
}
Delegate newMethod = EHandler.CreateMethod <ERef <IDbCommand>, object[], ENull>((il) =>
{
EModel idbCommand = EModel.CreateModelFromParameter <IDbCommand>(0);
idbCommand.UseRef();
idbCommand.Set("CommandText", sql);
EArray arrayArg = EArray.CreateArrayFromParameter(1, typeof(object));
EModel copyParameters = idbCommand.Load("Parameters");
MatchCollection collection = ParameterRegex.Matches(sql);
int length = collection.Count;
for (int i = 0; i < length; i += 1)
{
Type type = values[i].GetType();
string memberName = collection[i].Groups[1].Value;
copyParameters.Dup();
EModel copyParameter = EMethod.Load(idbCommand).ExecuteMethod("CreateParameter").Dup();
copyParameter.Set("ParameterName", "@".Append(memberName));
copyParameter.Dup().Set("DbType", (int)SqlTypes[type]);
if (type.IsPrimitive)
{
copyParameter.Dup().Set("Value", () => { arrayArg.LoadArray(i); });
}
else
{
EJudge.If(ENull.IsNull(() => { arrayArg.LoadArray(i); }))(() =>
{
copyParameter.Dup().Set("Value", EDBNull.LoadValue);
}).Else(() =>
{
copyParameter.Dup().Set("Value", () => { arrayArg.LoadArray(i); });
});
}
EMethod.Load <IList>().ExecuteMethod <object>("Add").Pop();
}
copyParameters.Pop();
}).Compile(typeof(SqlDelegate <T> .GetCommandByObject));
return((SqlDelegate <T> .GetCommandByObject)newMethod);
}
public static void ForeachClassArray()
{
TestClass[] testArray = new TestClass[5];
for (int i = 0; i < testArray.Length; i += 1)
{
TestClass t = new TestClass();
t.Name = "T" + i;
testArray[i] = t;
}
testArray[0].FieldNext = new TestStruct()
{
Name = "1", Age = 10
};
Delegate ShowDelegate = EHandler.CreateMethod <TestClass[]>((il) =>
{
EArray model = testArray;
ELoop.For(model, (loadCurrentElement) =>
{
EModel modelHandler = EModel.CreateModelFromAction <TestClass>(loadCurrentElement);
modelHandler.LField("FieldNext").LFieldValue("Age");
modelHandler.il.REmit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }));
});
model.Load();
}).Compile();
if (ShowDelegate != null)
{
TestClass[] result = ((Func <TestClass[]>)ShowDelegate)();
for (int i = 0; i < result.Length; i += 1)
{
result[i].Name = "T" + (i + 5);
}
Console.WriteLine(result[0].FieldNext.Age);
Console.WriteLine("旧对象：");
for (int i = 0; i < testArray.Length; i += 1)
{
Console.WriteLine(testArray[i].Name);
}
Console.WriteLine("深度复制新对象：");
for (int i = 0; i < result.Length; i += 1)
{
Console.WriteLine(result[i].Name);
}
}
else
{
Console.WriteLine("??");
}
}
public static void ForeachIntArray()
{
int[] testArray = new int[] { 1, 2, 3, 4, 5 };
Delegate ShowDelegate = EHandler.CreateMethod <ENull>((il) =>
{
EArray Model = testArray;
ELoop.For(Model, (loadCurrentElement) =>
{
loadCurrentElement();
Model.il.REmit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }));
});
}).Compile();
((Action)ShowDelegate)();
}
public static void ForeachStringArray()
{
string[] testArray = new string[] { "1", "2", "C", "D" };
Delegate ShowDelegate = EHandler.CreateMethod <ENull>((il) =>
{
EArray Model = testArray;
ELoop.For(Model, (loadCurrentElement) =>
{
loadCurrentElement();
Model.il.REmit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
});
}).Compile();
((Action)ShowDelegate)();
}
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)());
}
static void Main(string[] args)
{
EArray ea = new EArray();
ea.Add(0);
ea.Add(1);
ea.Add(2);
ea.Add(3);
ea.Add(4);
ea.Add(5);
ea.Add(6);
ea.Add(7);
ea.Add(8);
ea.Add(9);
//ea.PrintArray();
ea.Delete(5);
ea.PrintArray();
Console.ReadLine();
}
public static void DTestArray()
{
string[] strArray = new string[5];
int[] intArray = new int[5];
StructField[] structArray = new StructField[5];
ClassField[] classArray = new ClassField[5];
DocumentEnum[] enumArray = new DocumentEnum[5];
for (int i = 0; i < strArray.Length; i += 1)
{
strArray[i] = i.ToString();
intArray[i] = i;
enumArray[i] = DocumentEnum.ID;
structArray[i] = new StructField()
{
PublicAge = i
};
classArray[i] = new ClassField()
{
PublicAge = i
};
}
//动态创建Action委托
Delegate newMethod = EHandler.CreateMethod <ENull>((il) =>
{
EMethod method = typeof(Console);
//从运行时获取数组并入栈到IL层临时变量
EArray stringArrayModel = strArray;
ELoop.For(stringArrayModel, (currentElement) =>
{
method.ExecuteMethod <string>("WriteLine", currentElement);
});
EArray intArrayModel = intArray;
ELoop.For(3, 5, 1, intArrayModel, (currentElement) =>
{
method.ExecuteMethod <int>("WriteLine", currentElement);
});
EArray arrayModel = EArray.CreateArraySpecifiedLength <int>(10);
arrayModel.StoreArray(5, 6);
arrayModel.StoreArray(6, 6);
arrayModel.StoreArray(7, 6);
ELoop.For(0, 10, 1, arrayModel, (currentElement) =>
{
method.ExecuteMethod <int>("WriteLine", currentElement);
});
//从运行时获取数组并入栈到IL层临时变量
EArray structArrayModel = EArray.CreateArrayFromRuntimeArray(structArray);
ELoop.For(structArrayModel, (currentElement) =>
{
EModel model = EModel.CreateModelFromAction(currentElement, typeof(StructField));
model.LFieldValue("PublicAge");
method.ExecuteMethod <int>("WriteLine");
});
EArray classArrayModel = EArray.CreateArrayFromRuntimeArray(classArray);
ELoop.For(classArrayModel, (currentElement) =>
{
EModel model = EModel.CreateModelFromAction(currentElement, typeof(ClassField));
model.LFieldValue("PublicAge");
method.ExecuteMethod <int>("WriteLine");
});
EArray enumArrayModel = EArray.CreateArrayFromRuntimeArray(enumArray);
ELoop.For(enumArrayModel, (currentElement) =>
{
EModel model = EModel.CreateModelFromAction(currentElement, typeof(DocumentEnum));
model.Load();
EPacket.Packet(typeof(DocumentEnum));
method.ExecuteMethod <object>("WriteLine");
});
}).Compile();
((Action)newMethod)();
}
/// <summary>
/// 深度复制对象，并压入栈中，创建一个新的临时变量
/// </summary>
/// <param name="value">类或者结构体或者数组</param>
/// <param name="type">类型</param>
/// <returns></returns>
public static LocalBuilder GetCloneBuilder(object value, Type type)
{
ILGenerator il = ThreadCache.GetIL();
if (il.IsNullable(type))
{
LocalBuilder builder = il.DeclareLocal(type);
if (value == null)
{
il.REmit(OpCodes.Ldloca_S, builder);
il.InitObject(type);
}
else
{
il.LoadObject(value, value.GetType());
il.CallNullableCtor(type);
}
return(builder);
}
else if (value == null)
{
LocalBuilder builder = il.DeclareLocal(type);
il.REmit(OpCodes.Ldnull);
il.REmit(OpCodes.Stloc_S, builder.LocalIndex);
return(builder);
}
else if (type.IsValueType && !type.IsPrimitive)
{
LocalBuilder builder = il.DeclareLocal(type);
if (type.IsEnum)
{
il.EmitInt((int)value);
il.REmit(OpCodes.Stloc_S, builder);
return(builder);
}
if (EStruckCheck.IsDefaultStruct(value, type))
{
EModel structModel = EModel.CreateModel(type).UseDefaultConstructor();
return(structModel.Builder);
}
}
else if (type.IsArray)
{
Array tempArray = (Array)value;
Type instanceType = value.GetType().GetElementType();
EArray array = EArray.CreateArraySpecifiedLength(value.GetType(), tempArray.Length);
for (int i = 0; i < tempArray.Length; i += 1)
{
object result = tempArray.GetValue(i);
if (result != null)
{
if (array.IsStruct && !array.ElementType.IsEnum)
{
if (EStruckCheck.IsDefaultStruct(result, instanceType))
{
continue;
}
}
array.StoreArray(i, result);
}
}
return(array.Builder);
}
if (!EReflector.GetMethodDict.ContainsKey(type))
{
EReflector.Create(type);
}
Dictionary <string, GetterDelegate> GetDict = EReflector.GetMethodDict[type];
ClassStruction struction = ClassCache.ClassInfoDict[type.Name];
EModel model = EModel.CreateModel(type).UseDefaultConstructor();
//foreach (var item in struction.Properties)
//{
// MethodInfo info = item.Value.GetSetMethod(true);
// if (info == null || GetDict[item.Key] == null || info.IsPrivate || info.IsStatic)
// {
// continue;
// }
// object result = GetDict[item.Key](value);
// if (result == null)
// {
// continue;
// }
// model.SProperty(item.Key, result);
//}
foreach (var item in struction.Fields)
{
if (item.Value.IsStatic)
{
continue;
}
object result = GetDict[item.Key](value);
if (result == null)
{
continue;
}
model.SField(item.Key, result);
}
return(model.Builder);
}
