I miss loop

[cj]

When I'm inside a do while loop sometimes it's necessary to jump out of
the loop using exit do. I'm also used to being able to jump back and
begin the loop again. Not sure which language my memories are of but I
think I just said loop somewhere inside the loop and it immediately
jumped back to the start of the loop and began again. I can't seem to
do that in .net. I this functionality available?

[cj]

Wow, not just anyone but a respected member of the community
recommending me to use goto. :) That took guts! I hope the community
still respects him.

Well, in case you haven't read all the other branches of this message I
can't seem to go against all these years of negative public opinion. I
decided to use nested do loops. I still think this is one time goto is
actually a practical, legitimate, and indeed inspired idea. I wish I
had the guts to use it. Herfried, your opinions are always welcome in
my posts.
Mythran wrote:

"cj" <[e-mail] am> wrote in message
news:%2******** ********@TK2MSF TNGP09.phx.gbl. ..

Whowa! Your sure to get blasted for that idea. I hope you aren't
using your real name. :) I just might do that though.
Herfried K. Wagner [MVP] wrote:

"cj" <[e-mail] am> schrieb:
Unfortunately I'm using VB.Net 2003 right now and continue doesn't
appear to do that in 2003. I believe continue does have that
functionality in some language.

You can still mimick the behavior of 'continue' using a named label
and 'GoTo'...

lol Herfried is a very popular poster here :) As well as an MVP...he'll
be blasted for being both of those for sure <ducks>

Naw, Herfried is a good poster and if he gets blasted...

Mythran

[cj]

Yes, that works too but requires me to enclose every segment of the code
in if else statements checking to see if it's ok to do it. I did use
this type of code in one place except I called it loopError and set it
to False and if it remains false It does all the ifs. Strangely next to
the non existent loop/continue statement goto would seem to create the
most readable and compact code. The example in VB.net 2003's help for
goto is an example of a bad use of goto.


Tim Ferguson wrote:

cj <[e-mail] am> wrote in
news:#z******** ******@TK2MSFTN GP10.phx.gbl:

Basically I'm starting the loop and if things go correctly I execute
all code in it. But at say 6 places in the loop I have to check how
things are going. If they are not going well I want to forget about
processing the remainder of work in the loop and try the next
iteration.

You could always try structured programming:
Do While True
carryOn = True

if carryOn Then
DoSomeProcessin g()
carryOn = Not ConditionMet()

end if

if carryOn Then
DoSomeMoreProce ssing()
If Not AnotherConditio n() Then
carryOn = False
End If

end if

if carryOn Then
DoLastBitOfWork
If FinalCondition > criterionDecide d Then
Exit Do
End If
End If

Loop

Hope that helps
Tim F

[cj]

Gee, I'm getting lots of support on this topic. Sounds like something
that needs discussing. I've done lots of batch files and you sure do
have to get, shall we say creative, to branch and make decisions.

Look familiar:

@echo off
if %1. == full. goto full
if %1. == FULL. goto full
goto mod
:full

In reviewing some of this just now I see one thing that would need to be
considered in choosing goto vs nested loops. I'm not sure but I suspect
the functionality of the not in VB.net 2003 loop/continue statement
would work more like the nested loops alternative than the goto
alternative. In a nested loop situation the exit sub would exit the
inner loop and therefore you'd re-enter the loop with any variables
declared inside the loop being refreshed, for lack of a better word. I
haven't tried but I get the impression from the help that goto can't be
used to jump outside a loop (to the line above it) so it could be
restarted, hence goto could only be used to go to the first line inside
the loop. variables inside the loop would not be refreshed they would
be as they existed before the goto was executed. This could be good or
it could be bad. Just has to be checked into and considered.
Mythran wrote:

An outer loop is what I have started with because goto has been out of
my vocabulary since 87.

Never do batch files eh? Like you said, it's not a bad command, just a
misused command. And if you want the functionality of "Continue"
without using the IF's, then Goto is the perfect command for what you
are trying to accomplish.

