实体类复制

    随着.net引入attribute，实体类在编程中的重要性已经越来越重要了，并且有越来越多的工具开始生成自己的实体类。但是这也引来了一个麻烦，每个工具生成的实体类需要各自的attribute，并且可能互相不通用。

    例如：Entity Framework生成的实体类有：Serializable，DataContract，EdmEntityType等，属性有DataMember，EdmScalarProperty等，entity framework所需要的各种特性，并且附带了wcf、xml序列化所需要的特性。但是，当你需要把这些实体做一个特殊的操作，并且这个操作又需要一些特殊的attribute时，至少有下面两种选择：

      1、直接修改生成的实体类，但是这样做了以后，通常会因为重新生成一边实体类而丢失了所有已经标记的attribute，这几乎让人无法接受。

      2、再定义一套实体类，但是，这样做的缺点是你需要手动的copy每一个值，这个工作有让人感到麻烦而无奈。

    所以，我们不得不寻找其他方案：

      1、找一个可以自己控制的代码生成器（例如：codesmith），但是，总有那些用现成工具很难配置的代码生成。

      2、运用反射，根据某种契约（例如：属性名称相同）自动复制数据，但是，传统反射的效率是在是一个大问题。

    但是，别忘了反射可以直接Emit出IL，这样可以极大提高复制速度，达到接近直接代码手写手动代码copy的效率，本文就是提供了这么一种简单的实现。

 

    第一步，就是确定核心功能Copy方法的签名，

    刚开始定义成了：

void Copy<T, TResult>(T value, TResult result);

    但是，不久就发现这个定义在很多场合不适合，例如TResult为值类型时，那么对TResult的任何复制操作将都是白搭。

    又经过了几次修订以后，最终确定为：

