在《一句代码实现批量数据绑定》中，我通过界面控件ID与作为数据源的实体属性名之间的映射实现了批量数据绑定。由于里面频繁涉及对属性的反射——通过反射从实体对象中获取某个属性值；通过反射为控件的某个属性赋值，所以这不是一种高效的操作方式。为了提升性能，我通过IL Emit的方式创建了一个PropertyAccessor组件，以实现高效的属性操作。如果你看了我在文中给出的三种属性操作性能的测试结果，相信会对PropertyAccessor的作用有深刻的印象。[源代码从这里下载]
目录：
一、PropertyAccessor与PropertyAccessor<T>的API定义
二、如何通过PropertyAccessor获取属性值和为属性赋值
三、Set和Get的实现
四、比较三种属性操作的性能
五、PropertyAccessor的ExpressionTree版本
一、PropertyAccessor与PropertyAccessor<T>的API定义
我们照例从编程——即如何使用PropertyAccessor进行属性操作（获取属性值/为属性赋值）讲起，所有先来看看PropertyAccessor提供了哪些API功我们调用。从下面的代码片断我们可以看到，PropertyAccessor得构造函数接受两个参数：目标对象的类型和属性名称，然后通过Get获取目标对象相应属性的值，通过Set方法为目标对象的属性进行赋值。此外，PropertyAccessor还提供了两个对应的Get/Set静态方法通过指定具体的目标对象和属性名称实现相同的操作。
1: public class PropertyAccessor
2: {
3: public PropertyAccessor(Type targetType, string propertyName);
4:
5: public object Get(object obj);
6: public void Set(object obj, object value);
7:
8: public static object Get(object obj, string propertyName);
9: public static void Set(object obj, string propertyName, object value);
10: //Others...
11: }
如果预先知道了目标对象的类型，可能使用泛型的PropertyAccessor<T>会使操作更加方便。PropertyAccessor<T>继承自PropertyAccessor，定义如下：
1: public class PropertyAccessor<T> : PropertyAccessor
2: {
3: public PropertyAccessor(string propertyName);
4:
5: public static object Get(T obj, string propertyName);
6: public static void Set(T obj, string propertyName, object value);
7: }
二、如何通过PropertyAccessor获取属性值和为属性赋值
现在我们来演示如何通PropertyAccessor<T>来对目标对象的属性赋值，以及如何或者目标对象相应属性的值。现在我们定义如下一个实体类型：Contact。
1: public class Contact
2: {
3: public string FirstName { get; set; }
4: public string LastName { get; set; }
5: public string Gender { get; set; }
6: public int? Age { get; set; }
7: public DateTime? Birthday { get; set; }
8: }
然后我们在一个Console应用的Main方法中编写如下一段代码。在这段代码中，我创建了一个Contact对象，然后通过调用PropertyAccessor<Contact>类型的静态方法Set为该对象的各个属性进行复制。然后将各个属性值按照一定的格式打印出来，而获取属性值是通过调用静态方法Get完成的。
1: static void Main(string[] args)
2: {
3: var contact = new Contact();
4:
5: PropertyAccessor<Contact>.Set(contact, "FirstName", "Jiang");
6: PropertyAccessor<Contact>.Set(contact, "LastName", "Jin Nan");
7: PropertyAccessor<Contact>.Set(contact, "Gender", "Male");
8: PropertyAccessor<Contact>.Set(contact, "Age", 30);
9: PropertyAccessor<Contact>.Set(contact, "Birthday", new DateTime(1981, 8, 24));
10:
11: Console.WriteLine("Contact({0} {1})\n\tGender\t:{2}\n\tAge\t:{3}\n\tBirth\t:{4}",
12: PropertyAccessor<Contact>.Get(contact, "FirstName"),
13: PropertyAccessor<Contact>.Get(contact, "LastName"),
14: PropertyAccessor<Contact>.Get(contact, "Gender"),
15: PropertyAccessor<Contact>.Get(contact, "Age"),
16: PropertyAccessor<Contact>.Get(contact, "Birthday"));
17: }
输出结果：
1: Contact(Jiang Jin Nan)
2: Gender :Male
3: Age :30
4: Birth :8/24/1981 12:00:00 AM
三、Set和Get的实现
虽然PropertyAccessor是一个很小的组件，但也不太可能将所有的代码列出来。在这里，我只是只能将核心部分作一下简单介绍，如果你想了解整个PropertyAccessor的实现，可以下载源代码。PropertyAccessor的两个核心的方法就是Get和Set。而在内部，它们对应着两个核心的方法：CreateGetFunction和CreateSetAction，它们利用IL Emit。下面是CreateGetFunction的实现:创建一个DynamicMethod对象，通过IL Emit调用属性的Getter方法，并将结果返回。最后通过DynamicMethod的CreateDelegate方法创建一个Func<object,object>委托对象并在本地缓存起来，供或许的获取属性值操作之用。
1: private Func<object, object> CreateGetFunction()
2: {
3: //...
4: DynamicMethod method = new DynamicMethod("GetValue", typeof(object), new Type[] { typeof(object) });
5: ILGenerator ilGenerator = method.GetILGenerator();
6: ilGenerator.DeclareLocal(typeof(object));
7: ilGenerator.Emit(OpCodes.Ldarg_0);
8: ilGenerator.Emit(OpCodes.Castclass, this.TargetType);
9: ilGenerator.EmitCall(OpCodes.Call, this.GetMethod, null);
10: if (this.GetMethod.ReturnType.IsValueType)
11: {
12: ilGenerator.Emit(OpCodes.Box, this.GetMethod.ReturnType);
13: }
14: ilGenerator.Emit(OpCodes.Stloc_0);
15: ilGenerator.Emit(OpCodes.Ldloc_0);
16: ilGenerator.Emit(OpCodes.Ret);
17:
18: method.DefineParameter(1, ParameterAttributes.In, "value");
19: return (Func<object, object>)method.CreateDelegate(typeof(Func<object, object>));
20: }
与CreateGetFunction类似，CreateSetAction同样创建一个DynamicMethod对象，通过IL Emit的方式调用属性的Setter方法。最后通过DynamicMethod的CreateDelegate方法创建一个Action<object,object>委托对象并在本地缓存起来，供后续的属性赋值操作之用。
1: private Action<object, object> CreateSetAction()
2: {
3: //...
4: DynamicMethod method = new DynamicMethod("SetValue", null, new Type[] { typeof(object), typeof(object) });
5: ILGenerator ilGenerator = method.GetILGenerator();
6: Type paramType = this.SetMethod.GetParameters()[0].ParameterType;
7: ilGenerator.DeclareLocal(paramType);
8: ilGenerator.Emit(OpCodes.Ldarg_0);
9: ilGenerator.Emit(OpCodes.Castclass, this.TargetType);
10: ilGenerator.Emit(OpCodes.Ldarg_1);
11: if (paramType.IsValueType)
12: {
13: ilGenerator.Emit(OpCodes.Unbox, paramType);
14: if (valueTpyeOpCodes.ContainsKey(paramType))
15: {
16: OpCode load = (OpCode)valueTpyeOpCodes[paramType];
17: ilGenerator.Emit(load);
18: }
19: else
20: {
21: ilGenerator.Emit(OpCodes.Ldobj, paramType);
22: }
23: }
24: else
25: {
26: ilGenerator.Emit(OpCodes.Castclass, paramType);
27: }
28:
29: ilGenerator.EmitCall(OpCodes.Callvirt, this.SetMethod, null);
30: ilGenerator.Emit(OpCodes.Ret);
31:
32: method.DefineParameter(1, ParameterAttributes.In, "obj");
33: method.DefineParameter(2, ParameterAttributes.In, "value");
34: return (Action<object, object>)method.CreateDelegate(typeof(Action<object, object>));
35: }
四、比较三种属性操作的性能
我想大家最关心的还是“性能”的问题，现在我们就来编写一个性能测试的程序。在这个程序中我们比较三种典型的属性操作耗费的时间：直接通过属性赋值（或者取值）、通过IL Emit（即PropertyAccessor）和PropertyInfo对属性赋值（或者取值）。我们定义两个简单的类型Foo和Bar，Foo中定义一个类型和名称为Bar的可读写的属性。
1: public class Foo
2: {
3: public Bar Bar { get; set; }
4: }
5: public class Bar
6: { }下面是用于比较三种属性复制操作的测试程序SetTest，方法参数为复制操作的次数，最后将三种属性赋值操作的总时间（单位毫秒）分别打印出来。
1: public static void SetTest(int times)
2: {
3: Foo foo = new Foo();
4: Bar bar = new Bar();
5: Stopwatch stopwatch = new Stopwatch();
6: PropertyAccessor<Foo> propertyAccessor = new PropertyAccessor<Foo>("Bar");
7: PropertyInfo propertyInfo = typeof(Foo).GetProperty("Bar");
8: stopwatch.Start();
9: for (int i = 0; i < times; i++)
10: {
11: foo.Bar = bar;
12: }
13: long duration1 = stopwatch.ElapsedMilliseconds;
14:
15: stopwatch.Restart();
16: for (int i = 0; i < times; i++)
17: {
18: propertyAccessor.Set(foo, bar);
19: }
20: long duration2 = stopwatch.ElapsedMilliseconds;
21:
22: stopwatch.Restart();
23: for (int i = 0; i < times; i++)
24: {
25: propertyInfo.SetValue(foo, bar, null);
26: }
27: long duration3 = stopwatch.ElapsedMilliseconds;
28: Console.WriteLine("{0,-10}{1,-10}{2,-10}{3,-10}", times, duration1, duration2, duration3);
29: }
下面是下面是用于比较三种或者属性值操作的测试程序GetTest，定义形式和上面一样：
1: public static void GetTest(int times)
2: {
3: Foo foo = new Foo { Bar = new Bar() };
4: Stopwatch stopwatch = new Stopwatch();
5: PropertyAccessor<Foo> propertyAccessor = new PropertyAccessor<Foo>("Bar");
6: PropertyInfo propertyInfo = typeof(Foo).GetProperty("Bar");
7: stopwatch.Start();
8: for (int i = 0; i < times; i++)
9: {
10: var bar = foo.Bar;
11: }
12: long duration1 = stopwatch.ElapsedMilliseconds;
13:
14: stopwatch.Restart();
15: for (int i = 0; i < times; i++)
16: {
17: var bar = propertyAccessor.Get(foo);
18: }
19: long duration2 = stopwatch.ElapsedMilliseconds;
20:
21: stopwatch.Restart();
22: for (int i = 0; i < times; i++)
23: {
24: var bar = propertyInfo.GetValue(foo, null);
25: }
26: long duration3 = stopwatch.ElapsedMilliseconds;
27: Console.WriteLine("{0,-10}{1,-10}{2,-10}{3,-10}", times, duration1, duration2, duration3);
28: }
然后，我们在Console应用的Main方法中编写如下的代码，旨在测试次数分别为100000（十万）、1000000（一百万）和10000000（一千万）下三种不同形式的属性操作所耗用的时间。
1: static void Main(string[] args)
2: {
3: Console.WriteLine("{0,-10}{1,-10}{2,-10}{3,-10}", "Times", "General", "IL Emit", "Reflection");
4: SetTest(100000);
5: SetTest(1000000);
6: SetTest(10000000);
7:
8: Console.WriteLine();
9: GetTest(100000);
10: GetTest(1000000);
11: GetTest(10000000);
12: }
输出结果：
1: Times General IL Emit Reflection
2: 100000 1 17 204
3: 1000000 12 110 1918
4: 10000000 131 1103 18919
5:
6: 100000 1 10 153
7: 1000000 11 101 1534
8: 10000000 112 1009 15425
由于我的笔记本已经差不多5年的历史，性能不是很好，所以更能反映出三种操作类型的性能差异。我们对属性直接进行赋值和取值是最快的，这一点没有什么好说的。我们关心的是，IL Emit的方式和单纯使用PropertyInfo进行反射（并且值得一提的是：PropertyInfo之前已经保存起来，并没有频繁去创建）的方式这两者的性能依然有本质的差别。如果你对数字不是敏感，那就看看下面的曲线图吧。
五、PropertyAccessor的ExpressionTree版本（2011-03-25）
对于很多人来说，IL Emit编程是一件很繁琐的事。反正我多这比较头疼，我一般的做法都是将需要的逻辑通过代码写出来，编译之后跟据IL写Emit代码。而我们更喜欢采用的则是ExpressionTree，为此我编写了PropertyAccessor的ExpressionTree版本（你可以从这里下载）。两个版本主要的不同还是在于上述两个方法：CreateGetFunction和CreateSetAction。下面是两个方法的定义：
1: private Func<object, object> CreateGetFunction()
2: {
3: var getMethod = this.Property.GetGetMethod();
4: var target = Expression.Parameter(typeof(object), "target");
5: var castedTarget = getMethod.IsStatic ? null : Expression.Convert(target, this.TargetType);
6: var getProperty = Expression.Property(castedTarget, this.Property);
7: var castPropertyValue = Expression.Convert(getProperty, typeof(object));
8: return Expression.Lambda<Func<object, object>>(castPropertyValue, target).Compile();
9: }
10:
11: private Action<object, object> CreateSetAction()
12: {
13: var setMethod = this.Property.GetSetMethod();
14: var target = Expression.Parameter(typeof(object), "target");
15: var propertyValue = Expression.Parameter(typeof(object), "value");
16: var castedTarget = setMethod.IsStatic ? null : Expression.Convert(target, this.TargetType);
17: var castedpropertyValue = Expression.Convert(propertyValue, this.PropertyType);
18: var propertySet = Expression.Call(castedTarget, setMethod, castedpropertyValue);
19: return Expression.Lambda<Action<object, object>>(propertySet, target, propertyValue).Compile();
20: }
晚绑定场景下对象属性赋值和取值可以不需要PropertyInfo
三种属性操作性能比较：PropertyInfo + Expression Tree + Delegate.CreateDelegate
关于Expression Tree和IL Emit的所谓的"性能差别"
共同學(xué)習(xí)，寫(xiě)下你的評(píng)論
評(píng)論加載中...
作者其他優(yōu)質(zhì)文章
