public void CacheTest()
{
IMapperEmit mapper1 = AutoMapperEmit.Build(typeof(Student), typeof(Person));
IMapperEmit mapper2 = AutoMapperEmit.Build(typeof(Student), typeof(Person));
Assert.AreEqual(mapper1.GetHashCode(), mapper2.GetHashCode());
}
public void ValueTypeTest()
{
IMapperEmit m = AutoMapperEmit.Build(typeof(int), typeof(int));
int x = 1;
int i = (int)m.Map(x);
Assert.AreEqual(x, i);
}
public void MapParametersTest()
{
IMapperEmit m = AutoMapperEmit.Build(typeof(Student), typeof(Course));
Student s = new Student {
ImAField = "ImAField", Nickname = "Zezito", Nr = 27721, Name = "Ze Manel", Address = "Rua de Cima"
};
Course c = (Course)m.Map(s);
Assert.AreEqual(s.Address, c.Address);
}
public void MapTest()
{
IMapperEmit m = AutoMapperEmit.Build(typeof(Student), typeof(Person));
Student s = new Student {
Nr = 27721, Name = "Ze Manel"
};
Person p = (Person)m.Map(s);
Assert.AreEqual(s.Name, p.Name);
}
public void MapByBindTest()
{
IMapperEmit m = AutoMapperEmit.Build(typeof(Student), typeof(Person))
.Bind(MappingEmit.Fields);
Student s = new Student {
ImAField = "ImAField", Nickname = "Zezito", Nr = 27721, Name = "Ze Manel"
};
Person p = (Person)m.Map(s);
Assert.AreEqual(s.ImAField, p.ImAField);
}
public void MapCustomAttributeTest()
{
IMapperEmit m = AutoMapperEmit.Build(typeof(Student), typeof(Person))
.Bind(MappingEmit.CustomAttributes);
Student s = new Student {
ImAField = "ImAField", Nickname = "Zezito", Nr = 27721, Name = "Ze Manel"
};
Person p = (Person)m.Map(s);
Assert.AreEqual(s.Nickname, p.Nickname);
}
public static IMapperEmit Build(Type klassSrc, Type klassDest)
{
if (cache == null)
{
cache = new CacheStructure();
}
IMapperEmit mapper = cache.GetMapper(klassSrc, klassDest);
if (mapper == null)
{
mapper = new MapperEmit(klassSrc, klassDest);
cache.Add(klassSrc, klassDest, mapper);
}
return(mapper);
}
public static Mapper <TSrc, TDest> Build <TSrc, TDest> ()
{
if (cache == null)
{
cache = new CacheStructure();
}
IMapperEmit mapper = cache.GetMapper(typeof(TSrc), typeof(TDest));
if (mapper == null)
{
mapper = new Mapper <TSrc, TDest>(typeof(TSrc), typeof(TDest));
cache.Add(typeof(TSrc), typeof(TDest), mapper);
}
return((Mapper <TSrc, TDest>)mapper);
}
public void MapArrayTest()
{
IMapperEmit m = AutoMapperEmit.Build(typeof(Student), typeof(Person));
Student[] s = { new Student {
ImAField = "ImAField", Nickname = "Zezito", Nr = 27721, Name = "Ze Manel"
},
new Student {
ImAField = "ImAField", Nickname = "Xico", Nr = 27722, Name = "Francisco"
} };
Person[] p = (Person[])m.Map(s);
for (int i = 0; i < p.Length; ++i)
{
Assert.AreEqual(s[i].Name, p[i].Name);
}
}
public void MapByMatchTest()
{
int[] array = { 27999, 27898, 27162 };
IMapperEmit m = AutoMapperEmit.Build(typeof(Student), typeof(Person))
.Match("Nr", "Id")
.Match("Org", "Org");
Student s = new Student
{
ImAField = "ImAField",
Nickname = "Zezito",
Nr = 27721,
Name = "Ze Manel",
Org = new School("Lisbon", array, "ISEL")
};
Person p = (Person)m.Map(s);
Assert.AreEqual(s.Nr, p.Id);
Assert.AreEqual(s.Org.Name, p.Org.Name);
}
public void Add(Type src, Type dest, IMapperEmit mapper)
{
KeyValuePair <Type, Type> pair = new KeyValuePair <Type, Type>(src, dest);
cacheDictionary.Add(pair, mapper);
}
public override object Copy(object objSrc)
{
IMapperEmit m = null;
if (emitter != null)
{
emitter.Copy(objSrc);
}
TypeBuilder tBuilder = GetTypeBuilder("Field");
MethodBuilder mBuilder = GetMethodBuilder(tBuilder);
FieldBuilder fb = tBuilder.DefineField(
"target",
typeof(IMapperEmit),
FieldAttributes.Private);
ConstructorBuilder cb = tBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.ExplicitThis,
new Type[] { typeof(IMapperEmit) });
/*********************************** IL CODE ***************************/
ILGenerator cbIlGen = cb.GetILGenerator();
cbIlGen.Emit(OpCodes.Ldarg_0);
cbIlGen.Emit(OpCodes.Ldarg_1);
cbIlGen.Emit(OpCodes.Stfld, fb);
cbIlGen.Emit(OpCodes.Ret);
ILGenerator ilGenerator = mBuilder.GetILGenerator();
ilGenerator.Emit(OpCodes.Newobj, dest.GetConstructors()[0]);
foreach (KeyValuePair <FieldInfo, FieldInfo> pair in fieldList)
{
if (pair.Key.FieldType.IsAssignableFrom(pair.Value.FieldType))
{
ilGenerator.Emit(OpCodes.Dup);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Ldfld, ((FieldInfo)pair.Key));
ilGenerator.Emit(OpCodes.Stfld, ((FieldInfo)pair.Value));
}
else
{
if (map.TryGetValue(pair, out m))
{
ilGenerator.Emit(OpCodes.Dup);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Ldfld, pair.Key);
ilGenerator.Emit(OpCodes.Ldfld, fb);
ilGenerator.Emit(OpCodes.Callvirt, typeof(IMapperEmit).GetMethod("Map"));
ilGenerator.Emit(OpCodes.Stfld, pair.Value);
}
}
}
ilGenerator.Emit(OpCodes.Ret);
/*********************************** END ***************************/
Type t = tBuilder.CreateType();
emitter = (IEmitter)Activator.CreateInstance(t, m);
asm.Save(tBuilder.Name + ".dll");
return(emitter.Copy(objSrc));
}
public override object Copy(object objSrc)
{
IMapperEmit m = null;
if (emitter != null)
{
return(emitter.Copy(objSrc));
}
TypeBuilder tBuilder = GetTypeBuilder("Property");
MethodBuilder mBuilder = GetMethodBuilder(tBuilder);
FieldBuilder fb = tBuilder.DefineField(
"target",
typeof(IMapperEmit),
FieldAttributes.Private);
ConstructorBuilder cb = tBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.ExplicitThis,
new Type[] { typeof(IMapperEmit) });
/*********************************** IL CODE ***************************/
ILGenerator cbIlGen = cb.GetILGenerator();
cbIlGen.Emit(OpCodes.Ldarg_0);
cbIlGen.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
cbIlGen.Emit(OpCodes.Ldarg_0);
cbIlGen.Emit(OpCodes.Ldarg_1);
cbIlGen.Emit(OpCodes.Stfld, fb);
cbIlGen.Emit(OpCodes.Ret);
ILGenerator ilGenerator = mBuilder.GetILGenerator();
LocalBuilder localSrc = ilGenerator.DeclareLocal(src);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Castclass, src);
ilGenerator.Emit(OpCodes.Stloc, localSrc);
ilGenerator.Emit(OpCodes.Newobj, dest.GetConstructors()[0]);
foreach (KeyValuePair <PropertyInfo, PropertyInfo> pair in propertyList)
{
if (pair.Key.PropertyType.IsAssignableFrom(pair.Value.PropertyType))
{
ilGenerator.Emit(OpCodes.Dup);
ilGenerator.Emit(OpCodes.Ldloc, localSrc);
ilGenerator.Emit(OpCodes.Callvirt, pair.Key.GetGetMethod());
ilGenerator.Emit(OpCodes.Callvirt, pair.Value.GetSetMethod());
}
else
{
if (map.TryGetValue(pair, out m))
{
ilGenerator.Emit(OpCodes.Dup);
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, fb);
ilGenerator.Emit(OpCodes.Ldloc, localSrc);
ilGenerator.Emit(OpCodes.Callvirt, pair.Key.GetGetMethod());
ilGenerator.Emit(OpCodes.Callvirt, typeof(IMapperEmit).GetMethod("Map", new [] { typeof(object) }));
ilGenerator.Emit(OpCodes.Callvirt, pair.Value.GetSetMethod());
}
}
}
ilGenerator.Emit(OpCodes.Ret);
Type t = tBuilder.CreateType();
asm.Save(tBuilder.Name + ".dll");
emitter = (IEmitter)Activator.CreateInstance(t, m);
return(emitter.Copy(objSrc));
}
