public void Assign()
{
Utilities.Reflection.Emit.Assembly Assembly = new Utilities.Reflection.Emit.Assembly("TestAssembly");
Utilities.Reflection.Emit.TypeBuilder TestType = Assembly.CreateType("TestType");
IMethodBuilder Method = TestType.CreateMethod("TestMethod");
VariableBase Local1 = Method.CreateLocal("Local1", typeof(int));
Local1.Assign(12);
}
private static void SetupEnd(IMethodBuilder method, VariableBase returnValue, IPropertyBuilder aspectusEnding)
{
VariableBase endingArgs = method.NewObj(typeof(Ending).GetConstructor(new Type[0]));
endingArgs.Call(typeof(Ending).GetProperty("MethodName").GetSetMethod(), new object[] { method.Name });
if (method.ReturnType != typeof(void) && returnValue.DataType != null && returnValue.DataType.IsValueType)
{
endingArgs.Call(typeof(Ending).GetProperty("ReturnValue").GetSetMethod(),
new object[] { method.Box(returnValue) });
}
else if (method.ReturnType != typeof(void))
{
endingArgs.Call(typeof(Ending).GetProperty("ReturnValue").GetSetMethod(), new object[] { returnValue });
}
VariableBase parameterList = endingArgs.Call(typeof(Ending).GetProperty("Parameters").GetGetMethod());
for (int x = 1; x < method.Parameters.Count; ++x)
{
if (method.Parameters.ElementAt(x).DataType != null &&
method.Parameters.ElementAt(x).DataType.IsValueType)
{
parameterList.Call(typeof(List <object>).GetMethod("Add"),
new object[] { method.Box(method.Parameters.ElementAt(x)) });
}
else
{
parameterList.Call(typeof(List <object>).GetMethod("Add"),
new object[] { method.Parameters.ElementAt(x) });
}
}
VariableBase eventsThis = method.Cast(method.This, typeof(IEvents));
Type eventHelperType = typeof(DelegateExtensions);
MethodInfo[] methods = eventHelperType.GetMethods()
.Where(x => x.GetParameters().Length == 3)
.ToArray();
MethodInfo tempMethod = methods.Length > 0 ? methods[0] : null;
tempMethod = tempMethod.MakeGenericMethod(new[] { typeof(Ending) });
method.Call(null, tempMethod, new object[] { aspectusEnding, eventsThis, endingArgs });
if (method.ReturnType != typeof(void))
{
VariableBase tempReturnValue = endingArgs.Call(typeof(Ending).GetProperty("ReturnValue").GetGetMethod());
VariableBase tempNull = method.CreateLocal("TempNull", typeof(object));
If If = method.If(tempReturnValue, Comparison.NotEqual, tempNull);
{
returnValue.Assign(tempReturnValue);
}
method.SetCurrentMethod();
If.EndIf();
}
}
/// <summary>
/// Sets up a property (List)
/// </summary>
/// <param name="Method">Method builder</param>
/// <param name="BaseType">Base type for the object</param>
/// <param name="ReturnValue">Return value</param>
/// <param name="Property">Property info</param>
/// <param name="Mapping">Mapping info</param>
private void SetupListProperty(IMethodBuilder Method, Type BaseType, VariableBase ReturnValue, IProperty Property, IMapping Mapping)
{
Utilities.Reflection.Emit.FieldBuilder Field = Fields.Find(x => x.Name == Property.DerivedFieldName);
Utilities.Reflection.Emit.FieldBuilder FieldLoaded = Fields.Find(x => x.Name == Property.DerivedFieldName + "_Loaded");
Utilities.Reflection.Emit.Commands.If If1 = Method.If((VariableBase)SessionField, Comparison.NotEqual, null);
{
Utilities.Reflection.Emit.Commands.If If2 = Method.If(Field, Comparison.Equal, null);
{
Utilities.Reflection.Emit.Commands.If If3 = Method.If(FieldLoaded, Comparison.Equal, Method.CreateConstant(false));
{
//Load data
VariableBase IDValue = Method.This.Call(BaseType.GetProperty(Mapping.IDProperty.Name).GetGetMethod());
VariableBase IDParameter = Method.NewObj(typeof(EqualParameter <>).MakeGenericType(Mapping.IDProperty.Type), new object[] { IDValue, "ID", "@" });
VariableBase PropertyList = Method.NewObj(typeof(List <IParameter>));
PropertyList.Call("Add", new object[] { IDParameter });
MethodInfo LoadPropertiesMethod = typeof(Session).GetMethod("LoadListProperties");
LoadPropertiesMethod = LoadPropertiesMethod.MakeGenericMethod(new Type[] { BaseType, Field.DataType.GetGenericArguments()[0] });
VariableBase ReturnVal = ((VariableBase)SessionField).Call(LoadPropertiesMethod, new object[] { Method.This, Property.Name, PropertyList.Call("ToArray") });
Field.Assign(ReturnVal);
FieldLoaded.Assign(true);
}
If3.EndIf();
}
If2.EndIf();
PropertyInfo CountProperty = Field.DataType.GetProperty("Count");
Utilities.Reflection.Emit.Commands.If If4 = Method.If(Field.Call(CountProperty.GetGetMethod()), Comparison.Equal, Method.CreateConstant(0));
{
Utilities.Reflection.Emit.Commands.If If3 = Method.If(FieldLoaded, Comparison.Equal, Method.CreateConstant(false));
{
//Load data
VariableBase IDValue = Method.This.Call(BaseType.GetProperty(Mapping.IDProperty.Name).GetGetMethod());
VariableBase IDParameter = Method.NewObj(typeof(EqualParameter <>).MakeGenericType(Mapping.IDProperty.Type), new object[] { IDValue, "ID", "@" });
VariableBase PropertyList = Method.NewObj(typeof(List <IParameter>));
PropertyList.Call("Add", new object[] { IDParameter });
MethodInfo LoadPropertiesMethod = typeof(Session).GetMethod("LoadProperties");
LoadPropertiesMethod = LoadPropertiesMethod.MakeGenericMethod(new Type[] { BaseType, Field.DataType.GetGenericArguments()[0] });
VariableBase ReturnVal = ((VariableBase)SessionField).Call(LoadPropertiesMethod, new object[] { Method.This, Property.Name, PropertyList.Call("ToArray") });
Field.Assign(ReturnVal);
FieldLoaded.Assign(true);
}
If3.EndIf();
}
If4.EndIf();
Utilities.Reflection.Emit.Commands.If If5 = Method.If(Field, Comparison.Equal, null);
{
Field.Assign(Method.NewObj(typeof(List <>).MakeGenericType(Property.Type).GetConstructor(Type.EmptyTypes)));
}
If5.EndIf();
}
If1.EndIf();
ReturnValue.Assign(Field);
}
private static void SetupMethod(Type baseType, IMethodBuilder method, IPropertyBuilder aspectusStarting,
IPropertyBuilder aspectusEnding, IPropertyBuilder aspectusException,
MethodInfo baseMethod)
{
if (baseMethod == null)
{
baseMethod = baseType.GetMethod(method.Name);
}
method.SetCurrentMethod();
Label endLabel = method.Generator.DefineLabel();
VariableBase returnValue = method.ReturnType != typeof(void)
? method.CreateLocal("FinalReturnValue", method.ReturnType)
: null;
Try Try = method.Try();
{
SetupStart(method, endLabel, returnValue, aspectusStarting);
_aspects.ForEach(x => x.SetupStartMethod(method, baseType));
var parameters = new List <ParameterBuilder>();
method.Parameters.For(1, method.Parameters.Count - 1, x => parameters.Add(x));
if (method.ReturnType != typeof(void) && baseMethod != null)
{
returnValue.Assign(method.This.Call(baseMethod, parameters.ToArray()));
}
else if (baseMethod != null)
{
method.This.Call(baseMethod, parameters.ToArray());
}
SetupEnd(method, returnValue, aspectusEnding);
_aspects.ForEach(x => x.SetupEndMethod(method, baseType, returnValue));
method.Generator.MarkLabel(endLabel);
}
Catch Catch = Try.StartCatchBlock(typeof(System.Exception));
{
SetupException(method, Catch, aspectusException);
_aspects.ForEach(x => x.SetupExceptionMethod(method, baseType));
Catch.Rethrow();
}
Try.EndTryBlock();
if (method.ReturnType != typeof(void))
{
method.Return(returnValue);
}
else
{
method.Return();
}
}
private void SetupEnd(IMethodBuilder Method, VariableBase ReturnValue, IPropertyBuilder AspectusEnding)
{
VariableBase EndingArgs = Method.NewObj(typeof(Ending).GetConstructor(new Type[0]));
EndingArgs.Call(typeof(Ending).GetProperty("MethodName").GetSetMethod(), new object[] { Method.Name });
if (Method.ReturnType != typeof(void) && ReturnValue.DataType != null && ReturnValue.DataType.IsValueType)
{
EndingArgs.Call(typeof(Ending).GetProperty("ReturnValue").GetSetMethod(), new object[] { Method.Box(ReturnValue) });
}
else if (Method.ReturnType != typeof(void))
{
EndingArgs.Call(typeof(Ending).GetProperty("ReturnValue").GetSetMethod(), new object[] { ReturnValue });
}
VariableBase ParameterList = EndingArgs.Call(typeof(Ending).GetProperty("Parameters").GetGetMethod());
for (int x = 1; x < Method.Parameters.Count; ++x)
{
if (Method.Parameters[x].DataType != null && Method.Parameters[x].DataType.IsValueType)
{
ParameterList.Call(typeof(List <object>).GetMethod("Add"), new object[] { Method.Box(Method.Parameters[x]) });
}
else
{
ParameterList.Call(typeof(List <object>).GetMethod("Add"), new object[] { Method.Parameters[x] });
}
}
VariableBase IEventsThis = Method.Cast(Method.This, typeof(IEvents));
Type EventHelperType = typeof(Utilities.Events.EventHelper);
MethodInfo[] Methods = EventHelperType.GetMethods()
.Where <MethodInfo>(x => x.GetParameters().Length == 3)
.ToArray();
MethodInfo TempMethod = Methods.Length > 0 ? Methods[0] : null;
TempMethod = TempMethod.MakeGenericMethod(new Type[] { typeof(Ending) });
Method.Call(null, TempMethod, new object[] { AspectusEnding, IEventsThis, EndingArgs });
if (Method.ReturnType != typeof(void))
{
VariableBase TempReturnValue = EndingArgs.Call(typeof(Ending).GetProperty("ReturnValue").GetGetMethod());
VariableBase TempNull = Method.CreateLocal("TempNull", typeof(object));
Utilities.Reflection.Emit.Commands.If If = Method.If(TempReturnValue, Utilities.Reflection.Emit.Enums.Comparison.NotEqual, TempNull);
{
ReturnValue.Assign(TempReturnValue);
}
Method.SetCurrentMethod();
If.EndIf();
}
}
private void SetupMethod(Type BaseType, IMethodBuilder Method, IPropertyBuilder AspectusStarting,
IPropertyBuilder AspectusEnding, IPropertyBuilder AspectusException, MethodInfo BaseMethod)
{
if (BaseMethod == null)
{
BaseMethod = BaseType.GetMethod(Method.Name);
}
Method.SetCurrentMethod();
System.Reflection.Emit.Label EndLabel = Method.Generator.DefineLabel();
VariableBase ReturnValue = Method.ReturnType != typeof(void) ? Method.CreateLocal("FinalReturnValue", Method.ReturnType) : null;
Utilities.Reflection.Emit.Commands.Try Try = Method.Try();
{
SetupStart(Method, EndLabel, ReturnValue, AspectusStarting);
Aspects.ForEach(x => x.SetupStartMethod(Method, BaseType));
List <ParameterBuilder> Parameters = new List <ParameterBuilder>();
Method.Parameters.For(1, Method.Parameters.Count - 1, x => Parameters.Add(x));
if (Method.ReturnType != typeof(void) && BaseMethod != null)
{
ReturnValue.Assign(Method.This.Call(BaseMethod, Parameters.ToArray()));
}
else if (BaseMethod != null)
{
Method.This.Call(BaseMethod, Parameters.ToArray());
}
SetupEnd(Method, ReturnValue, AspectusEnding);
Aspects.ForEach(x => x.SetupEndMethod(Method, BaseType, ReturnValue));
Method.Generator.MarkLabel(EndLabel);
}
Utilities.Reflection.Emit.Commands.Catch Catch = Try.StartCatchBlock(typeof(System.Exception));
{
SetupException(Method, Catch, AspectusException);
Aspects.ForEach(x => x.SetupExceptionMethod(Method, BaseType));
Catch.Rethrow();
}
Try.EndTryBlock();
if (Method.ReturnType != typeof(void))
{
Method.Return(ReturnValue);
}
else
{
Method.Return();
}
}
private static void SetupStart(IMethodBuilder Method, System.Reflection.Emit.Label EndLabel,
VariableBase ReturnValue, IPropertyBuilder AspectusStarting)
{
VariableBase StartingArgs = Method.NewObj(typeof(Starting).GetConstructor(new Type[0]));
StartingArgs.Call(typeof(Starting).GetProperty("MethodName").GetSetMethod(), new object[] { Method.Name });
VariableBase ParameterList = StartingArgs.Call(typeof(Starting).GetProperty("Parameters").GetGetMethod());
for (int x = 1; x < Method.Parameters.Count; ++x)
{
if (Method.Parameters.ElementAt(x).DataType != null && Method.Parameters.ElementAt(x).DataType.IsValueType)
{
ParameterList.Call(typeof(List <object>).GetMethod("Add"), new object[] { Method.Box(Method.Parameters.ElementAt(x)) });
}
else
{
ParameterList.Call(typeof(List <object>).GetMethod("Add"), new object[] { Method.Parameters.ElementAt(x) });
}
}
VariableBase IEventsThis = Method.Cast(Method.This, typeof(IEvents));
Type EventHelperType = typeof(Utilities.DataTypes.ExtensionMethods.DelegateExtensions);
MethodInfo[] Methods = EventHelperType.GetMethods()
.Where <MethodInfo>(x => x.GetParameters().Length == 3)
.ToArray();
MethodInfo TempMethod = Methods.Length > 0 ? Methods[0] : null;
TempMethod = TempMethod.MakeGenericMethod(new Type[] { typeof(Starting) });
Method.Call(null, TempMethod, new object[] { AspectusStarting, IEventsThis, StartingArgs });
if (Method.ReturnType != typeof(void))
{
VariableBase TempReturnValue = StartingArgs.Call(typeof(Starting).GetProperty("ReturnValue").GetGetMethod());
VariableBase TempNull = Method.CreateLocal("TempNull", typeof(object));
Utilities.Reflection.Emit.Commands.If If = Method.If(TempReturnValue, Utilities.Reflection.Emit.Enums.Comparison.NotEqual, TempNull);
{
ReturnValue.Assign(TempReturnValue);
Method.Generator.Emit(System.Reflection.Emit.OpCodes.Br, EndLabel);
}
Method.SetCurrentMethod();
If.EndIf();
}
}
