Hmm, What happened to Left ?

[Jm]

Hi all

I feel stupid for asking this, but i just went to use the left() function
from vb6 only to find it doesnt do what it used to under .NET. Im assuming
theres something else now im meant to do when i want to say for example

Dim Str as string
Str = "1234"
msgbox left(str,2)

Thanks

[Herfried K. Wagner [MVP]]

"Sahil Malik" <co************ *****@nospam.co m> schrieb:

String.SubStrin g <--- That's what u got now !!

Why?! I am not a fan of weak semantics...

'Left' is still available in the 'Microsoft.Visu alBasic.Strings ' module and
is IMO the best choice.

To avoid a name clash with a form's 'Left' property, use 'Strings.Left' in
Windows Forms code.

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

[Herfried K. Wagner [MVP]]

"Jim" <no******@this. address> schrieb:

In fact you can still use Left by invoking explicitly

Microsoft.Visua lBasic.Left(str ing, length)

but this does seem a bit unneccesary now we have Substring.

Well, why not use pure assembler? 'Substring' is unnecessary too...

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

[Cor Ligthert]

Herfried,

The why is in my messages in this thread

As well as the why not by the way

:-)

Cor

[Jay B. Harlow [MVP - Outlook]]

Hefried,

Why?! I am not a fan of weak semantics... ?

How is String.SubStrin g "weak semantics"? To me it is very OO, you have a
string object & you want to get part of that string object.

See my other post on using Strings.Left.

Jay
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:uE******** ******@TK2MSFTN GP09.phx.gbl... "Sahil Malik" <co************ *****@nospam.co m> schrieb:

String.SubStrin g <--- That's what u got now !!

Why?! I am not a fan of weak semantics...

'Left' is still available in the 'Microsoft.Visu alBasic.Strings ' module
and is IMO the best choice.

To avoid a name clash with a form's 'Left' property, use 'Strings.Left' in
Windows Forms code.

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

[Jay B. Harlow [MVP - Outlook]]

Jm,
In addition to all the other comments.

A Form has a Left property so it hides the VB.Left function, what I normally
do is use an Import Alias in my form source files to allow use of the
function.

Imports VB = Microsoft.Visua lBasic

Public Class MainForm

...

Public Sub Test

Dim Str as string
Str = "1234"
msgbox VB.left(str,2)
End Class

A word of caution on String.SubStrin g (System.String methods) & Strings.Left
(Microsoft.Visu alBasic.Strings functions): System.String methods uses base 0
indexes while Microsoft.Visua lBasic.Strings uses base 1 indexes. I would
recommend you stay with either the System.String methods or the
Microsoft.Visua lBasic.Strings functions to avoid possible confusion & subtle
problems later...

Hope this helps
Jay

"Jm" <ja*****@ihug.c om.au> wrote in message
news:cr******** **@lust.ihug.co .nz... Hi all

I feel stupid for asking this, but i just went to use the left() function
from vb6 only to find it doesnt do what it used to under .NET. Im assuming
theres something else now im meant to do when i want to say for example

Dim Str as string
Str = "1234"
msgbox left(str,2)

Thanks

[Herfried K. Wagner [MVP]]

Jay,

"Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> schrieb:

Why?! I am not a fan of weak semantics...

?

How is String.SubStrin g "weak semantics"? To me it is very OO, you have a
string object & you want to get part of that string object.

'Left', 'Mid' and 'Right' make it more obvious which part of the string is
returned, and thus make code more readable. 'Substring' can be used to to
the same, but the user will have to analyze the values passed to it in order
to be able to determine if the left, right, or an arbitrary part (middle) of
the string is returned. In other words: The name 'Substring' only tells
the reader that a part of the string is returned, names like 'Left' and
'Right' provide more/additional information.

Notice that I was not discussing that 'Substring' is more OO than 'Left',
'Right', etc. OO is a good tool, but in some cases (like working with
strings or dealing with numbers) it IMO doesn't add much benefit.

Would

\\\
Dim d As Double = ...
Dim e As Double = d.Cos() * 2
///

really have benefits over

\\\
Dim d As Double
Dim e As Double = Math.Cos(d) * 2
///

