public IlBuilder GetMember(MemberHandler mm, KnownTypesHandler handler)
{
if (mm.MemberInfo.IsProperty)
{
var method = ((PropertyInfo)mm.MemberInfo.GetMemberInfo()).GetGetMethod(true);
return(CallVirtual(handler.Import(method)));
}
return(LoadField(handler.Import((FieldInfo)mm.MemberInfo.GetMemberInfo())));
}
private void ProcessPropertyGet()
{
var processor = PreProcessPropertyMethod(_pi.PropertyDefinition.GetMethod);
processor.LoadArg(0);
processor.LoadField(_pi.FieldDefinition);
if (_pi.FieldType == FieldType.BelongsTo || _pi.FieldType == FieldType.HasOne || _pi.FieldType == FieldType.LazyLoad)
{
var getValue = _handler.Import(_pi.FieldDefinition.FieldType.GetMethod("get_Value"));
processor.CallVirtual(getValue);
}
processor.Return();
processor.Append();
}
public void Generate(ModuleDefinition module)
{
foreach (var member in _info.Members)
{
var key = member.MemberInfo.Name;
var type = TypeFactory.CreateType(_model, _handler.ObjectType, key);
type.Interfaces.Add(_handler.MemberHandlerInterface);
try
{
if (member.MemberInfo.IsProperty)
{
_properties[key].CustomAttributes.Add(_handler.GetModelHandler(type));
}
else
{
_fields[key].CustomAttributes.Add(_handler.GetModelHandler(type));
}
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message + ":" + key);
}
GenerateConstructor(type);
var mt = _handler.Import(member.MemberInfo.MemberType);
GenerateSetValue(type, member, mt);
GenerateGetValue(type, member, mt);
module.Types.Add(type);
}
}
public IlBuilder CastOrUnbox(TypeReference t, KnownTypesHandler handler)
{
//TODO: refactor the types to KnownTypesHandler
if (t.IsGenericInstance && t.Name == "Nullable`1")
{
var inType = ((GenericInstanceType)t).GenericArguments[0];
if (ProcessDateAndTime(inType, handler.Import(typeof(Date?)), handler.Import(typeof(Time?))))
{
return(this);
}
}
if (t.IsValueType)
{
if (ProcessDateAndTime(t, handler.Import(typeof(Date)), handler.Import(typeof(Time))))
{
return(this);
}
if (t.FullName == typeof(bool).FullName)
{
t = handler.Import(typeof(bool));
}
else if (t.FullName == typeof(uint).FullName)
{
t = handler.Import(typeof(int));
}
else if (t.FullName == typeof(ulong).FullName)
{
t = handler.Import(typeof(long));
}
else if (t.FullName == typeof(ushort).FullName)
{
t = handler.Import(typeof(short));
}
_list.Add(_il.Create(OpCodes.Unbox_Any, t));
}
else
{
_list.Add(_il.Create(OpCodes.Castclass, t));
}
return(this);
}
private void ProcessGenericPropertyInConstructor(PropertyInformation pi, IlBuilder processor)
{
processor.LoadArg(0).LoadArg(0);
MethodReference ci1;
var ft = (GenericInstanceType)pi.FieldDefinition.FieldType;
if (pi.IsHasOne || pi.IsHasMany || pi.IsHasAndBelongsToMany)
{
ci1 = ft.GetConstructor(typeof(DbObjectSmartUpdate), typeof(string), typeof(string));
var ob = GetOrderByString(pi);
if (string.IsNullOrEmpty(ob))
{
processor.LoadNull();
}
else
{
processor.LoadString(ob);
}
}
else
{
ci1 = ft.GetConstructor(typeof(DbObjectSmartUpdate), typeof(string));
}
if (pi.IsLazyLoad)
{
processor.LoadString(pi.ColumnName);
}
else
{
processor.Nop().Nop().Nop().Nop().LoadString(pi.FieldDefinition.Name);
}
var ctor = _handler.Import(ci1);
ctor.DeclaringType = ft; //NOTE: might be a bug of Cecil
processor.NewObj(ctor);
processor.SetField(pi.FieldDefinition);
}
private void GenerateLoadSimpleValuesByIndex()
{
var method = new MethodDefinition("LoadSimpleValuesByIndex", MethodAttr, _handler.VoidType);
method.Overrides.Add(_handler.LoadSimpleValuesByIndex);
method.Parameters.Add(new ParameterDefinition("o", ParameterAttributes.None, _handler.ObjectType));
method.Parameters.Add(new ParameterDefinition("dr", ParameterAttributes.None, _handler.DataReaderInterface));
var processor = new IlBuilder(method.Body);
// User u = (User)o;
processor.DeclareLocal(_model);
processor.LoadArg(1).Cast(_model).SetLoc(0);
// set values
int n = 0;
foreach (var f in _info.SimpleMembers)
{
processor.LoadLoc(0);
if (f.Is.AllowNull)
{
processor.LoadArg(0);
}
processor.LoadArg(2).LoadInt(n);
var mi1 = Helper.GetMethodInfo(f.MemberType);
if (f.Is.AllowNull || mi1 == null)
{
processor.CallVirtual(_handler.GetDataReaderMethodInt());
if (f.Is.AllowNull)
{
SetSecendArgForGetNullable(f, processor);
processor.Call(_handler.ModelHandlerBaseTypeGetNullable);
}
// cast or unbox
processor.CastOrUnbox(_handler.Import(f.MemberType), _handler);
}
else
{
processor.CallVirtual(_handler.Import(mi1));
}
processor.SetMember(f, _handler);
n++;
}
processor.Return();
processor.Append();
_result.Methods.Add(method);
}
