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

    }

}
巴特西

C# 快速高效率复制对象的几种方式

本文基于上文略加改动，暂记

最新文章

热门文章