only because it's more OO?

SCNR

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

[Jay B. Harlow [MVP - Outlook]]

Herfried,

'Left', 'Mid' and 'Right' make it more obvious which part of the string is
returned, and thus make code more readable. I agree it may be more obvious...

However! I'm just wondering about "weak semantics", to me saying it is "weak
semantics" is like insisting a glass is half full, when it is obvious it is
really half empty! Considering most of the time, it really doesn't matter if
I am getting the Left, Mid or Right of a string, I just want a part of the
string...

When you just want part of a string, any part of the string, SubString or
just Mid is sufficient. Left & Right can be implemented in terms of
SubString or Mid themselves...
the same, but the user will have to analyze the values passed to it in
order to be able to determine if the left, right, or an arbitrary part
(middle) of the string is returned. If one uses SubString enough is this really an issue? In other words, they
soon pick up on:
- x.SubString(0, n) is Left
- x.SubString(n) is Right (not the same as VB.Right!)
- x.SubString(m,n ) is Middle

Which if you believe Overloading is "evil", then yes I agree it may be "weak
semantics". However! I see overloading as a very powerful OO tool (which
like any construct can be easily abused), so the above does not cause me any
real issues... Info on "Overloadin g vs. Object Technology"
http://www.inf.ethz.ch/personal/meye...verloading.pdf

I do find VB.Left, VB.Right, & VB.Mid can be "better" in that they have more
tolerant argument checking, which also makes String.SubStrin g "better" as it
insists on correct arguments!

Jay

"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:eh******** ******@TK2MSFTN GP14.phx.gbl... Jay,

"Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> schrieb:

Why?! I am not a fan of weak semantics...

?

How is String.SubStrin g "weak semantics"? To me it is very OO, you have a
string object & you want to get part of that string object.

'Left', 'Mid' and 'Right' make it more obvious which part of the string is
returned, and thus make code more readable. 'Substring' can be used to to
the same, but the user will have to analyze the values passed to it in
order to be able to determine if the left, right, or an arbitrary part
(middle) of the string is returned. In other words: The name 'Substring'
only tells the reader that a part of the string is returned, names like
'Left' and 'Right' provide more/additional information.

Notice that I was not discussing that 'Substring' is more OO than 'Left',
'Right', etc. OO is a good tool, but in some cases (like working with
strings or dealing with numbers) it IMO doesn't add much benefit.

Would

\\\
Dim d As Double = ...
Dim e As Double = d.Cos() * 2
///

really have benefits over

\\\
Dim d As Double
Dim e As Double = Math.Cos(d) * 2
///

only because it's more OO?

SCNR

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

[Herfried K. Wagner [MVP]]

Jay,

"Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> schrieb:

'Left', 'Mid' and 'Right' make it more obvious which part of the string
is returned, and thus make code more readable. I agree it may be more obvious...

However! I'm just wondering about "weak semantics", to me saying it is
"weak semantics" is like insisting a glass is half full, when it is
obvious it is really half empty! Considering most of the time, it really
doesn't matter if I am getting the Left, Mid or Right of a string, I just
want a part of the string...

When learning string algorithms for university, I found those much clearer
and easier to understand which used 'Left' or 'Right' instead of picking out
a part of a string starting at a certain position and ending at a certain
position, or starting at a certain position and being of a certain length,
respectively. Imagine describing an algorithm that works on a string to
somebody via telephone. Would you say "Take the substring starting at
position 22 and ending at the string's end" or would you say "Take the
string's last three characters". I'd say the latter. Sure, taking the
start and end of a string /is/ taking /part of/ the string, but that's a
more general description of what is done.
When you just want part of a string, any part of the string, SubString or
just Mid is sufficient. Left & Right can be implemented in terms of
SubString or Mid themselves...
If I just want a part of the string that I don't have more information
about, I use 'Mid'. For the special cases, I prefer 'Right' and 'Left' for
the reasons described above.

the same, but the user will have to analyze the values passed to it in
order to be able to determine if the left, right, or an arbitrary part
(middle) of the string is returned.

