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

￡神魔★判官ぃ 2022-06-18 04:40 151阅读 0赞

以前我一直有个疑惑——在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.     \} 
20. 
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.     \} 
61. 
62. \#endregion 
63. 
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.     //\} 
74. 
75. \#endregion 
76. 
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)); 
150. 
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)); 
199. 
200.                 \#endregion  // 直接调用 
201. 
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)); 
232. 
233.                 \#endregion  // 间接调用 
234. 
235.                 \#endregion  // 调用 
236. 
237.                 \#region 泛型调用 
238. 
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)); 
259. 
260.                 \#endregion // 泛型基类约束 
261. 
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)); 
292. 
293.                 \#endregion  // 直接调用 
294. 
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)); 
325. 
326.                 \#endregion  // 间接调用 
327. 
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位。

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

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

结果分析——  
先看第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_115.com_file_dn6hvcm3]

[http://download.csdn.net/detail/zyl910/3614511][http_download.csdn.net_detail_zyl910_3614511]

源代码下载——  
[http://115.com/file/aqz70zy3][http_115.com_file_aqz70zy3]

[http://download.csdn.net/detail/zyl910/3614514][http_download.csdn.net_detail_zyl910_3614514]

[http_115.com_file_dn6hvcm3]: http://115.com/file/dn6hvcm3
[http_download.csdn.net_detail_zyl910_3614511]: http://download.csdn.net/detail/zyl910/3614511
[http_115.com_file_aqz70zy3]: http://115.com/file/aqz70zy3
[http_download.csdn.net_detail_zyl910_3614514]: http://download.csdn.net/detail/zyl910/3614514