Mythran

[cj]

Thanks for all the support. I posted this to Mythran also but I wanted
to make sure you saw it as well.

In reviewing some of this just now I see one thing that would need to be
considered in choosing goto vs nested loops. I'm not sure but I suspect
the functionality of the not in VB.net 2003 loop/continue statement
would work more like the nested loops alternative than the goto
alternative. In a nested loop situation the exit sub would exit the
inner loop and therefore you'd re-enter the loop with any variables
declared inside the loop being refreshed, for lack of a better word. I
haven't tried but I get the impression from the help that goto can't be
used to jump outside a loop (to the line above it) so it could be
restarted, hence goto could only be used to go to the first line inside
the loop. variables inside the loop would not be refreshed they would
be as they existed before the goto was executed. This could be good or
it could be bad. Just has to be checked into and considered.
dotNuttah wrote:

cj wrote:

I understand the functionality of continue. I also understand it
doesn't work in VB.Net 2003, right? It does in 2005, right?

I don't know about 2005. ;-)

I understand why goto is not generally a good thing but just because a
command has been frequently misused in the past doesn't make it bad.
I admire Herfried for suggesting goto. It seems like a perfect use.

I've never thought goto was bad. I think that bad use of it is bad. :-D

Still I'm having a hard time using it because other say it's wrong.
It's a real conundrum. There has to be a way that socially acceptable
and personally feels right.

You're the only one that can change your personal perspective on it.
Socially it really depends on who's opinion you're giving value to. I wonder
what would happen if you change your personal perspective to let you use
goto when the situation warrants it, and give it more priority than "social"
opinion. :-))

An outer loop is what I have started with because goto has been out of
my vocabulary since 87. Still I just don't like seeing one loop
inserted inside another just for this functionality. It looks funny
and just seems wrong.

I often use that method but yep, it looks clumsy, clumsy and makes the code
cry out for some decent syntax for this structure. I can't remember where it
was but one language I came across had "break" (or exit loop) and "continue"
with an index. The index was the level of the loop that the break or
continue was applied to. Very handy.

To make the goto easy to use for a reader you have to make it stand out in
the code, else the reader might be hunting all over for it and that can look
clumsy too. Do you have the label in column one or indent it (and hence bury
it, to a degree) in the code which it labels? :-/ A choice of name that says
where to go/look, like "goto bottom_of_loop" helps.

I'll come up with a better way. Something in
the nature subroutines and flags etc.

Aye, it sounds as if the loop body contains enough that a subroutine would
be appropriate anyway, perhaps.

I'll get something that feels better when I get back to work tomorrow.

:-))

dotNuttah wrote:

cj wrote:
When I'm inside a do while loop sometimes it's necessary to jump out
of the loop using exit do. I'm also used to being able to jump back
and begin the loop again. Not sure which language my memories are
of but I think I just said loop somewhere inside the loop and it
immediately jumped back to the start of the loop and began again. I
can't seem to do that in .net. I this functionality available?
The meaning of "continue" is to start the *next* iteration
immediately and bypass any further code in the loop body. If you
want to continue the current operation then you'd either have an
inner loop or use a goto. If you want to completely restart the loop
then you'd be best enclosing it in an outer loop. You mustn't use
the goto idea for that one. Jumping out of the loop to before the
loop - that should get you those frowns. ;o)

[cj]

It sure has been nice discussing this here. I guess I found a subject
that many folks have encountered. There are lots of way to tackle the
problem. The continue/loop functionality I hoped existed in VB.Net 2003
for the do loop structure would be a perfect for this job. Since it
isn't I keep looking to find the next most perfect solution. Still I
don't have infinite time so I went with the nested do loop. It's not
perfect but it'll get the job done. When I have more time I'm going to
look into the goto some. Might have to put it back into service in this
one specific type of situation.

I need to get 2005 loaded and see what's in it sometime but that'll
probably be a few more months.
Cor Ligthert [MVP] wrote:

cj,

You can do it without a continue, a goto or whatever. I have once made a
sample for that when Marina told I could not. It is unreadable, however.
Therefore I do not show it here.

It was almost the same as yours, although she had made an impossible
chalenge as sample.

Cor

[cj]

Ooops, I refered to exit sub where I meant exit do.

cj wrote:

Thanks for all the support. I posted this to Mythran also but I wanted
to make sure you saw it as well.

In reviewing some of this just now I see one thing that would need to be
considered in choosing goto vs nested loops. I'm not sure but I suspect
the functionality of the not in VB.net 2003 loop/continue statement
would work more like the nested loops alternative than the goto
alternative. In a nested loop situation the exit sub would exit the
inner loop and therefore you'd re-enter the loop with any variables
declared inside the loop being refreshed, for lack of a better word. I
haven't tried but I get the impression from the help that goto can't be
used to jump outside a loop (to the line above it) so it could be
restarted, hence goto could only be used to go to the first line inside
the loop. variables inside the loop would not be refreshed they would
be as they existed before the goto was executed. This could be good or
it could be bad. Just has to be checked into and considered.
dotNuttah wrote:

cj wrote:

I understand the functionality of continue. I also understand it
doesn't work in VB.Net 2003, right? It does in 2005, right?

I don't know about 2005. ;-)

I understand why goto is not generally a good thing but just because a
command has been frequently misused in the past doesn't make it bad.
I admire Herfried for suggesting goto. It seems like a perfect use.

I've never thought goto was bad. I think that bad use of it is bad. :-D

Still I'm having a hard time using it because other say it's wrong.
It's a real conundrum. There has to be a way that socially acceptable
and personally feels right.

You're the only one that can change your personal perspective on it.
Socially it really depends on who's opinion you're giving value to. I
wonder
what would happen if you change your personal perspective to let you use
goto when the situation warrants it, and give it more priority than
"social"
opinion. :-))

An outer loop is what I have started with because goto has been out of
my vocabulary since 87. Still I just don't like seeing one loop
inserted inside another just for this functionality. It looks funny
and just seems wrong.

I often use that method but yep, it looks clumsy, clumsy and makes the
code
cry out for some decent syntax for this structure. I can't remember
where it
was but one language I came across had "break" (or exit loop) and
"continue"
with an index. The index was the level of the loop that the break or
continue was applied to. Very handy.

To make the goto easy to use for a reader you have to make it stand
out in
the code, else the reader might be hunting all over for it and that
can look
clumsy too. Do you have the label in column one or indent it (and
hence bury
it, to a degree) in the code which it labels? :-/ A choice of name
that says
where to go/look, like "goto bottom_of_loop" helps.

I'll come up with a better way. Something in
the nature subroutines and flags etc.

Aye, it sounds as if the loop body contains enough that a subroutine
would
be appropriate anyway, perhaps.

I'll get something that feels better when I get back to work tomorrow.

:-))

dotNuttah wrote:
cj wrote:
> When I'm inside a do while loop sometimes it's necessary to jump out
> of the loop using exit do. I'm also used to being able to jump back
> and begin the loop again. Not sure which language my memories are
> of but I think I just said loop somewhere inside the loop and it
> immediately jumped back to the start of the loop and began again. I
> can't seem to do that in .net. I this functionality available?
The meaning of "continue" is to start the *next* iteration
immediately and bypass any further code in the loop body. If you
want to continue the current operation then you'd either have an
inner loop or use a goto. If you want to completely restart the loop
then you'd be best enclosing it in an outer loop. You mustn't use
the goto idea for that one. Jumping out of the loop to before the
loop - that should get you those frowns. ;o)

[cj]

Ooops, I said exit sub where I meant exit do.

cj wrote:

Gee, I'm getting lots of support on this topic. Sounds like something
that needs discussing. I've done lots of batch files and you sure do
have to get, shall we say creative, to branch and make decisions.

Look familiar:

