String.Empty or ""

  • Thread starter Thread starter shapper
  • Start date Start date
S

shapper

Hello,

On an ASP.NET MVC View I am using the following:

<%=Html.TextBox("Title", Model.Post.Title != null ? Model.Post.Title :
String.Empty)%>

In general is there a difference between using "" or String.Empty?

For example using:
String a = Model.Post.Title != null ? Model.Post.Title : String.Empty;

Or

String b = Model.Post.Title != null ? Model.Post.Title : "";

If there is no difference what is more correct to use?

Thanks,
Miguel
 
There is no practical difference.  String interning (a variation of string  
pooling) makes them basically the same.



If one could say that one was more correct than the other, then there  
would be a difference.  :p

Pete
Click to expand...

Thank You Pete.
Miguel
 
String.IsEmptyOrNull does it all in one operation.


There is no practical difference. String interning (a variation of string
pooling) makes them basically the same.



If one could say that one was more correct than the other, then there
would be a difference. :p

Pete
Click to expand...

Thank You Pete.
Miguel
 
shapper said:
For example using:
String a = Model.Post.Title != null ? Model.Post.Title : String.Empty;

Or

String b = Model.Post.Title != null ? Model.Post.Title : "";

If there is no difference what is more correct to use?
Click to expand...

There will be a difference the day the decide to make the
empty string something else than "".

:-)

The code does the same thing and I believe that String.Empty
is an absurdity that should never have been invented.

Arne
 
There is no functional difference. That being said, I prefer string.Empty,
as it is more clear what my intention is. You decide what is easiest for
you.

--
Gregory A. Beamer
MCP: +I, SE, SD, DBA

*********************************************
| Think outside the box!
|
*********************************************
 
Cowboy (Gregory A. Beamer) said:
There is no functional difference. That being said, I prefer string.Empty,
as it is more clear what my intention is. You decide what is easiest for
you.
Click to expand...
And I prefer more "", because I don't like functions which are longer to
type and do exactly the same behind the scene.

Those functions come in my ideas from the days that a string was not a value
type but a byte array and therefore more complex to test.

As "" is used nobody asks what it does, while with Empty you see already
here that people are thinking about it.

:-)

Cor
 
And I prefer more "", because I don't like functions which are longer to
type and do exactly the same behind the scene.

Those functions come in my ideas from the days that a string was not a value
type but a byte array and therefore more complex to test.
Click to expand...

String is not a value type. It has some behaviors that are similar - but, it
is still a reference type.
As "" is used nobody asks what it does, while with Empty you see already
here that people are thinking about it.
Click to expand...

I prefere string.Empty myself.
 
Tom said:
I prefere string.Empty myself.
Click to expand...

I also prefer String.Empty, since for example in code

dog = "";
cat = " ";
mouse = "";

the difference of cat to others is harder to notice.
 
shapper said:
Hello,

On an ASP.NET MVC View I am using the following:

<%=Html.TextBox("Title", Model.Post.Title != null ? Model.Post.Title :
String.Empty)%>

In general is there a difference between using "" or String.Empty?

For example using:
String a = Model.Post.Title != null ? Model.Post.Title : String.Empty;

Or

String b = Model.Post.Title != null ? Model.Post.Title : "";

If there is no difference what is more correct to use?

Thanks,
Miguel
Click to expand...

The only practical difference is that String.Empty already exists in the
mscorlib.dll, while the "" string will be added to your assembly.
However, if you use "" more than once in your code it will reuse the
same string, so there will never be more than one literal "" string in
your assembly. So the added data is absolutely nothing to be concerned
about.

There are however two reasons to use String.Empty rather than "" in your
code:

1. It's clearer that you actually mean an empty string and not just
started typing something and forgot to write anything in the string. If
you always use String.Empty for empty strings you can easily spot a
string that may be unintentionally left empty.

2. The difference between the empty string "" and strings like " " and
"'" is not very obvious. If you use String.Empty the difference is
really very obvious.
 
Arne said:
The code does the same thing and I believe that String.Empty
is an absurdity that should never have been invented.
Click to expand...

I guess it is the same reason why there are Decimal.Zero, Byte.MinValue,
Boolean.FalseString etc. And yes, I don't know the reason either.
 
Hello,

On an ASP.NET MVC View I am using the following:

<%=Html.TextBox("Title", Model.Post.Title != null ? Model.Post.Title :
String.Empty)%>

In general is there a difference between using "" or String.Empty?

For example using:
String a = Model.Post.Title != null ? Model.Post.Title : String.Empty;

Or

String b = Model.Post.Title != null ? Model.Post.Title : "";

If there is no difference what is more correct to use?

Thanks,
Miguel
Click to expand...

Better you use String.Empty rather than "", because while you typing
"" in case if you add extra space to this like " ", then you wont get
the expected results(Because String.Empty != " ").
I will give you an another example :
if (value == 1) or if (1 == value)
which one you prefer? (if (1 == value) right?) .
in first example : (if (value == 1)) if we forget one =, this will be
assignment stmnt.
In second example, if you do the same mistake, it will give the
compiler error.

So less chance to do mistake...

--Patel
 
Patel formulated the question :
I will give you an another example :
if (value == 1) or if (1 == value)
which one you prefer? (if (1 == value) right?) .
in first example : (if (value == 1)) if we forget one =, this will be
assignment stmnt.
In second example, if you do the same mistake, it will give the
compiler error.

So less chance to do mistake...

--Patel
Click to expand...

That is true in C/C++, because that doesn't have a 'bool' type.
The C# compiler catches that "if (value = 1)" with an error: "Cannot
implicitly convert type 'int' to 'bool'".

You could still get into problems with boolean variables:
if (boolVar = true) ..
(although you still get a compiler warning)
but that is better written as:
if (boolVar) ..

Hans Kesting
 
Arto said:
I guess it is the same reason why there are Decimal.Zero,
Byte.MinValue, Boolean.FalseString etc. And yes, I don't know the
reason either.
Click to expand...

Byte.MinValue is part of a pattern -- if you are given typeof(SomeType), you
can ask what its MinValue is and write code that handles both signed and
unsigned types. I'd guess this is very handy for the XML serializer (for
example).

Boolean.FalseString might change with locale.

String.Empty is useful because String is actually a reference type even
though its behavior is very similar to value type semantics. So
String.Empty is actually equal to String.Empty reference-wise as well as
value-wise. The same isn't true for empty strings created at runtime (e.g.
new StringBuilder().ToString()).
 
Hans said:
Patel formulated the question :

That is true in C/C++, because that doesn't have a 'bool' type.
Click to expand...

C++ has a bool type. But many things convert to bool implicitly.
The C# compiler catches that "if (value = 1)" with an error: "Cannot
implicitly convert type 'int' to 'bool'".

You could still get into problems with boolean variables:
if (boolVar = true) ..
(although you still get a compiler warning)
but that is better written as:
if (boolVar) ..
Click to expand...

But neither method helps with

if (boolA = boolB) ...

Good we have a warning then. And if you meant assignment you can say:

if (true == (boolA = boolB)) ...
 
Back
Top