CStr() vs. .ToString()

[Sean]

Book I am reading says that Cstr() is best method for efficency and safety
however it doesnt compare that method of the .ToString() method.

Which is best.

Thanks

[Herfried K. Wagner [MVP]]

"Scott M." <s-***@nospam.nosp am> schrieb:

both points of view are valid, however i use the vb string methods as the
compiler makes optimzations that can improve performance over the native
.Net
methods, also i find the vb methods read better.
The VB 6.0 way are not methods, they are functions. The .NET way are
object methods. The VB.NET compiler does NOT optimize the VB 6.0
functions to work BETTER than the natvie .NET object methods.

Does this really matter? The JIT compiler could inline the type conversion
functions.
To answer your question, ToString would be my suggestion, rather than
CStr(). ToString is a method of the Object Type, and since all classes
inherit from Object, all objects have this method.

'ToString' and 'CStr' serve different purposes. 'ToString' won't work on
'Nothing' references, which is a downside /if/ a 'Nothing' reference should
be converted to an empty string. That's exactly where 'CStr' can be used.

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

[Sean]

Thanks CMM, what you wrote is what I thought was true and I was looking for a
comfirmation.

As far as Scott goes I was refering to a "method" using the meaning of the
word "a way to". For my purposes it couldnt matter less if its a function or
a method.
"CMM" wrote:

I don't think that's true at all. First off, CStr,CBool, Etc. are all just
easier-to-read specialized wrappers around CType..... which in and of itself
is a special "VB" construct. The true "non-VB" casting operator is
DirectCast(...) .

Contrary to what Scott M says you're SUPPOSED to use them. What's the point
of using VB if you're not going to use its special methods that make your
life easier? This is straight from the VB documentation:

"As a rule, you should use the Visual Basic type conversion functions in
preference to the .NET Framework methods such as ToString(), either on the
Convert class or on an individual type structure or class. The Visual Basic
functions are designed for optimal interaction with Visual Basic code, and
they also make your source code shorter and easier to read. In addition, the
..NET Framework conversion methods do not always produce the same results as
the Visual Basic functions, for example when converting Boolean to Integer.
For more information, see Troubleshooting Data Types."