@echo off
if %1. == full. goto full
if %1. == FULL. goto full
goto mod
:full

In reviewing some of this just now I see one thing that would need to be
considered in choosing goto vs nested loops. I'm not sure but I suspect
the functionality of the not in VB.net 2003 loop/continue statement
would work more like the nested loops alternative than the goto
alternative. In a nested loop situation the exit sub would exit the
inner loop and therefore you'd re-enter the loop with any variables
declared inside the loop being refreshed, for lack of a better word. I
haven't tried but I get the impression from the help that goto can't be
used to jump outside a loop (to the line above it) so it could be
restarted, hence goto could only be used to go to the first line inside
the loop. variables inside the loop would not be refreshed they would
be as they existed before the goto was executed. This could be good or
it could be bad. Just has to be checked into and considered.
Mythran wrote:

An outer loop is what I have started with because goto has been out
of my vocabulary since 87.

Never do batch files eh? Like you said, it's not a bad command, just
a misused command. And if you want the functionality of "Continue"
without using the IF's, then Goto is the perfect command for what you
are trying to accomplish.

Mythran

[Sebastian]

I think you may have misunderstood the suggestion for using goto. Make
the goto go to the end of the loop, not the beginning, and you get
exactly the functionality of a continue statement, no messy inner loop.

Ex:
do

[Mythran]

"cj" <[e-mail] am> wrote in message
news:%2******** ********@TK2MSF TNGP11.phx.gbl. ..

Thanks for all the support. I posted this to Mythran also but I wanted to
make sure you saw it as well.

In reviewing some of this just now I see one thing that would need to be
considered in choosing goto vs nested loops. I'm not sure but I suspect
the functionality of the not in VB.net 2003 loop/continue statement would
work more like the nested loops alternative than the goto alternative. In
a nested loop situation the exit sub would exit the inner loop and
therefore you'd re-enter the loop with any variables declared inside the
loop being refreshed, for lack of a better word. I haven't tried but I
get the impression from the help that goto can't be used to jump outside a
loop (to the line above it) so it could be restarted, hence goto could
only be used to go to the first line inside the loop. variables inside
the loop would not be refreshed they would be as they existed before the
goto was executed. This could be good or it could be bad. Just has to be
checked into and considered.

Depends how you write it...

Your explanation is correct if written this way:

[begin loop]
[:MyLabel]
[do stuff]
[goto MyLabel]
[end loop]

You explanation is in-correct if written this way:

[begin loop]
[goto MyLabel]
[do stuff]
[:MyLabel]
[end loop]

So placing the label right before the loop re-starts will make it
iterate/increment properly :)

Mythran

[cj]

Quite true indeed.

Mythran wrote:

"cj" <[e-mail] am> wrote in message
news:%2******** ********@TK2MSF TNGP11.phx.gbl. ..

Thanks for all the support. I posted this to Mythran also but I
wanted to make sure you saw it as well.

In reviewing some of this just now I see one thing that would need to
be considered in choosing goto vs nested loops. I'm not sure but I
suspect the functionality of the not in VB.net 2003 loop/continue
statement would work more like the nested loops alternative than the
goto alternative. In a nested loop situation the exit sub would exit
the inner loop and therefore you'd re-enter the loop with any
variables declared inside the loop being refreshed, for lack of a
better word. I haven't tried but I get the impression from the help
that goto can't be used to jump outside a loop (to the line above it)
so it could be restarted, hence goto could only be used to go to the
first line inside the loop. variables inside the loop would not be
refreshed they would be as they existed before the goto was executed.
This could be good or it could be bad. Just has to be checked into
and considered.

Depends how you write it...

Your explanation is correct if written this way:

[begin loop]
[:MyLabel]
[do stuff]
[goto MyLabel]
[end loop]

You explanation is in-correct if written this way:

[begin loop]
[goto MyLabel]
[do stuff]
[:MyLabel]
[end loop]

So placing the label right before the loop re-starts will make it
iterate/increment properly :)

Mythran