.empty

[cj]

What is string.empty used for?

I can't say: if string.empty then
I have to use: if string = "" then

which is ok, I just want to know what .empty is for.

[Cor Ligthert [MVP]]

CJ,

There are endless methods to tell that a string exist however does not
contain any character.

One of those is string.empy another one string="" and string=nothing
although that initializes.

In this newsgroup is once taken the string="" for the string without any
character.

However I would not botter to much. The only dangerous one can be the
string=nothing, because that test as well on a string that was in advance no
string (Is Nothing)

I hope this helps,

Cor

"cj" <[e-mail] am> schreef in bericht
news:uM******** ******@TK2MSFTN GP05.phx.gbl...

What is string.empty used for?

I can't say: if string.empty then
I have to use: if string = "" then

which is ok, I just want to know what .empty is for.

[Herfried K. Wagner [MVP]]

"cj" <[e-mail] am> schrieb:

What is string.empty used for?

I can't say: if string.empty then
I have to use: if string = "" then

which is ok, I just want to know what .empty is for.

\\\
If x = String.Empty Then
...
End If
///

is semantically equivalent to

\\\
If x = "" Then
...
End If
///

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://classicvb.org/petition/>

[Clive Dixon]

Use String.Empty to initialise strings to zero-length.

Dim s As String
s = String.Empty

To check whether a string is zero length, check the Length property.

If s.Length = 0 Then
'...
End If

http://www.gotdotnet.com/team/fxcop/...ingLength.html
--
=============== =======
Clive Dixon
Digita Ltd. (www.digita.com)
"cj" <[e-mail] am> wrote in message
news:uM******** ******@TK2MSFTN GP05.phx.gbl...

What is string.empty used for?

I can't say: if string.empty then
I have to use: if string = "" then

which is ok, I just want to know what .empty is for.

[Mitchell S. Honnert]

To add on what Herfried and Cor have already said, I prefer the use of
String.Empty to "". Yes, they're syntactically correct, but the few extra
keystrokes are worth the added clarity. Is there a space in there that I
can't see becuase of the IDE's font setting? Is one of the double quotes
really two single quotes? Better to avoid the potential for confusion and
just use String.Empty.

- Mitchell S. Honnert
"cj" <[e-mail] am> wrote in message
news:uM******** ******@TK2MSFTN GP05.phx.gbl...

What is string.empty used for?

I can't say: if string.empty then
I have to use: if string = "" then

which is ok, I just want to know what .empty is for.

[cj]

Well, I see I typed my question a bit off again. When I posted
if string.empty

I meant it to be interpreted
if mystring.empty

which I assumed would return a True or False and it doesn't.
I didn't expect for anyone to think I meant using it like
if mystring = string.empty

But ok, I see what .empty is all about now. And I don't like it.
mystring = "" has been around for ages now an is obvious beyond any
doubt to me so I surely don't think saying mystring = string.empty is
any better. Heck I was confusing in my post. But then that's just my
opinion. :)

Thanks to everyone for explaining .empty to me!
Mitchell S. Honnert wrote:

To add on what Herfried and Cor have already said, I prefer the use of
String.Empty to "". Yes, they're syntactically correct, but the few extra
keystrokes are worth the added clarity. Is there a space in there that I
can't see becuase of the IDE's font setting? Is one of the double quotes
really two single quotes? Better to avoid the potential for confusion and
just use String.Empty.

- Mitchell S. Honnert
"cj" <[e-mail] am> wrote in message
news:uM******** ******@TK2MSFTN GP05.phx.gbl...

What is string.empty used for?

I can't say: if string.empty then
I have to use: if string = "" then

which is ok, I just want to know what .empty is for.

[Herfried K. Wagner [MVP]]

"cj" <[e-mail] am> schrieb:

Well, I see I typed my question a bit off again. When I posted
if string.empty

I meant it to be interpreted
if mystring.empty

which I assumed would return a True or False and it doesn't.
I didn't expect for anyone to think I meant using it like
if mystring = string.empty
That's because 'String.Empty' is shared.
But ok, I see what .empty is all about now. And I don't like it.
Dito.
mystring = "" has been around for ages now an is obvious beyond any doubt
to me so I surely don't think saying mystring = string.empty is any
better.

Full ACK. I wonder why the VB compiler doesn't emit 'String.Empty' for
empty-string literals.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://classicvb.org/petition/>

[Phill W.]

Herfried K. Wagner [MVP] wrote:

"cj" <[e-mail] am> schrieb:

.. . .

mystring = "" has been around for ages now an is obvious beyond any
doubt to me so I surely don't think saying mystring = string.empty is
any better.

Full ACK. I wonder why the VB compiler doesn't emit 'String.Empty' for
empty-string literals.

Wouldn't that be nice - from the little I understand of I.L.Code, the
compiler does come up with something a bit different in each case (not
surprisingly).

Given ...

If s1 = String.Empty Then

.... the ILCode produced looks like:

IL_0001: ldloc.0
IL_0002: ldsfld string [mscorlib]System.String:: Empty
IL_0007: ldc.i4.0
IL_0008: call int32 [Microsoft.Visua lBasic]
....CompilerSer vices.StringTyp e::StrCmp( string, string, bool )

But if you use the "old-fashioned" ...