In addition, although I'm a guy who always initializes strings and objects
as soon as possible rather than have them sit around until my algorithm uses
them- so I don't really care about the following- but, there's an advantage
to using VB's functions: they interpret "Nothing." You can't use the OO
methods on a string that is "Nothing" (s.ToUpper for instance won't work).

--
-C. Moya
www.cmoya.com
"Scott M." <s-***@nospam.nosp am> wrote in message
news:O7******** ******@TK2MSFTN GP14.phx.gbl...

IMHO (and this has been debated for quite some time now), you should view
all of the old "data-type" specific functions as legacy functions and no
longer use them. Instead, use the more object-oriented methods of a type.

CStr, CBool, CDbl, CInt, etc. would all be replaced with CType or
.ToString
All date/time functions would be replaced with methods and properties of
the Date class
All string functions would be replaced with methods and properties of the
String class.

et all.
"Sean" <Se**@discussio ns.microsoft.co m> wrote in message
news:68******** *************** ***********@mic rosoft.com...

Book I am reading says that Cstr() is best method for efficency and
safety
however it doesnt compare that method of the .ToString() method.

Which is best.

Thanks

[Scott M.]

>> The VB 6.0 way are not methods, they are functions. The .NET way are

object methods. The VB.NET compiler does NOT optimize the VB 6.0
functions to work BETTER than the natvie .NET object methods.
Does this really matter? The JIT compiler could inline the type
conversion functions.

I was merely pointing out the inacurracy of the previous post. I'll leave
it up to the reader to determine if they care about the details.

To answer your question, ToString would be my suggestion, rather than
CStr(). ToString is a method of the Object Type, and since all classes
inherit from Object, all objects have this method.
'ToString' and 'CStr' serve different purposes. 'ToString' won't work on
'Nothing' references, which is a downside /if/ a 'Nothing' reference
should be converted to an empty string. That's exactly where 'CStr' can
be used.

As stated by others already, good programming practice would dictate that
data should be validated before being converted. So, I suppose I could say,
"Does it really matter since any good programmer would be checking for
nothing before converting the data?".

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

[Scott M.]

Same answer as when you asked the same question earilier in the thread.
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:%2******** ********@TK2MSF TNGP09.phx.gbl. ..

"Bob Lehmann" <no****@dontbot herme.zzz> schrieb:

You can't use the OO methods on a string that is "Nothing"

Why would you want to?

Oh, I get it, you're too lazy to check the data before performing an
operation it. Isn't checking your data a 100 level concept?

Why type 'If s IsNot Nothing AndAlso s.Length > 0 Then' if you could
shorten it to 'If Len(s) > 0 Then'? The same applies to 'ToString' vs.
'CStr': Why type

\\\
If o Is Nothing Then
s = ""
Else
s = o.ToString()
End If
///

if you could archieve the same by using

\\\
s = CStr(o)
///

?

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

[Scott M.]

Because CStr() wouldn't throw an exception if it encountered a Nothing
value, which could cause unexpected bugs in the application. ToString would
throw an exception and thus make it easier to determine the problem.
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:uY******** *****@TK2MSFTNG P15.phx.gbl...

"Bob Lehmann" <no****@dontbot herme.zzz> schrieb:

At least you have a sound rationale -
"Checking if a variable actually contains data before doing a convert to
upper case is simply too much code."

Waaaaa! But Mom, those extra 20 keystrokes to check the data are soooo
hard
to do. And besides, my code is better readable since you know I don't
indent
If blocks.

Well, why duplicate this checking code all over the source code if it is
possible to encapsulate it cleanly in high-level wrappers/functions like
'CStr'?

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

[Scott M.]

To add to this, you can't use DirectCast on anything but Reference Types
anyway, so CType will need to be used for all numeric casting anyway.
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:%2******** *******@tk2msft ngp13.phx.gbl.. .

"CMM" <cm*@nospam.com > schrieb:

I don't think that's true at all. First off, CStr,CBool, Etc. are all just
easier-to-read specialized wrappers around CType..... which in and of
itself is a special "VB" construct.

ACK. While it doesn't matter if you use 'C<Type>' or 'CType(...,
<Type>)', I strongly recommend to use them instead of 'Convert.To*'.

The true "non-VB" casting operator is DirectCast(...) .

... which doesn't mean that 'DirectCast' should not be used. Personally I
prefer 'CType' for value types (type conversions) and 'DirectCast' for
type casts (reference types). However, some other people prefer to use
'CType' instead of 'DirectCast'.

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

[Scott M.]

Then you should absolutely go with your preference, which is what I said in
the first place. I merely indicated what my preference was and why.

Good luck!
"Sean" <Se**@discussio ns.microsoft.co m> wrote in message
news:BD******** *************** ***********@mic rosoft.com...

Thanks CMM, what you wrote is what I thought was true and I was looking
for a
comfirmation.

As far as Scott goes I was refering to a "method" using the meaning of the
word "a way to". For my purposes it couldnt matter less if its a function
or
a method.
"CMM" wrote:

I don't think that's true at all. First off, CStr,CBool, Etc. are all
just
easier-to-read specialized wrappers around CType..... which in and of
itself
is a special "VB" construct. The true "non-VB" casting operator is
DirectCast(...) .

Contrary to what Scott M says you're SUPPOSED to use them. What's the
point
of using VB if you're not going to use its special methods that make your
life easier? This is straight from the VB documentation:

"As a rule, you should use the Visual Basic type conversion functions in
preference to the .NET Framework methods such as ToString(), either on
the
Convert class or on an individual type structure or class. The Visual
Basic
functions are designed for optimal interaction with Visual Basic code,
and
they also make your source code shorter and easier to read. In addition,
the
..NET Framework conversion methods do not always produce the same results
as
the Visual Basic functions, for example when converting Boolean to
Integer.
For more information, see Troubleshooting Data Types."

In addition, although I'm a guy who always initializes strings and
objects
as soon as possible rather than have them sit around until my algorithm
uses
them- so I don't really care about the following- but, there's an
advantage
to using VB's functions: they interpret "Nothing." You can't use the OO
methods on a string that is "Nothing" (s.ToUpper for instance won't
work).

--
-C. Moya
www.cmoya.com
"Scott M." <s-***@nospam.nosp am> wrote in message
news:O7******** ******@TK2MSFTN GP14.phx.gbl...

> IMHO (and this has been debated for quite some time now), you should
> view
> all of the old "data-type" specific functions as legacy functions and
> no
> longer use them. Instead, use the more object-oriented methods of a
> type.
>
> CStr, CBool, CDbl, CInt, etc. would all be replaced with CType or
> .ToString
> All date/time functions would be replaced with methods and properties
> of
> the Date class
> All string functions would be replaced with methods and properties of
> the
> String class.
>
> et all.
>
>
> "Sean" <Se**@discussio ns.microsoft.co m> wrote in message
> news:68******** *************** ***********@mic rosoft.com...
>> Book I am reading says that Cstr() is best method for efficency and
>> safety
>> however it doesnt compare that method of the .ToString() method.
>>
>> Which is best.
>>
>> Thanks
>>
>>
>
>

[Herfried K. Wagner [MVP]]

"Scott M." <s-***@nospam.nosp am> schrieb:

Because CStr() wouldn't throw an exception if it encountered a Nothing
value, which could cause unexpected bugs in the application. ToString
would throw an exception and thus make it easier to determine the problem.

Well, but there are cases where I'd call 'CStr' intentionally because I want
a 'Nothing' reference to be converted to an empty string!

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

[Scott M.]

I hear what you are saying, but as I said in the previous post, using CStr()
wouldn't allow you to discriminate between those Nothing values that you
intended to run across and Nothing values that inadvertantly may happen. As
others have said, a simple If statement that checks for the Nothing value
would allow you to get a Nothing value and convert it to an empty string
while still maintaining the integrety of the code.
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:uu******** *****@tk2msftng p13.phx.gbl...

"Scott M." <s-***@nospam.nosp am> schrieb:

Because CStr() wouldn't throw an exception if it encountered a Nothing
value, which could cause unexpected bugs in the application. ToString
would throw an exception and thus make it easier to determine the
problem.

Well, but there are cases where I'd call 'CStr' intentionally because I
want a 'Nothing' reference to be converted to an empty string!

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

[Herfried K. Wagner [MVP]]

"Scott M." <s-***@nospam.nosp am> schrieb:

I hear what you are saying, but as I said in the previous post, using
CStr() wouldn't allow you to discriminate between those Nothing values that
you intended to run across and Nothing values that inadvertantly may
happen. As others have said, a simple If statement that checks for the
Nothing value would allow you to get a Nothing value and convert it to an
empty string while still maintaining the integrety of the code.

'CStr' is different from 'ToString'. It's obvious that it doesn't behave
like 'ToString', and the additional behavior is publically well-known. So
using 'CStr' *iff* it makes sense does not break the integrity of the code.
It's the developer's fault if it breaks integrity.

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