automapper

尽一切可能避免反射。如果能基于接口设计软件，为什么反射？

“不相同实体”这个概念，如果拿到一个不懂面向对象技术，不懂继承和多态基本概念的程序设计师，其实就不是什么好事儿了。好像反射这个词儿挺高大上，就好像说任何程序都能变为字符串、能变为0、1、0、1 一串串数字，多么万能啊？！实际上为了同样功能往往绕一大圈而已，并不惜性能。

就算是反射，起码也往往会仅仅对同一个类型进行一次遍历，将遍历处理结果动态产生一个 Delegate，然后缓存起来，以后千万次地重用这些 Delegate，而不是什么滥用最原始的反射代码。

现在的 .net 使用 dynamic 模式来自动优化和处理这类编程，不需要你多写反射代码。

那么你主动地基于接口来编程设计，胜过反射几百倍。

用表达式树，我完整写了一个

using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Text;

using System.Threading.Tasks;



namespace T392496087

{

    class A

    {

        public string Str { get; set; }

        public int IntVal { get; set; }

    }



    class B

    {

        public string str { get; set; }

        public int intval { get; set; }

        public override string ToString()

        {

            return string.Format("B str = {0}, intval = {1};", str, intval);

        }

    }



    class Program

    {

        static List<A> GenAList(int count)

        {

            List<A> list = new List<A>();

            Random rnd = new Random();

            for (int i = 1; i <= count; i++)

                list.Add(new A { IntVal = rnd.Next(0, 100), Str = "A:" + i.ToString() });

            return list;

        }



        static List<B> HardCoded(List<A> list)

        {

            return list.Select(x => new B() { intval = x.IntVal, str = x.Str }).ToList();

        }



        static List<B> ByReflection(List<A> list)

        {

            var props = typeof(A).GetProperties().Select(x => new { a = x, b = typeof(B).GetProperty(x.Name.ToLower()) });

            return list.Select(x => {

                B b = new B();

                foreach (var item in props)

                    item.b.SetValue(b, item.a.GetValue(x, null));

                return b;

            }).ToList();

        }



        static List<B> ByExpTree(List<A> list)

        {

            var props = typeof(A).GetProperties().Select(x => new { a = x, b = typeof(B).GetProperty(x.Name.ToLower()) });

            var param = Expression.Parameter(typeof(A), "x");

            List<Expression> exps = new List<Expression>();

            var cre = Expression.New(typeof(B));

            var newb = Expression.Variable(typeof(B));

            var assb = Expression.Assign(newb, cre);

            exps.Add(assb);

            foreach (var item in props)

            {

                var getexp = Expression.MakeMemberAccess(param, item.a);

                var setexp = Expression.MakeMemberAccess(newb, item.b);

                var ass = Expression.Assign(setexp, getexp);

                exps.Add(ass);

            }

            exps.Add(newb);

            var body = Expression.Block(new ParameterExpression [] { newb }, exps);

            var sel = Expression.Lambda<Func<A, B>>(body, param);

            return list.Select(sel.Compile()).ToList();

        }



        static void TestIt(string title, Func<List<A>, List<B>> foo, int count, int maxoutput = 5)

        {

            var listA = GenAList(count);

            DateTime dt = DateTime.Now;

            var listB = foo(listA);

            DateTime dt2 = DateTime.Now;

            Console.WriteLine(title);

            Console.WriteLine("time spent: " + new TimeSpan(dt2.Ticks - dt.Ticks).TotalSeconds + " sec.");

            string omit = "";

            if (count <= maxoutput)

                maxoutput = count;

            else

                omit = "...\n";

            for (int i = 0; i < maxoutput; i++)

                Console.WriteLine(listB[i]);

            Console.Write(omit);

        }

        static void Main(string[] args)

        {

            int n = 200000;

            TestIt("HardCoded", HardCoded, n);

            TestIt("ByReflection", ByReflection, n);

            TestIt("ByExpTree", ByExpTree, n);

        }

    }

}

HardCoded
time spent: 0.0390033 sec.
B str = A:1, intval = 74;
B str = A:2, intval = 87;
B str = A:3, intval = 17;
B str = A:4, intval = 93;
B str = A:5, intval = 61;
...
ByReflection
time spent: 0.7790435 sec.
B str = A:1, intval = 43;
B str = A:2, intval = 74;
B str = A:3, intval = 88;
B str = A:4, intval = 84;
B str = A:5, intval = 3;
...
ByExpTree
time spent: 0.0380019 sec.
B str = A:1, intval = 66;
B str = A:2, intval = 6;
B str = A:3, intval = 20;
B str = A:4, intval = 67;
B str = A:5, intval = 52;
...
Press any key to continue . . .
可以看出，性能媲美硬编码，远远超过反射。

23种设计模式之一，包装模式。

别用“百万级”吓唬人啊。

也许你的数据库里的数据有百万，但你实际使用其实最多也就几百条-几k条。
至于转换其实你也没必要担心，如果你去看java，go的最流行的大数据，不知道你会不会“骂娘”，整个"mapreduce"过程比你想的要“弱智”和“性能低”的多

那人家为啥能那么牛叉呢？因为他可以并行啊（单机的并行，cpu的并行，多机的并行）

