Shulou(Shulou.com)06/02 Report--

This article is about how to implement performance testing of C# extension methods. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Three methods for testing the performance of C# extension method

A total of three methods are compared with string.IsNullOrEmpty (called "original method"):

/ / extended method public static bool IsNullOrEmpty1 (this string s) {return string.IsNullOrEmpty (s);} / manual method public static bool IsNullOrEmpty2 (string s) {return s = = null | | s = = string.Empty;} / / lambda method public static Func

IsNullOrEmpty3 = s = > string.IsNullOrEmpty (s)

We add a number after the function name to distinguish them from each other to avoid confusion.

In order to test fairly and eliminate the errors in the test as much as possible, we use an array to store the strings to be tested.

This array holds three types of strings, non-Empty, non-Null, Empty, and Null. Deposited randomly, the quantity is roughly the same. The generation algorithm is as follows:

Private static string [] GetTestStringArray (int count) {string [] result = new string [count]; Random random = new Random (); int r = 0; for (int I = 0; I < count; iTunes +) {r = random.Next (3); if (r = 0) result [I] = i.ToString (); else if (r = 1) result [I] = string.Empty Else result [I] = null;} return result

We have these four algorithms (the first three algorithms + the original static algorithm) judge each item in the array in turn.

One thing to pay special attention to is that traversing collections takes time, and we need to rule out this time.

The following is a test algorithm. If it is not well written, don't laugh:

Public static void Test () {int count = 100000000; / 7 zero string [] ss = GetTestStringArray (count); / / Test string Array bool b; string str; long t = 0; / / basic cycle time long t0 = 0; / / original method time long T1 = 0 / / extended method time long T2 = 0; / / Manual method time long T3 = 0; / / lambda time Stopwatch watch = new Stopwatch (); for (int I = 0; I < 10; iTunes +) / / cycle testing 10 times {watch.Reset (); watch.Start (); foreach (string s in ss) str = s; watch.Stop () Console.Write ("basic loop:" + watch.ElapsedMilliseconds + "ms\ t\ t\ t"); t + = watch.ElapsedMilliseconds; watch.Reset (); watch.Start (); foreach (string s in ss) {str = s; b = string.IsNullOrEmpty (str);} watch.Stop (); Console.Write ("original method:" + watch.ElapsedMilliseconds + "ms\ t") T0 + = watch.ElapsedMilliseconds; watch.Reset (); watch.Start (); foreach (string s in ss) {str = s; b = str.IsNullOrEmpty1 ();} watch.Stop (); Console.Write ("extension method:" + watch.ElapsedMilliseconds + "ms\ t"); T1 + = watch.ElapsedMilliseconds; watch.Reset (); watch.Start () Foreach (string s in ss) {str = s; b = IsNullOrEmpty2 (str);} watch.Stop (); Console.Write ("manual method:" + watch.ElapsedMilliseconds + "ms\ t\ t"); T2 + = watch.ElapsedMilliseconds; watch.Reset (); watch.Start (); foreach (string s in ss) {str = s; b = IsNullOrEmpty3 (str) } watch.Stop (); Console.Write ("lambda method:" + watch.ElapsedMilliseconds + "ms\ t\ t"); T3 + = watch.ElapsedMilliseconds; Console.WriteLine ();} Console.WriteLine (); Console.WriteLine ("extension method\ t / original method\ t = {0:f2}", (T1-t) * 1.0 / (t0-t) Console.WriteLine (string.Format ("manual method\ t / original method\ t = {0:f2}", (T2-t) * 1.0 / (t0-t); Console.WriteLine ("lambda method\ t / original method\ t = {0:f2}", (T3-t) * 1.0 / (t0-t));}

Want to restructure, consider several ways, not very good, afraid that people will look more laborious after refactoring.

The four snippets of code in Test are similar and are used to measure the time of each of the four algorithms.

1 foreach (string s in ss) str = s

The above code is a basic loop, and the next three sets of code all add corresponding actions to it.

Test () is not complicated, but it is so verbose that everyone can understand it.

First run the test in Debug mode:

The last three methods are too inefficient! Let's take a look at the Release mode:

It is a little more efficient than before. * the program generated in Release mode is executed on the command line:

Note 1: the output type of the project must be "console application" in order to output in the console.

Note 2: the width of the console is relatively small, I deleted several tabs in the output of Test (), and so on, so that its input does not wrap.

Explanation 3: this department executes the program generated by Release mode, not the program generated by Debug mode.

Debug and Release tests are carried out in the VS2008 host. * * console test is the real running environment. Our test results are based on the console test results.

The reason for posting the first two is to tell you that the results of debugging tests in vs are quite inaccurate.

Performance test results of C# extension method

Let's analyze the test results:

1. The efficiency of the extended method is quite high, with only a few percent of the performance loss compared with the original method (running several times more, it may be 1, 3, 4 or even 0, and once-2, that is, the ratio is 0.98).

two。 The efficiency of manual methods is too low to be expected by most people.

3.lambda can cause a "considerable" performance loss.

If you consider performance: you can use extension methods, but don't use lambda expressions inside extension methods, and try to use regular code inside them.

(in fact, it doesn't matter whether the internal code of the extension method is simple or not. after all, the extension method is a kind of encapsulation, which can hide the internal complex operations and provide it to the caller with a simple extension method.)

If you consider performance: use less lambda and more native methods.

Feeling: the result of this test surprised me. I really didn't expect the efficiency of the c # extension method to be so high (it seems that there is a market for my expansion idea)!

Expectation: I am a "rough man", very careless, if you find any errors in the above test, please let me know immediately, thank you!

Intention: the test of a c # extension method is not convincing enough, and some related testing work will be done in the future.

Emotion: the level of efficiency can not be determined by the eyes and the brain, but scientific testing methods must be used to give a conclusion.

Thank you for reading! This is the end of this article on "how to achieve performance testing of C# extension methods". I hope the above content can be of some help to you, so that you can learn more knowledge. If you think the article is good, you can share it out for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.