If s1 = "" Then

.... the compiler produces this instead:

IL_0001: ldloc.0
IL_0002: ldstr ""
IL_0007: ldc.i4.0
IL_0008: call int32 [Microsoft.Visua lBasic]
....CompilerSer vices.StringTyp e::StrCmp( string, string, bool )

So does it really matter?
Is "ldstr" so much slower than "ldsfld" that "String.Emp ty" really is
worth all the extra typing?

<advocate owner="devil" >
Is String.Empty really so much more readible than ""?

Regards,
Phill W.

[Herfried K. Wagner [MVP]]

"Phill W." <p-.-a-.-w-a-r-d@o-p-e-n-.-a-c-.-u-k> schrieb:

mystring = "" has been around for ages now an is obvious beyond any
doubt to me so I surely don't think saying mystring = string.empty is
any better.
Full ACK. I wonder why the VB compiler doesn't emit 'String.Empty' for
empty-string literals.

Wouldn't that be nice - from the little I understand of I.L.Code, the
compiler does come up with something a bit different in each case (not
surprisingly).

Given ...

If s1 = String.Empty Then

... the ILCode produced looks like:

IL_0001: ldloc.0
IL_0002: ldsfld string [mscorlib]System.String:: Empty
IL_0007: ldc.i4.0
IL_0008: call int32 [Microsoft.Visua lBasic]
...CompilerServ ices.StringType ::StrCmp( string, string, bool )

But if you use the "old-fashioned" ...

If s1 = "" Then

... the compiler produces this instead:

IL_0001: ldloc.0
IL_0002: ldstr ""
IL_0007: ldc.i4.0
IL_0008: call int32 [Microsoft.Visua lBasic]
...CompilerServ ices.StringType ::StrCmp( string, string, bool )

So does it really matter?

IMO no.
Is "ldstr" so much slower than "ldsfld" that "String.Emp ty" really is
worth all the extra typing?
IMO no.
<advocate owner="devil" >
Is String.Empty really so much more readible than ""?

IMO no.

However, it's true that the 'ldsfld' instruction is slightly faster than the
'ldstr' instruction. I don't see any reason for the VB compiler not to emit
'ldsfld' + 'String.Empty' instead of 'ldstr' for "", as both are
semantically equivalent and thus no problem could arise.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://classicvb.org/petition/>

[Mitchell S. Honnert]

>Is String.Empty really so much more readible than ""?
More readable enough that it's worth the few extra keystrokes, yes. I
personally don't get the near obsession some programmers have with saving a
few keystrokes. As a percentage of all overall development, the time it
takes to actually type the code is small. Besides, in most cases, you write
the code once, but it's read dozens of time. So, even if you take three
extra seconds to type a more explicit reference (be it String.Empty or
anything else), you more than make up for the "investment " of the single
write during the multiple reads.

Is this a big deal? Not really. I happen to prefer String.Empty to ""
because I believe the former to be a bit more clear and that's enough for
me. What I find interesting, though, is that this discussion seems to
paralel in a way the arguments of C# vs. VB.NET. C# people love that fact
that they save a few keystrokes with their cryptic language. I prefer to
type a bit extra and have my code more easilly understood by more people.
Sure, if you know C#, then you know what weird combination of punctuation
marks you have to create to get the functionality you need, but is this
in-built obfuscation really worth the relatively small savings in
keystrokes? I prefer VB.NET, so obviously I don't think so. To me, it's
like driving ten miles out of your way to save a penny per gallon on gas.

I'm not trying to start another C# vs. VB.NET holy flame war here. It's just
that the principle of "" vs String.Empty reminded me of some of the same
points, albeit on a much smaller scale.

- Mitchell S. Honnert

"Phill W." <p-.-a-.-w-a-r-d@o-p-e-n-.-a-c-.-u-k> wrote in message
news:e2******** **@yarrow.open. ac.uk...

Herfried K. Wagner [MVP] wrote:

"cj" <[e-mail] am> schrieb:

. . .

mystring = "" has been around for ages now an is obvious beyond any
doubt to me so I surely don't think saying mystring = string.empty is
any better.

Full ACK. I wonder why the VB compiler doesn't emit 'String.Empty' for
empty-string literals.

Wouldn't that be nice - from the little I understand of I.L.Code, the
compiler does come up with something a bit different in each case (not
surprisingly).

Given ...

If s1 = String.Empty Then

... the ILCode produced looks like:

IL_0001: ldloc.0
IL_0002: ldsfld string [mscorlib]System.String:: Empty
IL_0007: ldc.i4.0
IL_0008: call int32 [Microsoft.Visua lBasic]
...CompilerServ ices.StringType ::StrCmp( string, string, bool )

But if you use the "old-fashioned" ...

If s1 = "" Then

... the compiler produces this instead:

IL_0001: ldloc.0
IL_0002: ldstr ""
IL_0007: ldc.i4.0
IL_0008: call int32 [Microsoft.Visua lBasic]
...CompilerServ ices.StringType ::StrCmp( string, string, bool )

So does it really matter?
Is "ldstr" so much slower than "ldsfld" that "String.Emp ty" really is
worth all the extra typing?

<advocate owner="devil" >
Is String.Empty really so much more readible than ""?

Regards,
Phill W.