引用 6 楼 足球中国 的回复:

23种设计模式之一，包装模式。

其实直截了当地说明了 .net “如何做”的.net模式名词儿，胜过说空洞的GOF模式名词儿。

总的来说，对于频繁重复操作的优化，原则就是“由弱类型变强类型、由低级动态方式变为预编译缓存形式、由只注重结果变为注重过程”。反射看似高大上，但是往往初级的复杂技术编程方式充其量只能达到刚刚实现功能而已，绕了一大圈反而性能很差。

比如说“类型转换，例如

public static User Converter2User(IDataRecord rd)

{

    return new User{

        name= (string)rd["name"],

        address=(string)rd["addr"],

        level = 获取组织架构层级((string)rd["department"])

    };

    

这样一个方法，甚至是

var func = new Func<IDataRecord,User>(rd=>

        new User{

          name= (string)rd["name"],

          address=(string)rd["addr"],

        level = 获取组织架构层级((string)rd["department"])

      }); 

就可以用到类似

var result = (from IDataRecord rd in dbcommand.ExecuteReader()

        select Convert2User(rd)).ToList();

或者

var result = (from IDataRecord rd in dbcommand.ExecuteSca()

        select func(rd)).ToList();

这样的代码中。

所以说到性能，不管是静态写一个转换过程，还是动态产生一个委托（#5楼使用 Linq 表达式树动态产生委托函数），总之是类型越强则性能越靠谱。

引用 6 楼 足球中国 的回复:

23种设计模式之一，包装模式。

只要是针对”类型转换“设计开发，其实都可以往这上面靠。

还是具体谈 .net 模式更科学更可操作。谈 GOF 设计模式名词儿往往是一个初步的思路。

方法很多啊，不过楼上都是设计大系统的
小系统用用反射也没事

class Digit

{

    public Digit(double d) { val = d; }

    public double val;

    // ...other members



    // User-defined conversion from Digit to double

    public static implicit operator double(Digit d)

    {

        return d.val;

    }

    //  User-defined conversion from double to Digit

    public static implicit operator Digit(double d)

    {

        return new Digit(d);

    }

}



class Program

{

    static void Main(string[] args)

    {

        Digit dig = new Digit(7);

        //This call invokes the implicit "double" operator

        double num = dig;

        //This call invokes the implicit "Digit" operator

        Digit dig2 = 12;

        Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);

        Console.ReadLine();

    }

}

用反射是最慢的方法

直接new对象赋值属性不干嘛？

反射比较慢吧

就要用反射，就用，就用

mark,不为别的，以后留着用

动态语言特性，不知道如何破性能的难题。
还是基于接口比较好。

不错，学到了，哈哈哈

23种设计模式之一，包装模式。

就实际解决问题来说，装饰模式，算是比较快的解决方案了，理论上讲没有比这更快的转换方案了

.net 反射效率有点低。

尽一切可能避免反射。如果能基于接口设计软件，为什么反射？

高大上的问题。如果明确知道要转换和转换后的对象，直接new一个，赋值就好。
如果不知道的话，特别是不知道对象的属性类型，那就不知道了....

我是后期接手的项目，所以对于当时为什么服务端返回类型和客户端类型为什么不一样，这我也不清楚，都是在客户端定义特性，指定字段转换，项目进度问题所以就直接用到反射。
谢谢大家。

 public delegate void SetValueDelegate(object target, object arg);

    public static class DynamicMethodFactory

    {

        public static SetValueDelegate CreatePropertySetter(PropertyInfo property)

        {

            if (property == null)

                throw new ArgumentNullException("property");



            if (!property.CanWrite)

                return null;



            MethodInfo setMethod = property.GetSetMethod(true);



            DynamicMethod dm = new DynamicMethod("PropertySetter", null,

                new Type[] { typeof(object), typeof(object) }, property.DeclaringType, true);



           

            ILGenerator il = dm.GetILGenerator();



            if (!setMethod.IsStatic)

            {

                il.Emit(OpCodes.Ldarg_0);

            }

            il.Emit(OpCodes.Ldarg_1);



            EmitCastToReference(il, property.PropertyType);

            if (!setMethod.IsStatic && !property.DeclaringType.IsValueType)

            {

                il.EmitCall(OpCodes.Callvirt, setMethod, null);

            }

            else

                il.EmitCall(OpCodes.Call, setMethod, null);



            il.Emit(OpCodes.Ret);



            return (SetValueDelegate)dm.CreateDelegate(typeof(SetValueDelegate));

        }

        private static void EmitCastToReference(ILGenerator il, Type type)

        {

            if (type.IsValueType)

                il.Emit(OpCodes.Unbox_Any, type);

            else

                il.Emit(OpCodes.Castclass, type);

        }

    }

上面是我在网上查到的 关于反射优化，用到委托和Emit,效率上比直接赋值慢了十几倍，但是比反射快了一半。

mark,我公司用的框架就是通过反射获取数据库中的数据，数据量一大就非常难受

厉害啊兄弟  加油

建议你写个代码生成器？ 直接new 然后赋值。然后多线程并行处理。

真是太感谢楼主了，找了好久！