C# 快速高效率復制對象的幾種方式

http://www.cnblogs.com/emrys5/p/expression_trans_model.html 這篇較具體。

本文基於上文略加改動，暫記

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
/*
 * 表達式樹暫時只支持簡單類型，自定義類型的支持還需擴展。且只能復制屬性，字段也需擴展
 * 反射跟序列化效率差不多
 * 表達式樹的效率最高（當然Stu2 stu = new Stu2 { Num = Stu1.Num,Str = Stu1.Str,Str3 = Stu1.Str3};這樣的硬編碼效率最高）
 */

namespace 表達式樹
{
    class Program
    {
        static void Main(string[] args)
        {
            //反射
            Stu1 stuIn = new 表達式樹.Stu1 { Num = 1,Str = "123",Str2 = "456"};
            Stu2 stu1 = TransReflection<Stu1, Stu2>(stuIn);
            //序列化
            Stu2 stu2 = JsonConvert.DeserializeObject<Stu2>(JsonConvert.SerializeObject(stuIn));
            //表達式樹
            Stu2 stu3 = TransExpV2<Stu1,Stu2>.Trans(stuIn); 
        }
 
        /// <summary>
        /// 反射
        /// </summary>
        /// <typeparam name="TIn">輸入類型</typeparam>
        /// <typeparam name="TOut">轉換后類型</typeparam>
        /// <param name="tIn"></param>
        /// <returns></returns>
        private static TOut TransReflection<TIn, TOut>(TIn tIn)
        {
            TOut tOut = Activator.CreateInstance<TOut>();
            var tInType = tIn.GetType();
            foreach (var itemOut in tOut.GetType().GetProperties())
            {
                var itemIn = tInType.GetProperty(itemOut.Name); ;
                if (itemIn != null)
                {
                    itemOut.SetValue(tOut, itemIn.GetValue(tIn));
                }
            }
            return tOut;
        }
    }


    /// <summary>
    /// 表達式樹
    /// </summary>
    /// <typeparam name="TIn">輸入類型</typeparam>
    /// <typeparam name="TOut">轉換后類型</typeparam>
    public static class TransExpV2<TIn, TOut>
    {

        private static readonly Func<TIn, TOut> cache = GetFunc();
        private static Func<TIn, TOut> GetFunc()
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
            List<MemberBinding> memberBindingList = new List<MemberBinding>();

            foreach (var item in typeof(TOut).GetProperties())
            {
                if (!item.CanWrite)
                    continue;

                var prop = typeof(TIn).GetProperty(item.Name);
                var isExist = prop != null;

                if (!isExist)//說明輸出類型中該字段在輸入類型中不存在
                    continue;

                MemberExpression property = Expression.Property(parameterExpression, prop);
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }

            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
            Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[] { parameterExpression });

            return lambda.Compile();
        }

        public static TOut Trans(TIn tIn)
        {
            return cache(tIn);
        }

    }
    class Stu1
    {
        public int Num { get; set; }
        public string Str { get; set; }
        public string Str2 { get; set; }
    }

    class Stu2
    {
        public int Num { get; set; }
        public string Str { get; set; }
        //public string Str2 { get; set; }
        public string Str3 { get; set; }
    }
}