.NET Tips and Tricks

As we know we have two ways to set a variable value to an empty string.
We can just set it to empty quotes “” or set it to string.Empty, but what is the difference and is there one at all ?

If we will look at the .NET String.cs we will see the next line:

        public static readonly String Empty = "";

The above line can tell us that string.Empty is not a constant as we would like to believe but a readonly field.

The question is why, why static readonly and not a constant. The answer is in the same String.cs comments of the Empty field.

        // The Empty constant holds the empty string value.
        //We need to call the String constructor so that the compiler doesn't mark this as a literal.
        //Marking this as a literal would mean that it doesn't show up as a field which we can access
        //from native.

Now, let’s make some test.

            string EmptyValue = string.Empty;

            if (EmptyValue == "")
                // Output : Is Empty : 1
                Console.WriteLine("Is Empty : 1");

            if (EmptyValue.Length == 0)
                // Output : Is Empty : 2
                Console.WriteLine("Is Empty : 2");

            switch (EmptyValue)
            {
                case "":
                    {
                        // Output : Is Empty : 3
                        Console.WriteLine("Is Empty : 3");
                        break;
                    }
                 case string.Empty:
                    {
                        // Compilation error : A constant value is expected
                        Console.WriteLine("A constant value is expected");
                        break;
                    }
            }

            if (EmptyValue.Equals (""))
                // Output : Is Empty : 4
                Console.WriteLine("Is Empty : 4");

            if (string.IsNullOrEmpty(EmptyValue))
                // Output : Is Empty : 5
                Console.WriteLine("Is Empty : 5");

As we can see string.Empty and “” have the same behavior except the “switch” because string.Empty is not a constant.

And of course the most important question – is there a performance differences between the two ? The answer is – Yes, but minor.
Lets see some results :

           // Execution Time : 2144ms
            for (int n = 0; n < 100000000; n++)
            {
                if (TestValue == string.Empty)
                    t = 1; //"For test purposes only..."
            }

            // Execution Time : 2211ms
            for (int i = 0; i < 100000000; i++)
            {
                if (TestValue == "")
                    t = 2; //"For test purposes only..."
            }

We can see from the results that the comparison with string.Empty is a little bit faster but it's negligible.

One of the advantages of using "" is that it's in some cases it can be optimized by the compiler before the JIT. For example if you will run the same iteration while comparing ""==null the whole block will be removed by the optimizer.

So, use what ever you like, you'd probably won't see the difference.

A few posts you might find interesting:

1. C# Increment operator (++) question
2. C# Inheritance Question
3. C# The “double” trouble
4. Division by zero is simple, isn’t it ?
5. C# LINQ Teaser