If one uses SubString enough is this really an issue? In other words, they
soon pick up on:
- x.SubString(0, n) is Left
- x.SubString(n) is Right (not the same as VB.Right!)
- x.SubString(m,n ) is Middle

You definitely /can/ get used to it and then be able to use it without any
problems.

BTW: It's interesting that the method's name is 'Substring', but most
people refer to it as 'SubString', even those who are using case-sensitive
programming languages ;-).
Which if you believe Overloading is "evil", then yes I agree it may be
"weak semantics". However! I see overloading as a very powerful OO tool
(which like any construct can be easily abused), so the above does not
cause me any real issues... Info on "Overloadin g vs. Object Technology"
http://www.inf.ethz.ch/personal/meye...verloading.pdf
Thanks for the link, that's an interesting article. Well, I really liked
the sample of named constructors the author of the article you referenced
above gave... ;-). I believe in the power of overloading and I am confident
that it is a very powerful OO tool, but my concerns were not primarily
related to overloading in general.
I do find VB.Left, VB.Right, & VB.Mid can be "better" in that they have
more tolerant argument checking, which also makes String.SubStrin g
"better" as it insists on correct arguments!

:-)

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

[Jay B. Harlow [MVP - Outlook]]

Herfried,

BTW: It's interesting that the method's name is 'Substring', but most
people refer to it as 'SubString', even those who are using case-sensitive
programming languages ;-). I was using Substring (in this thread), but I "corrected" myself, as
SubString was used earlier in this thread...

Jay
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:Oy******** ******@TK2MSFTN GP09.phx.gbl... Jay,

"Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> schrieb:

'Left', 'Mid' and 'Right' make it more obvious which part of the string
is returned, and thus make code more readable.

I agree it may be more obvious...

However! I'm just wondering about "weak semantics", to me saying it is
"weak semantics" is like insisting a glass is half full, when it is
obvious it is really half empty! Considering most of the time, it really
doesn't matter if I am getting the Left, Mid or Right of a string, I just
want a part of the string...

When learning string algorithms for university, I found those much clearer
and easier to understand which used 'Left' or 'Right' instead of picking
out a part of a string starting at a certain position and ending at a
certain position, or starting at a certain position and being of a certain
length, respectively. Imagine describing an algorithm that works on a
string to somebody via telephone. Would you say "Take the substring
starting at position 22 and ending at the string's end" or would you say
"Take the string's last three characters". I'd say the latter. Sure,
taking the start and end of a string /is/ taking /part of/ the string, but
that's a more general description of what is done.

When you just want part of a string, any part of the string, SubString or
just Mid is sufficient. Left & Right can be implemented in terms of
SubString or Mid themselves...

If I just want a part of the string that I don't have more information
about, I use 'Mid'. For the special cases, I prefer 'Right' and 'Left'
for the reasons described above.

the same, but the user will have to analyze the values passed to it in
order to be able to determine if the left, right, or an arbitrary part
(middle) of the string is returned.

If one uses SubString enough is this really an issue? In other words,
they soon pick up on:
- x.SubString(0, n) is Left
- x.SubString(n) is Right (not the same as VB.Right!)
- x.SubString(m,n ) is Middle

You definitely /can/ get used to it and then be able to use it without any
problems.

BTW: It's interesting that the method's name is 'Substring', but most
people refer to it as 'SubString', even those who are using case-sensitive
programming languages ;-).

Which if you believe Overloading is "evil", then yes I agree it may be
"weak semantics". However! I see overloading as a very powerful OO tool
(which like any construct can be easily abused), so the above does not
cause me any real issues... Info on "Overloadin g vs. Object Technology"
http://www.inf.ethz.ch/personal/meye...verloading.pdf

Thanks for the link, that's an interesting article. Well, I really liked
the sample of named constructors the author of the article you referenced
above gave... ;-). I believe in the power of overloading and I am
confident that it is a very powerful OO tool, but my concerns were not
primarily related to overloading in general.

I do find VB.Left, VB.Right, & VB.Mid can be "better" in that they have
more tolerant argument checking, which also makes String.SubStrin g
"better" as it insists on correct arguments!

:-)

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