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; }
    }
}

转载于:https://www.cnblogs.com/joeymary/p/6678039.html