.text == "" vs .length==0

[j_ruez]

I am trying to learn the best ways to do some things in c#

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

and why would I use one over the other. And if it doesn't matter,
just let me know that also.

Thanks

[Tobin Harris]

"j_ruez" <j_****@yahoo.c om> wrote in message
news:17******** *************** ***@posting.goo gle.com...

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

A more descriptive, and potentially platform-safe way could be this:

txtValue.Text == string.Empty

However, bear in mind that strings can also be null, so you may want to
check this also!

Tobin

[Nicholas Paldino [.NET/C# MVP]]

j_ruez,

I personally would use the following when working with strings in
general:

if (pstrString == null || pstrString.Leng th == 0)
// Perform operation here.

The reason for this is that you are not guaranteed to always hold a
reference to the string. Now your logic for what to do with a null
reference might be different than others, but you should take it into
consideration.

Also, the TextBox class might always return an empty string, in which
case, I would just check the length (it should be quicker than checking
against the empty string, which you should use "String.Emp ty" for as well).

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- nick(dot)paldin o=at=exisconsul ting<dot>com

"j_ruez" <j_****@yahoo.c om> wrote in message
news:17******** *************** ***@posting.goo gle.com...

I am trying to learn the best ways to do some things in c#

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

and why would I use one over the other. And if it doesn't matter,
just let me know that also.

Thanks

[Mickey Williams]

The most performant way is to check for Length == 0.

--
Mickey Williams
Author, "Microsoft Visual C# .NET Core Reference", MS Press
www.servergeek.com
"Tobin Harris" <co**********@h otmail.com> wrote in message
news:bl******** ****@ID-135366.news.uni-berlin.de...

"j_ruez" <j_****@yahoo.c om> wrote in message
news:17******** *************** ***@posting.goo gle.com...

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

A more descriptive, and potentially platform-safe way could be this:

txtValue.Text == string.Empty

However, bear in mind that strings can also be null, so you may want to
check this also!

Tobin

[Jon Skeet]

Tobin Harris <co**********@h otmail.com> wrote:

A more descriptive, and potentially platform-safe way could be this:

txtValue.Text == string.Empty
I don't see how it would ever be more platform-safe. As for descriptive
- I think on this one it's a matter of preference. I'd probably use
=="" myself, but that's not to say that using String.Empty isn't just
as good.
However, bear in mind that strings can also be null, so you may want to
check this also!

That's very true.

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

[Chris R. Timmons]

j_****@yahoo.co m (j_ruez) wrote in
news:17******** *************** ***@posting.goo gle.com:

I am trying to learn the best ways to do some things in c#

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

and why would I use one over the other. And if it doesn't matter,
just let me know that also.

Both ways are OK. To build on Tobin's answer, you can use a small
utility method to make testing for an empty or null string easier:

public sealed class StringUtilities
{
public static bool IsStringEmpty(
string s)
{
return (s == null) || (s.Length == 0);
}
}

You may also consider a string that contains only whitespace to be
"empty". In that case, the Trim() method can be used to strip
leading and trailing whitespace from the string before the Length
test is done:

public sealed class StringUtilities
{
public static bool IsStringEmpty(
string s)
{
return (s == null) || (s.Trim().Lengt h == 0);
}
}
Hope this helps.

Chris.
-------------
C.R. Timmons Consulting, Inc.
http://www.crtimmonsinc.com/

[Jeff]

Although I haven't verified this, my assumption would be that if you used
the - txtValue.Text == "" method to test if a string was empty, then an
extra string object would have to be created at run-time (for the "").
Although this probably isn't that big of an issue, I suppose it could be if
it were implemented within a large loop.

Using the - txtValue.Length == 0 way shouldn't have to create the extra
string object.

Just my $0.02 worth.

--- Jeff

"j_ruez" <j_****@yahoo.c om> wrote in message
news:17******** *************** ***@posting.goo gle.com...

I am trying to learn the best ways to do some things in c#

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

and why would I use one over the other. And if it doesn't matter,
just let me know that also.

Thanks

[Jon Skeet]

Jeff <je**@nowhere.c om> wrote:

Although I haven't verified this, my assumption would be that if you used
the - txtValue.Text == "" method to test if a string was empty, then an
extra string object would have to be created at run-time (for the "").

No. String literals are interned when classes are loaded. In other
words, "" is a reference to the same string wherever it's used.

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

[Jeff]

Jon,

Thanks for the clarification.

--- Jeff

"Jon Skeet" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

Jeff <je**@nowhere.c om> wrote:

Although I haven't verified this, my assumption would be that if you used the - txtValue.Text == "" method to test if a string was empty, then an
extra string object would have to be created at run-time (for the "").

No. String literals are interned when classes are loaded. In other
words, "" is a reference to the same string wherever it's used.

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

[mikeb]

j_ruez wrote:

I am trying to learn the best ways to do some things in c#

When testing for an empty string, what is the best way to test it.
For example, if I have a textbox named txtValue

Should I use

txtValue.Text == ""

or

txtValue.Length == 0

and why would I use one over the other. And if it doesn't matter,
just let me know that also.

Thanks

Let's look at the IL:

(txtValue.Text == "") boils down to a call to String.op_Equal ity(),
which in turn calls String.Equals( string, string). This checks for
reference equality and does some checks for null parameters before
calling String.Equals( string), which is implemented in native code, not
IL, and ILDASM won't tell me what's in there. I decided I didn't need to
go any further (farther?). I'll assume that the first thing
String.Equals does is check for the lengths being the same; actually it
probably checks for reference equality and/or a null parameter first.

(txtValue.Lengt h == 0) boils down to a call to
String.get_Leng th(), followed by a test for 0 (generally a 'brtrue' IL
instruction).

So, the second idiom is certainly more efficient in terms of IL - but,
we're looking at IL which may well be JIT'ed to some very efficient code
(in both cases), since the String class is sealed.

My opinion (for what it's worth) is to use whichever idiom seems most
readable to you, which may well be different in different areas of code.
I think the real-world speed difference will never be noticed (or even
measurable) in code that's doing any real work with strings.

Also, I'd suggest not using String.Empty (which I've seen in other
responses) - it buys you nothing, and I find it to be far less readable
than the simple, natural, well-used "".

--
mikeb