C#类与结构体究竟谁快——各种函数调用模式速度评测

以前我一直有个疑惑——在C#中，究竟是类（class）比较快，还是结构体（struct）比较快？
当时没有深究。

最近我遇到一个难题，需要将一些运算大的指针操作代码给封装一下。原先为了性能，这些代码是以硬编码的形式混杂在算法逻辑之中，不但影响了算法逻辑的可读性，其本身的指针操作代码枯燥、难懂、易写错，不易维护。所以我希望将其封装一下，简化代码编写、提高可维护性，但同时要尽可能地保证性能。
由于那些指针操作代码很灵活，简单的封装不能解决问题，还需要用到接口（interface）以实现一些动态调用功能。
为了简化代码，还打算实现一些泛型方法。
本来还想因32位指针、64位指针的不同而构造泛型类，可惜发现C#不支持将int/long作为泛型类型约束，只好作罢。将设计改为——分别为32位指针、64位指针编写不同的类，它们实现同一个接口。

在C#中，有两类封装技术——
1.基于类（class）的封装。在基类中定义好操作方法，然后在派生类中实现操作方法。
2.基于结构体（struct）的封装。在接口中定义好操作方法，然后在结构体中实现该接口的操作方法。
我分别使用这两类封装技术编写测试代码，然后做性能测试。

经过反复思索，考虑 类、结构体、接口、泛型 的组合，我找出了15种函数调用模式——
硬编码
静态调用
调用派生类
调用结构体
调用基类
调用派生类的接口
调用结构体的接口
基类泛型调用派生类
基类泛型调用基类
接口泛型调用派生类
接口泛型调用结构体
接口泛型调用结构体引用
接口泛型调用基类
接口泛型调用派生类的接口
接口泛型调用结构体的接口

测试代码为——

view plain copy to clipboard print ?

