public IEmitterType EmitMapMethod(IEmitterType sourceMemeber, IEmitterType targetMember)
{
Type mapperType = typeof(Mapper);
MethodInfo mapMethod = mapperType.GetMethod(Mapper.MapMethodName, BindingFlags.Instance | BindingFlags.Public);
FieldInfo mappersField = mapperType.GetField(Mapper.MappersFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
IEmitterType mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
IEmitterType mapper = EmitArray.Load(mappers, Id);
IEmitterType result = EmitMethod.Call(mapMethod, mapper, sourceMemeber, targetMember);
return(result);
}
public IEmitterType EmitMapMethod(IEmitterType sourceMember, IEmitterType targetMember)
{
var mapperType = typeof(Mapper);
var mapMethod = mapperType.GetMethod(Mapper.MAP_METHOD_NAME, BindingFlags.Instance | BindingFlags.Public);
var mappersField = mapperType.GetField(Mapper.MAPPERS_FIELD_NAME, BindingFlags.Instance | BindingFlags.NonPublic);
var mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
var mapper = EmitArray.Load(mappers, Id);
var result = EmitMethod.Call(mapMethod, mapper, sourceMember, targetMember);
return(result);
}
private void EmitEnumerableToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
Type sourceItemType = typePair.Source.GetCollectionItemType();
Type targetItemType = typePair.Target.GetCollectionItemType();
EmitConvertItem(typeBuilder, new TypePair(sourceItemType, targetItemType));
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, targetItemType);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitDictionaryToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
KeyValuePair <Type, Type> sourceTypes = typePair.Source.GetDictionaryItemTypes();
KeyValuePair <Type, Type> targetTypes = typePair.Target.GetDictionaryItemTypes();
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Key, targetTypes.Key), ConvertItemKeyMethod);
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Value, targetTypes.Value));
var arguments = new[] { sourceTypes.Key, sourceTypes.Value, targetTypes.Key, targetTypes.Value };
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, arguments);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitEnumerableToTarget(
Type parentType,
TypeBuilder typeBuilder,
TypePair typePair,
TypePair collectionItemTypePair,
string methodName,
string templateMethodName)
{
var methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
EmitConvertItem(typeBuilder, collectionItemTypePair);
var methodTemplate = parentType.GetGenericMethod(templateMethodName, collectionItemTypePair.Target);
var returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