void Copy<T, TResult>(T value, ref TResult result);

    这个方法签名至少可以应对各种值类型和应用类型的情况。

    第二步，就是确定该封装些什么，怎么允许扩展，顺便取个名字。

    为了保证功能和扩展性，决定用装饰模式，大概为：

    public abstract class EntityCopier
    {
        public abstract void Copy<TSource, TResult>(TSource source, ref TResult result);
        public static EntityCopier CreateAuto()
        {
            threw new NotImplementedException();
        }
    }

    当然，还要会基类中增加Cache服务，把Emit出来的方法cache下来，提高复制效率。当然，先要定义Cache的值（当然和Copy方法的签名一致）

    public delegate void CopyDelegate<TSource, TResult>(TSource source, ref TResult result);

    以及Cache的键

    internal struct CacheKey
    {
        public readonly EntityCopier Copier;
        public readonly Type Source;
        public readonly Type Result;
        public CacheKey(EntityCopier copier, Type source, Type result)
        {
            Copier = copier;
            Source = source;
            Result = result;
        }
    }

    然后，拥有Cache服务的基类将变成：

    public abstract class EntityCopier
    {
        private Dictionary<CacheKey, Delegate> _dict =
            new Dictionary<CacheKey, Delegate>();

        public abstract void Copy<TSource, TResult>(TSource source, ref TResult result);

        internal protected virtual bool CopyCore<TSource, TResult>(EntityCopier copier, TSource source, ref TResult result)
        {
            CopyDelegate<TSource, TResult> cd = GetDelegate<TSource, TResult>(copier);
            if (cd == null)
                return false;
            cd(source, ref result);
            return true;
        }

        internal protected abstract CopyDelegate<TSource, TResult> CreateCopyDelegate<TSource, TResult>(EntityCopier copier);

        private CopyDelegate<TSource, TResult> GetDelegate<TSource, TResult>(EntityCopier copier)
        {
            Delegate d = null;
            CacheKey key = new CacheKey(copier, typeof(TSource), typeof(TResult));
            if (_dict.TryGetValue(key, out d))
                return (CopyDelegate<TSource, TResult>)d;
            CopyDelegate<TSource, TResult> cd = CreateCopyDelegate<TSource, TResult>(copier);
            _dict[key] = cd;
            return cd;
        }

        public static EntityCopier CreateAuto()
        {
            throw new NotImplementedException();
        }
    }

    哦，对了，在这里，无论TSource还是TResult必须要是公开类型，否则的话，会遇上权限问题，所以，在基类里面加一个方法：

        protected static bool CheckType(Type type)
        {
            return type.IsVisible;
        }

    这样，我们就可以实现自动复制服务了：

    // 初步成型的EntityCopier和自动复制的实现
    public abstract class EntityCopier
    {

        #region Fields
        private static MethodInfo _copyMethod;
        private Dictionary<CacheKey, Delegate> _dict =
            new Dictionary<CacheKey, Delegate>();
        #endregion

        #region Internal Methods

        internal void RegistCore<TSource, TResult>(EntityCopier copier, CopyDelegate<TSource, TResult> cd)
        {
            _dict[new CacheKey(copier, typeof(TSource), typeof(TResult))] = cd;
        }

        internal static void CheckSourceNull(ILGenerator gen, Type sourceType)
        {
            if (!sourceType.IsValueType)
            {
                Label notNull = gen.DefineLabel();
                gen.Emit(OpCodes.Ldarg_1);
                gen.Emit(OpCodes.Brtrue_S, notNull);
                gen.Emit(OpCodes.Ret);
                gen.MarkLabel(notNull);
            }
            else if (sourceType.IsGenericType &&
                sourceType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                Label notNull = gen.DefineLabel();
                gen.Emit(OpCodes.Ldarg_1);
                gen.Emit(OpCodes.Box, sourceType);
                gen.Emit(OpCodes.Brtrue_S, notNull);
                gen.Emit(OpCodes.Ret);
                gen.MarkLabel(notNull);
            }
        }

        #endregion

        #region Virtual Methods

        public abstract void Copy<TSource, TResult>(TSource source, ref TResult result);

        internal protected virtual bool CopyCore<TSource, TResult>(EntityCopier copier, TSource source, ref TResult result)
        {
            CopyDelegate<TSource, TResult> cd = GetDelegate<TSource, TResult>(copier);
            if (cd == null)
                return false;
            cd(source, ref result);
            return true;
        }

        internal protected abstract CopyDelegate<TSource, TResult> CreateCopyDelegate<TSource, TResult>(EntityCopier copier);

        #endregion

        #region Properties

        protected static MethodInfo CopyMethod
        {
            get
            {
                return _copyMethod ??
                    (_copyMethod = typeof(EntityCopier).GetMethod("Copy"));
            }
        }

        public virtual bool CanBeDecorated
        {
            get { return true; }
        }

        #endregion

        #region Private Implements

        private CopyDelegate<TSource, TResult> GetDelegate<TSource, TResult>(EntityCopier copier)
        {
            Delegate d = null;
            CacheKey key = new CacheKey(copier, typeof(TSource), typeof(TResult));
            if (_dict.TryGetValue(key, out d))
                return (CopyDelegate<TSource, TResult>)d;
            CopyDelegate<TSource, TResult> cd = CreateCopyDelegate<TSource, TResult>(copier);
            _dict[key] = cd;
            return cd;
        }

        #endregion

        #region Static Methods

        public static EntityCopier CreateAuto()
        {
            return new AutoCopier();
        }

        protected static bool CheckType(Type type)
        {
            return type.IsVisible;
        }

        #endregion

    }

    //以及自动复制的实现（估计看了就会头晕，呵呵）
    internal class AutoCopier
        : EntityCopier
    {

        #region Sub-Classes

        protected sealed class ContextInfo
        {
            internal EntityCopier Copier;
            internal Type SourceType;
            internal Type ResultType;
            internal ILGenerator ILGen;
            internal bool SourceIsValueType;
            internal bool ResultIsValueType;
        }

        protected struct PropertyPair
        {
            public readonly PropertyInfo SourceProperty;
            public readonly PropertyInfo ResultProperty;
            public PropertyPair(PropertyInfo sourceProperty, PropertyInfo resultProperty)
            {
                SourceProperty = sourceProperty;
                ResultProperty = resultProperty;
            }
        }

        #endregion

        #region Overrides

        public sealed override void Copy<TSource, TResult>(TSource source, ref TResult result)
        {
            if (!CheckType(typeof(TSource)))
                throw new ArgumentException("type cannot be non-public type", typeof(TSource).ToString());
            if (!CheckType(typeof(TResult)))
                throw new ArgumentException("type cannot be non-public type", typeof(TResult).ToString());
            CopyCore<TSource, TResult>(this, source, ref result);
        }

        protected internal sealed override CopyDelegate<TSource, TResult> CreateCopyDelegate<TSource, TResult>(EntityCopier copier)
        {
            ContextInfo info = new ContextInfo();
            info.Copier = copier;
            info.SourceType = typeof(TSource);
            info.ResultType = typeof(TResult);
            info.SourceIsValueType = info.SourceType.IsValueType;
            info.ResultIsValueType = info.ResultType.IsValueType;
            return (CopyDelegate<TSource, TResult>)CreateCopyDelegateCore(info);
        }

        #endregion

        #region Private Implements

        private Delegate CreateCopyDelegateCore(ContextInfo info)
        {
            Type[] args = new Type[3];
            args[0] = typeof(EntityCopier);
            args[1] = info.SourceType;
            args[2] = info.ResultType.MakeByRefType();
            DynamicMethod dm = new DynamicMethod(string.Empty, typeof(void), args);
            info.ILGen = dm.GetILGenerator();
            CreateCopyDelegateBody(info);
            info.ILGen.Emit(OpCodes.Ret);
            return dm.CreateDelegate(typeof(CopyDelegate<,>).MakeGenericType(info.SourceType, info.ResultType), info.Copier);
        }

        private void CreateCopyDelegateBody(ContextInfo info)
        {
            CheckSourceNull(info);
            if (info.SourceType == info.ResultType)
                CopySameType(info);
            else
                CopyDifferentType(info);
            info.ILGen.Emit(OpCodes.Ret);
        }

        private static void CheckSourceNull(ContextInfo info)
        {
            if (!info.SourceIsValueType)
            {
                Label notNull = info.ILGen.DefineLabel();
                info.ILGen.Emit(OpCodes.Ldarg_1);
                info.ILGen.Emit(OpCodes.Brtrue_S, notNull);
                info.ILGen.Emit(OpCodes.Ret);
                info.ILGen.MarkLabel(notNull);
            }
            else if (info.SourceType.IsGenericType &&
                info.SourceType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                Label notNull = info.ILGen.DefineLabel();
                info.ILGen.Emit(OpCodes.Ldarg_1);
                info.ILGen.Emit(OpCodes.Box, info.SourceType);
                info.ILGen.Emit(OpCodes.Brtrue_S, notNull);
                info.ILGen.Emit(OpCodes.Ret);
                info.ILGen.MarkLabel(notNull);
            }
        }

        private static void CopySameType(ContextInfo info)
        {
            info.ILGen.Emit(OpCodes.Ldarg_2);
            info.ILGen.Emit(OpCodes.Ldarg_1);
            info.ILGen.Emit(OpCodes.Stobj, info.ResultType);
        }

        private void CopyDifferentType(ContextInfo info)
        {
            EnsureResultInstance(info);
            foreach (PropertyPair item in GetPropertyPair(info))
                CopyProperty(info, item);
        }

        private static void EnsureResultInstance(ContextInfo info)
        {
            if (!info.ResultIsValueType)
            {
                Label label = info.ILGen.DefineLabel();
                LoadResult(info);
                info.ILGen.Emit(OpCodes.Brtrue_S, label);
                TryCreateResultInstance(info);
                info.ILGen.MarkLabel(label);
            }
        }

        private static void TryCreateResultInstance(ContextInfo info)
        {
            ConstructorInfo ctor = info.ResultType.GetConstructor(Type.EmptyTypes);
            if (ctor == null)
            {
                info.ILGen.Emit(OpCodes.Ret);
            }
            else
            {
                info.ILGen.Emit(OpCodes.Ldarg_2);
                info.ILGen.Emit(OpCodes.Newobj, ctor);
                info.ILGen.Emit(OpCodes.Stind_Ref);
            }
        }

        private static void CopyProperty(ContextInfo info, PropertyPair item)
        {
            Label skip = info.ILGen.DefineLabel();
            LocalBuilder lb = info.ILGen.DeclareLocal(item.ResultProperty.PropertyType);
            if (item.ResultProperty.PropertyType.IsValueType)
            {
                info.ILGen.Emit(OpCodes.Ldloca, lb);
                info.ILGen.Emit(OpCodes.Initobj, item.ResultProperty.PropertyType);
            }
            else
            {
                info.ILGen.Emit(OpCodes.Ldnull);
                info.ILGen.Emit(OpCodes.Stloc, lb);
            }
            LoadResult(info);
            info.ILGen.Emit(OpCodes.Ldarg_0);
            LoadSourceProperty(info, item);
            if (!item.SourceProperty.PropertyType.IsValueType)
            {
                Label notNull = info.ILGen.DefineLabel();
                info.ILGen.Emit(OpCodes.Dup);
                info.ILGen.Emit(OpCodes.Brtrue_S, notNull);
                info.ILGen.Emit(OpCodes.Pop);
                info.ILGen.Emit(OpCodes.Pop);
                info.ILGen.Emit(OpCodes.Pop);
                info.ILGen.Emit(OpCodes.Br_S, skip);
                info.ILGen.MarkLabel(notNull);
            }
            info.ILGen.Emit(OpCodes.Ldloca, lb);
            info.ILGen.Emit(OpCodes.Callvirt, CopyMethod.MakeGenericMethod(item.SourceProperty.PropertyType, item.ResultProperty.PropertyType));
            info.ILGen.Emit(OpCodes.Ldloc, lb);
            SetResultProperty(info, item);
            info.ILGen.MarkLabel(skip);
        }

        protected virtual IEnumerable<PropertyPair> GetPropertyPair(ContextInfo info)
        {
            PropertyInfo[] srcProps = info.SourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            PropertyInfo[] resultProps = info.ResultType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (PropertyInfo resultProp in resultProps)
            {
                if (resultProp.GetIndexParameters().Length > 0)
                    continue;
                MethodInfo setMethod = resultProp.GetSetMethod(false);
                if (setMethod == null)
                    continue;
                foreach (PropertyInfo srcProp in srcProps)
                {
                    if (srcProp.Name != resultProp.Name)
                        continue;
                    if (srcProp.GetIndexParameters().Length > 0)
                        continue;
                    if (srcProp.GetGetMethod(false) == null)
                        continue;
                    yield return new PropertyPair(srcProp, resultProp);
                    break;
                }
            }
        }

        private static void LoadResult(ContextInfo info)
        {
            info.ILGen.Emit(OpCodes.Ldarg_2);
            if (!info.ResultIsValueType)
            {
                info.ILGen.Emit(OpCodes.Ldind_Ref);
                info.ILGen.Emit(OpCodes.Castclass, info.ResultType);
            }
        }

        private static void LoadSourceProperty(ContextInfo info, PropertyPair item)
        {
            if (info.SourceIsValueType)
            {
                info.ILGen.Emit(OpCodes.Ldarga_S, 1);
                info.ILGen.Emit(OpCodes.Call, item.SourceProperty.GetGetMethod(false));
            }
            else
            {
                info.ILGen.Emit(OpCodes.Ldarg_1);
                info.ILGen.Emit(OpCodes.Callvirt, item.SourceProperty.GetGetMethod(false));
            }
        }

        private static void SetResultProperty(ContextInfo info, PropertyPair item)
        {
            if (info.ResultIsValueType)
                info.ILGen.Emit(OpCodes.Call, item.ResultProperty.GetSetMethod(false));
            else
                info.ILGen.Emit(OpCodes.Callvirt, item.ResultProperty.GetSetMethod(false));
        }

        #endregion

    }

    来看一个简单的应用：

        public class MyClass1
        {
            public int A { get; set; }
        }

        public class MyClass2
        {
            public int A { get; set; }
        }

        [TestMethod]
        public void Test()
        {
            MyClass1 c1 = new MyClass1();
            c1.A = 1;
            MyClass2 c2 = null;
            EntityCopier copier = EntityCopier.CreateAuto();
            copier.Copy<MyClass1, MyClass2>(c1, ref c2);
            Assert.IsNotNull(c2);
            Assert.AreEqual(c1.A, c2.A);
        }

    看起来不错，基本的属性对属性的复制已经没问题了，而且，还可以支持Nested，或者值类型到引用类型，或者引用类型到值类型的强大复制功能，例如：

        public class MyClass1
        {
            public int A { get; set; }
            public Nested1 B { get; set; }
        }

        public class Nested1
        {
            public string C { get; set; }
        }

        public class MyClass2
        {
            public int A { get; set; }
            public Nested2 B { get; set; }
        }

        public struct Nested2
        {
            public string C { get; set; }
        }

        [TestMethod]
        public void Test()
        {
            MyClass1 c1 = new MyClass1
            {
                A = 1,
                B = new Nested1 { C = "Hello world", },
            };
            EntityCopier copier = EntityCopier.CreateAuto();
            MyClass2 c2 = null;
            copier.Copy<MyClass1, MyClass2>(c1, ref c2);
            Assert.IsNotNull(c2);
            Assert.AreEqual(c1.A, c2.A);
            Assert.AreEqual(c1.B.C, c2.B.C);
        }

    但是，这个简单的复制不是万能的，必须要能够被扩展，前面说过要使用装饰模式来扩展性的功能，那么，先定义个装饰的基类：

    public abstract class CopierDecorator
        : EntityCopier
    {
        private readonly EntityCopier _inner;

        protected CopierDecorator(EntityCopier inner)
        {
            if (inner == null)
                throw new ArgumentNullException("inner");
            if (!inner.CanBeDecorated)
                throw new InvalidOperationException("inner cannot be decorated");
            _inner = inner;
        }

        public sealed override void Copy<TSource, TResult>(TSource source, ref TResult result)
        {
            if (!CheckType(typeof(TSource)))
                throw new ArgumentException("type cannot be non-public type", typeof(TSource).ToString());
            if (!CheckType(typeof(TResult)))
                throw new ArgumentException("type cannot be non-public type", typeof(TResult).ToString());
            CopyCore<TSource, TResult>(this, source, ref result);
        }

        internal protected sealed override bool CopyCore<TSource, TResult>(
            EntityCopier copier, TSource source, ref TResult result)
        {
            if (base.CopyCore<TSource, TResult>(copier, source, ref result))
                return true;
            return _inner.CopyCore<TSource, TResult>(copier, source, ref result);
        }

        public EntityCopier Inner
        {
            get { return _inner; }
        }
    }

    是不是很简单，如何扩展实现哪？这里就以一个简单的自定义复制器为例：

    public class CustomCopierDecorator
        : CopierDecorator
    {

        public CustomCopierDecorator(EntityCopier inner)
            : base(inner) { }

        public void Register<TSource, TResult>(CopyDelegate<TSource, TResult> cd)
        {
            if (cd == null)
                throw new ArgumentNullException("cd");
            RegistCore<TSource, TResult>(this, cd);
        }

    来看看怎么用这个自定义复制器：

        public class MyClass1
        {
            public int A { get; set; }
        }

        public class MyClass2
        {
            public string A { get; set; }
        }

        public static void MyConvert(int value, ref string result)
        {
            result = value.ToString();
        }

        [TestMethod]
        public void Test()
        {
            MyClass1 c1 = new MyClass1 { A = 1, };
            CustomCopierDecorator copier = new CustomCopierDecorator(EntityCopier.CreateAuto());
            copier.Register<int, string>(MyConvert);
            MyClass2 c2 = null;
            copier.Copy<MyClass1, MyClass2>(c1, ref c2);
            Assert.IsNotNull(c2);
            Assert.AreEqual(c1.A.ToString(), c2.A);

    是不是很简单，当然，还可以写其他很多装饰，例如：数组复制的装饰，枚举复制的装饰，大家可以发挥自己的想象力。