Shall I now always use String.Empty instead of ""

[anonieko]

In the past I always used "" everywhere for empty string in my code
without a problem.

Now, do you think I should use String.Empty instead of "" (at all
times) ?

Let me know your thoughts.

[Leon Mayne]

"an******@hotma il.com" wrote:

In the past I always used "" everywhere for empty string in my code
without a problem.

Now, do you think I should use String.Empty instead of "" (at all
times) ?

If you're checking for an empty string it's better to use:
String.IsNullOr Empty(strString Name)
As of .NET 2.0

[Morten Wennevik]

Hi,

There is very little difference between the two.

"" is easy to write, easy to read, and near impossible to misunderstand.
It will however create an object where String.Empty would not, but the ""
object is reused throughout the lifespawn of your application so the
difference can therefore be ignored.

Neither will detect a null string so if you can have null strings you need
to either check for that as well or use String.IsNullEr Emtpy as Leon
pointed out.

if(str == null || str == "") // or
if(String.IsNul lOrEmpty(str))

If, on the other hand, you know you will never get null strings, testing
for String.Length == 0 is the fastest way.

On Thu, 23 Nov 2006 10:57:06 +0100, <an******@hotma il.comwrote:

In the past I always used "" everywhere for empty string in my code
without a problem.

Now, do you think I should use String.Empty instead of "" (at all
times) ?

Let me know your thoughts.

--
Happy Coding!
Morten Wennevik [C# MVP]

[Jon Skeet [C# MVP]]

<an******@hotma il.comwrote:

In the past I always used "" everywhere for empty string in my code
without a problem.

Now, do you think I should use String.Empty instead of "" (at all
times) ?

Which do you find easier to read? That's pretty much the only
difference of any significance, IMO.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Jon Shemitz]

Morten Wennevik wrote:

"" is easy to write, easy to read, and near impossible to misunderstand.
It will however create an object where String.Empty would not, but the ""
object is reused throughout the lifespawn of your application so the
difference can therefore be ignored.

I was surprised to read that "" will create an object where
String.Empty will not - surely String.Empty is just a static field
that points to an interned "" constant?

Sure enough, Reflector shows that String.Empty is implemented as

class string
{
static readonly string Empty = "";
}

.... yet the below code shows that while both "" and String.Empty are
interned, "" is not reference-equal to String.Empty. What gives? I
thought the intern table was maintained across assembly boundaries, so
it shouldn't matter that String.Empty comes from mscorlib.dll while ""
comes from the app assembly.

//

using System;

namespace StringEmptyTest
{
class Program
{
static void Main(string[] args)
{
Console.WriteLi ne(Object.Refer enceEquals(Stri ng.Empty, ""));
Console.WriteLi ne(String.IsInt erned("") != null);
Console.WriteLi ne(String.IsInt erned(String.Em pty) != null);
Console.ReadLin e();
}
}
}
--

..NET 2.0 for Delphi Programmers
www.midnightbeach.com/.net
What you need to know.

[Gabriel Lozano-Morán]

And what happens if string interning is disabled? Doesn't this mean that
each time you have a "" in your code that you will have the overhead of
allocating memory on the heap and creating a new string object?

Gabriel

"Jon Skeet [C# MVP]" <sk***@pobox.co mwrote in message
news:MP******** *************** *@msnews.micros oft.com...

<an******@hotma il.comwrote:

>In the past I always used "" everywhere for empty string in my code
without a problem.

Now, do you think I should use String.Empty instead of "" (at all
times) ?

Which do you find easier to read? That's pretty much the only
difference of any significance, IMO.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Jon Skeet [C# MVP]]

Gabriel Lozano-Morán <ab***@frontbri dge.comwrote:

And what happens if string interning is disabled? Doesn't this mean that
each time you have a "" in your code that you will have the overhead of
allocating memory on the heap and creating a new string object?

String interning isn't something you can enable or disable, as far as
I'm aware - and at that point, the C# language specification is being
violated. I don't alter my programming style in order to suit
situations like that - it's like changing your style to suit a
situation where garbage collection doesn't occur.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Gabriel Lozano-Morán]

See:
http://msdn2.microsoft.com/en-us/lib...attribute.aspx
http://msdn2.microsoft.com/en-us/lib...laxations.aspx

Gabriel Lozano-Morán
"Jon Skeet [C# MVP]" <sk***@pobox.co mwrote in message
news:MP******** *************** *@msnews.micros oft.com...
Gabriel Lozano-Morán <ab***@frontbri dge.comwrote:

And what happens if string interning is disabled? Doesn't this mean that
each time you have a "" in your code that you will have the overhead of
allocating memory on the heap and creating a new string object?

String interning isn't something you can enable or disable, as far as
I'm aware - and at that point, the C# language specification is being
violated. I don't alter my programming style in order to suit
situations like that - it's like changing your style to suit a
situation where garbage collection doesn't occur.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Chris Mullins]

"Jon Skeet [C# MVP]" <sk***@pobox.co mwrote

And what happens if string interning is disabled?

String interning isn't something you can enable or disable, as far as
I'm aware - and at that point, the C# language specification is being
violated.

You can't disable it. At least not that I was able to find, and I looked for
quite a while.

I wrote up a blog entry on my findings with string interning and when /
where it can save memory (at least in the case i'm worried about):
http://www.coversant.com/dotnetnuke/...=88&EntryID=24

--
Chris Mullins, MCSD.NET, MCPD:Enterprise
http://www.coversant.net/blogs/cmullins

[Jon Skeet [C# MVP]]

Gabriel Lozano-Morán <ab***@frontbri dge.comwrote:

See:
http://msdn2.microsoft.com/en-us/lib....compilerservi
ces.compilation relaxationsattr ibute.aspx

How bizarre. Using that would certainly mean you were no longer using a
language which conformed to the C# language spec. However, you would
have to *explicitly* use that attribute, so again I can't see that it's
actually a consideration to think about in normal coding.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too