Brendan Tompkins [MVP]

From my tests comparing the string's length to 0 rather than comparing the string to String.Empty was about two times faster in debug mode, and about 16.8 times faster in release mode. I had to iterate 100,000,000 times for each one, so keep in mind that .00016 milliseconds isn't really that much slower than .00001 milliseconds.

The empty string literal was effectively the same speed as String.Empty; however, I would agree with the poster that String.Empty is cleaner since it evaluates properly when comparing against null. That said, I still prefer checking the length to 0. :)

By the way, when comparing the length to 0, I did check for null first.

Which one is easier to read?  

If it's a distraction to maintenance programmers, that's the real performance cost.

And more time has been spent typing on this blog than the entire aggregated duration of the differences in speed in every single instance that one these calls have ever been made;  in every program and every loop that has used them.  Ever.  Put together.

And you've still got the null check which makes the little difference look like a rounding error.

Use string.IsEmptyOrNull()  for checks.  It is VERY clear and safe.  

Everybody knows what "" means, and its a lot easier to type, but ... string.Empty is OK.

string.length is the fastest, but only under high iterations.

on my test machine results in ms for 10 million iterations (in milliseconds)

93,110,265,266,47

Here' the code if you want to try it out on your machine.

 {

           string test = "test";

           int j = 0;

           long test1time = 0;

           long test2time = 0;

           long test3time = 0;

           long test4time = 0;

           long test5time = 0;

           long starttime = Environment.TickCount;

           //Test 1 Equals string.Empty

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

           {

               if (test.Equals(string.Empty))

               {

                   j++;

               }

           }

           test1time = Environment.TickCount - starttime;

           //Test 2 Equals ""

           starttime = Environment.TickCount;

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

           {

               if (test.Equals(""))

               {

                   j++;

               }

           }

           test2time = Environment.TickCount - starttime;

           //Test 3 ""

           starttime = Environment.TickCount;

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

           {

               if (test == "")

               {

                   j++;

               }

           }

           test3time = Environment.TickCount - starttime;

           //Test 4 string.empty

           starttime = Environment.TickCount;

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

           {

               if (test == string.Empty)

               {

                   j++;

               }

           }

           test4time = Environment.TickCount - starttime;

           //Test 5 string.length

           starttime = Environment.TickCount;

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

           {

               if (test.Length == 0)

               {

                   j++;

               }

           }

           test5time = Environment.TickCount - starttime;

           //Sjow Results

           string msg = "Test run times (ms) -> Test1,Test2,Test3,Test4,Test5: " + test1time.ToString() + "," + test2time.ToString() + "," + test3time.ToString() + "," + test4time.ToString() + "," + test5time.ToString();

           MessageBox.Show(msg);

       }

My guess is that because strings are immutable each reference to "" will have a reference to an empty string in a heap. For the first time .NET runtime will allocate ""  string in a heap. Then theoretically GC will collect it and if you reference it again, runtime will have to create another empty string.

Using String.Empty shouldn't create problems with allocating empty string and Garbage Collection. It is also faster because it doesn't reference another string on a heap.

啊哈

"" always creates a new string. string.Empty is a static property on the string object. Using string.Empty avoids the overhead of creating a new string.

string.Empty不分配存储空间

I could give a fuck. Boring, stupid, doesnt matter.

Pingback from  Empty strings | Polymath Programmer

不知不觉何时起，开始倾向于在代码中使用String.Empty。今天决定来探究一下

I few things to Note

"" can have Hidden chars your IDE dosent display

I have seen myString == "" fail as the programer cut and pasted code.

The problem was that "".length = 1 so there was a char in the string that is not renderd in the IDE.

String.Empty is a fixed value

String.Empty is defined as

public static readonly string Empty = "";

and

string.Empty.length = 0;

so there are no Hidden chars

This is is One instance of a string common to all .Net lauguages

for comparason to empty and null string.IsNullOrEmpty(myString) is safeist

using reflector the method appers like this

public static bool IsNullOrEmpty(string value)

{

   if (value != null)

   {

       return (value.Length == 0);

   }

   return true;

}

My vote is use string.Empty and string.IsNullOrEmpty.

PS if you find string.Empty harded to understand than "" it is time to give up your day job :P

There is JIT optimization known bug for IsNullOrEmpty. Google on IsNullOrEmpty  and optimization. It is fixed in post Orcas.

connect.microsoft.com/.../ViewFeedback.aspx

I will go for String.Empty right now

Very good Idea. Thanks for an idea.

Thanks for good idea