1. using System; 
2. using System.Collections.Generic; 
3. using System.Text; 
4. using System.Diagnostics; 
5.  
6. namespace TryPointerCall 
7. { 
8.     /// <summary> 
9.     /// 指针操作接口 
10.     /// </summary> 
11.     public interface IPointerCall 
12.     { 
13.         /// <summary> 
14.         /// 指针操作 
15.         /// </summary> 
16.         /// <param name="p">源指针</param> 
17.         /// <returns>修改后指针</returns> 
18.         unsafe byte* Ptr(byte* p); 
19.     } 
21. #region 非泛型 
22.     /// <summary> 
23.     /// [非泛型] 指针操作基类 
24.     /// </summary> 
25.     public abstract class PointerCall : IPointerCall 
26.     { 
27.         public abstract unsafe byte* Ptr(byte* p); 
28.     } 
29.  
30.     /// <summary> 
31.     /// [非泛型] 指针操作派生类: 指针+偏移 
32.     /// </summary> 
33.     public class PointerCallAdd : PointerCall 
34.     { 
35.         /// <summary> 
36.         /// 偏移值 
37.         /// </summary> 
38.         public int Offset = 0; 
39.  
40.         public override unsafe byte* Ptr(byte* p) 
41.         { 
42.             return unchecked(p + Offset); 
43.         } 
44.     } 
45.  
46.     /// <summary> 
47.     /// [非泛型] 指针操作结构体: 指针+偏移 
48.     /// </summary> 
49.     public struct SPointerCallAdd : IPointerCall 
50.     { 
51.         /// <summary> 
52.         /// 偏移值 
53.         /// </summary> 
54.         public int Offset; 
55.  
56.         public unsafe byte* Ptr(byte* p) 
57.         { 
58.             return unchecked(p + Offset); 
59.         } 
60.     } 
62. #endregion 
64. #region 泛型 
65.     // !!! C#不支持将整数类型作为泛型约束 !!! 
66.     //public abstract class GenPointerCall<T> : IPointerCall where T: int, long 
67.     //{ 
68.     //    public abstract unsafe byte* Ptr(byte* p); 
69.  
70.     //    void d() 
71.     //    { 
72.     //    } 
73.     //} 
75. #endregion 
77. #region 全部测试 
78.     /// <summary> 
79.     /// 指针操作的一些常用函数 
80.     /// </summary> 
81.     public static class PointerCallTool 
82.     { 
83.         private const int CountLoop = 200000000;    // 循环次数 
84.  
85.         /// <summary> 
86.         /// 调用指针操作 
87.         /// </summary> 
88.         /// <typeparam name="T">具有IPointerCall接口的类型。</typeparam> 
89.         /// <param name="ptrcall">调用者</param> 
90.         /// <param name="p">源指针</param> 
91.         /// <returns>修改后指针</returns> 
92.         public static unsafe byte* CallPtr<T>(T ptrcall, byte* p) where T : IPointerCall 
93.         { 
94.             return ptrcall.Ptr(p); 
95.         } 
96.         public static unsafe byte* CallClassPtr<T>(T ptrcall, byte* p) where T : PointerCall 
97.         { 
98.             return ptrcall.Ptr(p); 
99.         } 
100.         public static unsafe byte* CallRefPtr<T>(ref T ptrcall, byte* p) where T : IPointerCall 
101.         { 
102.             return ptrcall.Ptr(p); 
103.         } 
104.  
105.         // C#不允许将特定的结构体作为泛型约束。所以对于结构体只能采用上面那个方法，通过IPointerCall接口进行约束，可能会造成性能下降。 
106.         //public static unsafe byte* SCallPtr<T>(T ptrcall, byte* p) where T : SPointerCallAdd 
107.         //{ 
108.         //    return ptrcall.Ptr(p); 
109.         //} 
110.  
111.         private static int TryIt_Static_Offset; 
112.         private static unsafe byte* TryIt_Static_Ptr(byte* p) 
113.         { 
114.             return unchecked(p + TryIt_Static_Offset); 
115.         } 
116.         /// <summary> 
117.         /// 执行测试 - 静态调用 
118.         /// </summary> 
119.         /// <param name="sOut">文本输出</param> 
120.         private static unsafe void TryIt_Static(StringBuilder sOut) 
121.         { 
122.             TryIt_Static_Offset = 1; 
123.  
124.             // == 性能测试 == 
125.             byte* p = null; 
126.             Stopwatch sw = new Stopwatch(); 
127.             int i; 
128.             unchecked 
129.             { 
130.                 #region 测试 
131.                 // 硬编码 
132.                 sw.Reset(); 
133.                 sw.Start(); 
134.                 for (i = 0; i < CountLoop; ++i) 
135.                 { 
136.                     p = p + TryIt_Static_Offset; 
137.                 } 
138.                 sw.Stop(); 
139.                 sOut.AppendLine(string.Format("硬编码:\t{0}", sw.ElapsedMilliseconds)); 
140.  
141.                 // 静态调用 
142.                 sw.Reset(); 
143.                 sw.Start(); 
144.                 for (i = 0; i < CountLoop; ++i) 
145.                 { 
146.                     p = TryIt_Static_Ptr(p); 
147.                 } 
148.                 sw.Stop(); 
149.                 sOut.AppendLine(string.Format("静态调用:\t{0}", sw.ElapsedMilliseconds)); 
151.                 #endregion // 测试 
152.             } 
153.         } 
154.  
155.         /// <summary> 
156.         /// 执行测试 - 非泛型 
157.         /// </summary> 
158.         /// <param name="sOut">文本输出</param> 
159.         private static unsafe void TryIt_NoGen(StringBuilder sOut) 
160.         { 
161.             // 创建 
162.             PointerCallAdd pca = new PointerCallAdd(); 
163.             SPointerCallAdd spca; 
164.             pca.Offset = 1; 
165.             spca.Offset = 1; 
166.  
167.             // 转型 
168.             PointerCall pca_base = pca; 
169.             IPointerCall pca_itf = pca; 
170.             IPointerCall spca_itf = spca; 
171.  
172.             // == 性能测试 == 
173.             byte* p = null; 
174.             Stopwatch sw = new Stopwatch(); 
175.             int i; 
176.             unchecked 
177.             { 
178.                 #region 调用 
179.                 #region 直接调用 
180.                 // 调用派生类 
181.                 sw.Reset(); 
182.                 sw.Start(); 
183.                 for (i = 0; i < CountLoop; ++i) 
184.                 { 
185.                     p = pca.Ptr(p); 
186.                 } 
187.                 sw.Stop(); 
188.                 sOut.AppendLine(string.Format("调用派生类:\t{0}", sw.ElapsedMilliseconds)); 
189.  
190.                 // 调用结构体 
191.                 sw.Reset(); 
192.                 sw.Start(); 
193.                 for (i = 0; i < CountLoop; ++i) 
194.                 { 
195.                     p = spca.Ptr(p); 
196.                 } 
197.                 sw.Stop(); 
198.                 sOut.AppendLine(string.Format("调用结构体:\t{0}", sw.ElapsedMilliseconds)); 
200.                 #endregion  // 直接调用 
202.                 #region 间接调用 
203.                 // 调用基类 
204.                 sw.Reset(); 
205.                 sw.Start(); 
206.                 for (i = 0; i < CountLoop; ++i) 
207.                 { 
208.                     p = pca_base.Ptr(p); 
209.                 } 
210.                 sw.Stop(); 
211.                 sOut.AppendLine(string.Format("调用基类:\t{0}", sw.ElapsedMilliseconds)); 
212.  
213.                 // 调用派生类的接口 
214.                 sw.Reset(); 
215.                 sw.Start(); 
216.                 for (i = 0; i < CountLoop; ++i) 
217.                 { 
218.                     p = pca_itf.Ptr(p); 
219.                 } 
220.                 sw.Stop(); 
221.                 sOut.AppendLine(string.Format("调用派生类的接口:\t{0}", sw.ElapsedMilliseconds)); 
222.  
223.                 // 调用结构体的接口 
224.                 sw.Reset(); 
225.                 sw.Start(); 
226.                 for (i = 0; i < CountLoop; ++i) 
227.                 { 
228.                     p = spca_itf.Ptr(p); 
229.                 } 
230.                 sw.Stop(); 
231.                 sOut.AppendLine(string.Format("调用结构体的接口:\t{0}", sw.ElapsedMilliseconds)); 
233.                 #endregion  // 间接调用 
235.                 #endregion  // 调用 
237.                 #region 泛型调用 
239.                 #region 泛型基类约束 
240.                 // 基类泛型调用派生类 
241.                 sw.Reset(); 
242.                 sw.Start(); 
243.                 for (i = 0; i < CountLoop; ++i) 
244.                 { 
245.                     p = CallClassPtr(pca, p); 
246.                 } 
247.                 sw.Stop(); 
248.                 sOut.AppendLine(string.Format("基类泛型调用派生类:\t{0}", sw.ElapsedMilliseconds)); 
249.  
250.                 // 基类泛型调用基类 
251.                 sw.Reset(); 
252.                 sw.Start(); 
253.                 for (i = 0; i < CountLoop; ++i) 
254.                 { 
255.                     p = CallClassPtr(pca_base, p); 
256.                 } 
257.                 sw.Stop(); 
258.                 sOut.AppendLine(string.Format("基类泛型调用基类:\t{0}", sw.ElapsedMilliseconds)); 
260.                 #endregion // 泛型基类约束 
262.                 #region 泛型接口约束 - 直接调用 
263.                 // 接口泛型调用派生类 
264.                 sw.Reset(); 
265.                 sw.Start(); 
266.                 for (i = 0; i < CountLoop; ++i) 
267.                 { 
268.                     p = CallPtr(pca, p); 
269.                 } 
270.                 sw.Stop(); 
271.                 sOut.AppendLine(string.Format("接口泛型调用派生类:\t{0}", sw.ElapsedMilliseconds)); 
272.  
273.                 // 接口泛型调用结构体 
274.                 sw.Reset(); 
275.                 sw.Start(); 
276.                 for (i = 0; i < CountLoop; ++i) 
277.                 { 
278.                     p = CallPtr(spca, p); 
279.                 } 
280.                 sw.Stop(); 
281.                 sOut.AppendLine(string.Format("接口泛型调用结构体:\t{0}", sw.ElapsedMilliseconds)); 
282.  
283.                 // 接口泛型调用结构体引用 
284.                 sw.Reset(); 
285.                 sw.Start(); 
286.                 for (i = 0; i < CountLoop; ++i) 
287.                 { 
288.                     p = CallRefPtr(ref spca, p); 
289.                 } 
290.                 sw.Stop(); 
291.                 sOut.AppendLine(string.Format("接口泛型调用结构体引用:\t{0}", sw.ElapsedMilliseconds)); 
293.                 #endregion  // 直接调用 
295.                 #region 间接调用 
296.                 // 接口泛型调用基类 
297.                 sw.Reset(); 
298.                 sw.Start(); 
299.                 for (i = 0; i < CountLoop; ++i) 
300.                 { 
301.                     p = CallPtr(pca_base, p); 
302.                 } 
303.                 sw.Stop(); 
304.                 sOut.AppendLine(string.Format("接口泛型调用基类:\t{0}", sw.ElapsedMilliseconds)); 
305.  
306.                 // 接口泛型调用派生类的接口 
307.                 sw.Reset(); 
308.                 sw.Start(); 
309.                 for (i = 0; i < CountLoop; ++i) 
310.                 { 
311.                     p = CallPtr(pca_itf, p); 
312.                 } 
313.                 sw.Stop(); 
314.                 sOut.AppendLine(string.Format("接口泛型调用派生类的接口:\t{0}", sw.ElapsedMilliseconds)); 
315.  
316.                 // 接口泛型调用结构体的接口 
317.                 sw.Reset(); 
318.                 sw.Start(); 
319.                 for (i = 0; i < CountLoop; ++i) 
320.                 { 
321.                     p = CallPtr(spca_itf, p); 
322.                 } 
323.                 sw.Stop(); 
324.                 sOut.AppendLine(string.Format("接口泛型调用结构体的接口:\t{0}", sw.ElapsedMilliseconds)); 
326.                 #endregion  // 间接调用 
328.                 #endregion  // 泛型调用 
329.  
330.             } 
331.         } 
332.  
333.         /// <summary> 
334.         /// 执行测试 - 泛型 
335.         /// </summary> 
336.         /// <param name="sOut">文本输出</param> 
337.         private static unsafe void TryIt_Gen(StringBuilder sOut) 
338.         { 
339.             // !!! C#不支持将整数类型作为泛型约束 !!! 
340.         } 
341.  
342.         /// <summary> 
343.         /// 执行测试 
344.         /// </summary> 
345.         public static string TryIt() 
346.         { 
347.             StringBuilder sOut = new StringBuilder(); 
348.             sOut.AppendLine("== PointerCallTool.TryIt() =="); 
349.             TryIt_Static(sOut); 
350.             TryIt_NoGen(sOut); 
351.             TryIt_Gen(sOut); 
352.             sOut.AppendLine(); 
353.             return sOut.ToString(); 
354.         } 
355.     } 
356. #endregion 
357.  
358. } 

