快速指导
public class A{ public string message;}public class B{ public string message = "Hello, world!!!";} |
现在，我们有一个实体类B，我们想把它转为实体类A，但是又不想手动字段赋值。可以用以下方式解决：
B b = new B();A a = ObjectMapperManager.DefaultInstance.GetMapper<B, A>().Map(b); |
这个类库最主要的类是ObjectMapperManager。这个类实现了对象映射（在IL运行时）和映射缓存
/// <summary>/// 用于维护和生成映射的类/// </summary>public class ObjectMapperManager{ public static ObjectMapperManager DefaultInstance public ObjectMapperManager(); /// <summary> /// 返回特定类型的映射实体 /// </summary> /// <typeparam name="TFrom">来源类型</typeparam> /// <typeparam name="TTo">映射类型</typeparam> /// <returns></returns> public ObjectsMapper<TFrom, TTo> GetMapper<TFrom, TTo>(); /// <summary> /// 返回特定类型的映射实体 /// </summary> /// <typeparam name="TFrom">来源类型</typeparam> /// <typeparam name="TTo">映射类型</typeparam> /// <param name="ShallowCopy">True, 如果来源类型和映射类型中的某字段是引用类型，且类型相同，映射时，会直接引用而不会创建新的对象</param> /// <returns></returns> public ObjectsMapper<TFrom, TTo> GetMapper<TFrom, TTo>(bool ShallowCopy); /// <summary> /// 返回特定类型的映射实体 /// </summary> /// <typeparam name="TFrom">来源类型</typeparam> /// <typeparam name="TTo">映射类型</typeparam> /// <param name="ShallowCopy">True, 如果来源类型和映射类型中的某字段是引用类型，且类型相同，映射时，会直接引用而不会创建新的对象</param> /// <param name="mappingConfigurator">映射配置委托</param> /// <param name="mapperName">映射实体的名称。如果两个映射实体有相同的参数，但是名称不一样，那么，将生成两个不同的映射实体</param> /// <returns></returns> public ObjectsMapper<TFrom, TTo> GetMapper<TFrom, TTo>( bool ShallowCopy, MappingConfigurator mappingConfigurator, string mapperName); /// <summary> /// 返回特定类型的映射实现实体 /// </summary> /// <param name="from">来源类型</param> /// <param name="to">映射类型</param> /// <param name="ShallowCopy">True, 如果来源类型和映射类型中的某字段是引用类型，且类型相同，映射时，会直接引用而不会创建新的对象</param> /// <param name="mappingConfigurator">映射配置委托</param> /// <returns></returns> public ObjectsMapperBaseImpl GetMapperImpl( Type from, Type to, bool ShallowCopy, MappingConfigurator mappingConfigurator); /// <summary> /// 返回特定类型的映射实现实体 /// </summary> /// <param name="from">来源类型</param> /// <param name="to">映射类型</param> /// <param name="ShallowCopy">True, 如果来源类型和映射类型中的某字段是引用类型，且类型相同，映射时，会直接引用而不会创建新的对象</param> /// <param name="mappingConfigurator">映射配置委托</param> /// <param name="mapperName">映射实现实体的名称。如果两个映射实现实体有相同的参数，但是名称不一样，那么，将生成两个不同的映射实现实体</param> /// <returns></returns> public ObjectsMapperBaseImpl GetMapperImpl( Type from, Type to, bool ShallowCopy, MappingConfigurator mappingConfigurator, string mapperName);} |
一般情况下，如果你不需要分离映射缓存，你能够使用线程安全的 ObjectMapperManager.DefaultInstance 对象，你不需要实例化ObjectMapperManager
使用类ObjectMapperManager你能够创建ObjectsMapper实体，用于实体映射操作
public class ObjectsMapper<TFrom, TTo>{ public TTo Map(TFrom from, TTo to); public TTo Map(TFrom from);} |
使用这种方案，需要以下两步：
Step 1： 使用类ObjectMapperManager创建一个ObjectsMapper：
var mapper = ObjectMapperManager.DefaultInstance.GetMapper<B, A>(); |
Step 2: 使用上一步创建的mapper来映射对象
A a = mapper.Map(new B()); |
比如，我们有两个类“A”和“B”，他们有相同的结构
public class A{ public enum En { En1, En2, En3 } public class AInt { internal int intern = 13; public string str = "AInt"; public AInt() { intern = 13; } } private string m_str1 = "A::str1"; public string str1 { get { return m_str1; } set { m_str1 = value; } } public string str2 = "A::str2"; public AInt obj; public En en = En.En3; int[] m_arr; public int[] arr { set { m_arr = value; } get { return m_arr; } } public AInt[] objArr; public string str3 = "A::str3"; public A() { Console.WriteLine("A::A()"); }}public class B{ public enum En { En1, En2, En3 } public class BInt { public string str = "BInt"; } public string str1 = "B::str1"; public string str2 { get { return "B::str2"; } } public BInt obj = new BInt(); public En en = En.En2; public BInt[] objArr; public int[] arr { get { return new int[] { 1, 5, 9 }; } } public object str3 = null; public B() { Console.WriteLine("B::B()"); objArr = new BInt[2]; objArr[0] = new BInt(); objArr[0].str = "b objArr 1"; objArr[1] = new BInt(); objArr[1].str = "b objArr 2"; }} |
将类B映射到类A：
A a = new A();B b = new B();ObjectMapperManager.DefaultInstance.GetMapper<B, A>().Map(b, a);Assert.AreEqual(a.en, A.En.En2);Assert.AreEqual(a.str1, b.str1);Assert.AreEqual(a.str2, b.str2);Assert.AreEqual(a.obj.str, b.obj.str);Assert.AreEqual(a.obj.intern, 13);Assert.AreEqual(a.arr.Length, b.arr.Length);Assert.AreEqual(a.arr[0], b.arr[0]);Assert.AreEqual(a.arr[1], b.arr[1]);Assert.AreEqual(a.arr[2], b.arr[2]);Assert.AreEqual(a.objArr.Length, b.objArr.Length);Assert.AreEqual(a.objArr[0].str, b.objArr[0].str);Assert.AreEqual(a.objArr[1].str, b.objArr[1].str);Assert.IsNull(a.str3); |