using System; using System.Collections.Generic; using System.Text; using System.Diagnostics; namespace TryPointerCall { /// <summary> /// 指针操作接口 /// </summary> public interface IPointerCall { /// <summary> /// 指针操作 /// </summary> /// <param name="p">源指针</param> /// <returns>修改后指针</returns> unsafe byte* Ptr(byte* p); } #region 非泛型 /// <summary> /// [非泛型] 指针操作基类 /// </summary> public abstract class PointerCall : IPointerCall { public abstract unsafe byte* Ptr(byte* p); } /// <summary> /// [非泛型] 指针操作派生类: 指针+偏移 /// </summary> public class PointerCallAdd : PointerCall { /// <summary> /// 偏移值 /// </summary> public int Offset = 0; public override unsafe byte* Ptr(byte* p) { return unchecked(p + Offset); } } /// <summary> /// [非泛型] 指针操作结构体: 指针+偏移 /// </summary> public struct SPointerCallAdd : IPointerCall { /// <summary> /// 偏移值 /// </summary> public int Offset; public unsafe byte* Ptr(byte* p) { return unchecked(p + Offset); } } #endregion #region 泛型 // !!! C#不支持将整数类型作为泛型约束 !!! //public abstract class GenPointerCall<T> : IPointerCall where T: int, long //{ // public abstract unsafe byte* Ptr(byte* p); // void d() // { // } //} #endregion #region 全部测试 /// <summary> /// 指针操作的一些常用函数 /// </summary> public static class PointerCallTool { private const int CountLoop = 200000000; // 循环次数 /// <summary> /// 调用指针操作 /// </summary> /// <typeparam name="T">具有IPointerCall接口的类型。</typeparam> /// <param name="ptrcall">调用者</param> /// <param name="p">源指针</param> /// <returns>修改后指针</returns> public static unsafe byte* CallPtr<T>(T ptrcall, byte* p) where T : IPointerCall { return ptrcall.Ptr(p); } public static unsafe byte* CallClassPtr<T>(T ptrcall, byte* p) where T : PointerCall { return ptrcall.Ptr(p); } public static unsafe byte* CallRefPtr<T>(ref T ptrcall, byte* p) where T : IPointerCall { return ptrcall.Ptr(p); } // C#不允许将特定的结构体作为泛型约束。所以对于结构体只能采用上面那个方法，通过IPointerCall接口进行约束，可能会造成性能下降。 //public static unsafe byte* SCallPtr<T>(T ptrcall, byte* p) where T : SPointerCallAdd //{ // return ptrcall.Ptr(p); //} private static int TryIt_Static_Offset; private static unsafe byte* TryIt_Static_Ptr(byte* p) { return unchecked(p + TryIt_Static_Offset); } /// <summary> /// 执行测试 - 静态调用 /// </summary> /// <param name="sOut">文本输出</param> private static unsafe void TryIt_Static(StringBuilder sOut) { TryIt_Static_Offset = 1; // == 性能测试 == byte* p = null; Stopwatch sw = new Stopwatch(); int i; unchecked { #region 测试 // 硬编码 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = p + TryIt_Static_Offset; } sw.Stop(); sOut.AppendLine(string.Format("硬编码:\t{0}", sw.ElapsedMilliseconds)); // 静态调用 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = TryIt_Static_Ptr(p); } sw.Stop(); sOut.AppendLine(string.Format("静态调用:\t{0}", sw.ElapsedMilliseconds)); #endregion // 测试 } } /// <summary> /// 执行测试 - 非泛型 /// </summary> /// <param name="sOut">文本输出</param> private static unsafe void TryIt_NoGen(StringBuilder sOut) { // 创建 PointerCallAdd pca = new PointerCallAdd(); SPointerCallAdd spca; pca.Offset = 1; spca.Offset = 1; // 转型 PointerCall pca_base = pca; IPointerCall pca_itf = pca; IPointerCall spca_itf = spca; // == 性能测试 == byte* p = null; Stopwatch sw = new Stopwatch(); int i; unchecked { #region 调用 #region 直接调用 // 调用派生类 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = pca.Ptr(p); } sw.Stop(); sOut.AppendLine(string.Format("调用派生类:\t{0}", sw.ElapsedMilliseconds)); // 调用结构体 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = spca.Ptr(p); } sw.Stop(); sOut.AppendLine(string.Format("调用结构体:\t{0}", sw.ElapsedMilliseconds)); #endregion // 直接调用 #region 间接调用 // 调用基类 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = pca_base.Ptr(p); } sw.Stop(); sOut.AppendLine(string.Format("调用基类:\t{0}", sw.ElapsedMilliseconds)); // 调用派生类的接口 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = pca_itf.Ptr(p); } sw.Stop(); sOut.AppendLine(string.Format("调用派生类的接口:\t{0}", sw.ElapsedMilliseconds)); // 调用结构体的接口 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = spca_itf.Ptr(p); } sw.Stop(); sOut.AppendLine(string.Format("调用结构体的接口:\t{0}", sw.ElapsedMilliseconds)); #endregion // 间接调用 #endregion // 调用 #region 泛型调用 #region 泛型基类约束 // 基类泛型调用派生类 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallClassPtr(pca, p); } sw.Stop(); sOut.AppendLine(string.Format("基类泛型调用派生类:\t{0}", sw.ElapsedMilliseconds)); // 基类泛型调用基类 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallClassPtr(pca_base, p); } sw.Stop(); sOut.AppendLine(string.Format("基类泛型调用基类:\t{0}", sw.ElapsedMilliseconds)); #endregion // 泛型基类约束 #region 泛型接口约束 - 直接调用 // 接口泛型调用派生类 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallPtr(pca, p); } sw.Stop(); sOut.AppendLine(string.Format("接口泛型调用派生类:\t{0}", sw.ElapsedMilliseconds)); // 接口泛型调用结构体 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallPtr(spca, p); } sw.Stop(); sOut.AppendLine(string.Format("接口泛型调用结构体:\t{0}", sw.ElapsedMilliseconds)); // 接口泛型调用结构体引用 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallRefPtr(ref spca, p); } sw.Stop(); sOut.AppendLine(string.Format("接口泛型调用结构体引用:\t{0}", sw.ElapsedMilliseconds)); #endregion // 直接调用 #region 间接调用 // 接口泛型调用基类 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallPtr(pca_base, p); } sw.Stop(); sOut.AppendLine(string.Format("接口泛型调用基类:\t{0}", sw.ElapsedMilliseconds)); // 接口泛型调用派生类的接口 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallPtr(pca_itf, p); } sw.Stop(); sOut.AppendLine(string.Format("接口泛型调用派生类的接口:\t{0}", sw.ElapsedMilliseconds)); // 接口泛型调用结构体的接口 sw.Reset(); sw.Start(); for (i = 0; i < CountLoop; ++i) { p = CallPtr(spca_itf, p); } sw.Stop(); sOut.AppendLine(string.Format("接口泛型调用结构体的接口:\t{0}", sw.ElapsedMilliseconds)); #endregion // 间接调用 #endregion // 泛型调用 } } /// <summary> /// 执行测试 - 泛型 /// </summary> /// <param name="sOut">文本输出</param> private static unsafe void TryIt_Gen(StringBuilder sOut) { // !!! C#不支持将整数类型作为泛型约束 !!! } /// <summary> /// 执行测试 /// </summary> public static string TryIt() { StringBuilder sOut = new StringBuilder(); sOut.AppendLine("== PointerCallTool.TryIt() =="); TryIt_Static(sOut); TryIt_NoGen(sOut); TryIt_Gen(sOut); sOut.AppendLine(); return sOut.ToString(); } } #endregion }

编译器——
VS2005：Visual Studio 2005 SP1。
VS2010：Visual Studio 2010 SP1。
采用上述编译器编译为Release版程序，最大速度优化。

机器A——
HP CQ42-153TX
处理器：Intel Core i5-430M(2.26GHz, Turbo 2.53GHz, 3MB L3)
内存容量：2GB (DDR3-1066)

机器B——
DELL Latitude E6320
处理器：Intel i3-2310M(2.1GHz, 3MB L3)
内存容量：4GB (DDR3-1333，双通道)

测试环境——
A_2005：机器A，VS2005，Window 7 32位。
A_2010：机器A，VS2010，Window 7 32位。
B_2005：机器B，VS2005，Window 7 64位（x64）。
B_2010：机器B，VS2010，Window 7 64位（x64）。
B_2010xp：机器B，VS2010，Window XP SP3 32位。

测试结果（单位：毫秒）——

模式	A_2005	A_2010	B_2005	B_2010	B_2010xp
硬编码	163	162	23	24	95
静态调用	162	161	23	23	95
调用派生类	570	487	456	487	606
调用结构体	162	160	95	620	100
调用基类	565	571	453	513	874
调用派生类的接口	810	728	779	708	929
调用结构体的接口	1052	1055	1175	1175	1267
基类泛型调用派生类	975	568	1055	1148	671
基类泛型调用基类	984	569	1055	1152	671
接口泛型调用派生类	1383	729	1346	1531	1062
接口泛型调用结构体	566	162	767	1149	107
接口泛型调用结构体引用	487	164	752	816	100
接口泛型调用基类	1378	812	1337	1535	1072
接口泛型调用派生类的接口	1376	810	1338	1533	1102
接口泛型调用结构体的接口	1542	1133	2486	2013	1365

结果分析——
先看第1列数据（A_2005），发现“静态调用”、“调用结构体”与“硬编码”的时间几乎一致，很可能做了函数展开优化。其次最快的是“接口泛型调用结构体引用”，比“接口泛型调用结构体”快了16%。但是“接口泛型调用结构体的接口”最慢，“调用结构体的接口”也比较慢。其他的基于类的调用模式的速度排在中间。而且发现泛型方法速度较慢。
然后看第2列数据（A_2010），发现“接口泛型调用结构体”、“接口泛型调用结构体引用”也与“硬编码”的时间几乎一致，表示它们也是做了函数展开优化的，看来在VS2010中不需要使用ref优化结构体参数。“调用结构体的接口”、“接口泛型调用结构体的接口”两个都成了垫底。泛型方法的速度有了很大的提高，几乎与非泛型调用速度相当。
再看第3列数据（B_2005），并与第1列（A_2005）进行比较，发现“静态调用”与“硬编码”的时间几乎一致，而“调用结构体”要慢一些。“接口泛型调用结构体”、“接口泛型调用结构体引用”比较慢，排在了“调用基类”、“调用派生类”的后面。可能是64位环境（x64）的特点吧。
再看第4列数据（B_2010），并与第3列（B_2005）进行比较，发现大部分变慢了，尤其是结构体相关的，难道VS2010的x64性能还不如VS2005？我将平台改为“x64”又编译了一次，结果依旧。
再看第5列数据（B_2010xp），发现32位WinXP下的大部分项目比64位Win7下要快，真诡异。而且发现“静态调用”、“调用结构体”与“硬编码”的时间几乎一致，看来“调用结构体”一直是被函数展开优化的，而64位下的静态调用有着更深层次的优化，所以比不过。

我觉得在要求性能的情况下，使用结构体封装指针操作比较好，因为直接调用时会做函数展开优化，大多数情况下与硬编码的性能一致。在遇到需要一些灵活功能时，可考虑采用“接口泛型调用结构体引用”的方式，速度有所下降。接口方式最慢，尽可能不用。一定要用接口的话，应优先选择非泛型版。

（完）

测试程序exe——
http://115.com/file/dn6hvcm3

http://download.youkuaiyun.com/detail/zyl910/3614511

源代码下载——
http://115.com/file/aqz70zy3

http://download.youkuaiyun.com/detail/zyl910/3614514