Control cannot fall through from one case label ('case 115:')

  • Thread starter Thread starter puzzlecracker
  • Start date Start date
P

puzzlecracker

I just got this error, without more dissection it appears to be
preposterous for csharp to prevent cases in the switch to fall
through. In my case, I need to be able to fall through as the action
takes is the same for those cases.



Is that a joke?

switch(value)
{
case 1:
case2:
//do something
break;
default:
break
}

why should this fail?
 
Should work fine if you don't have any typeos.

- Case 2 didn't have a space between the words
- No semicolon after the last break

switch (value)
{
case 1:
case 2:
//do something
break;
default:
break;
}

Jason Newell
www.jasonnewell.net
 
Peter said:
You have to write an explicit "goto". In C#, every case must end with
_something_; implicit fall-through is not allowed.
Click to expand...

With the exception of empty cases, of course.
 
puzzlecracker said:
I just got this error, without more dissection it appears to be
preposterous for csharp to prevent cases in the switch to fall
through. In my case, I need to be able to fall through as the action
takes is the same for those cases.



Is that a joke?

switch(value)
{
case 1:
case2:
//do something
break;
default:
break
}

why should this fail?
Click to expand...

As long as you have no code between the two cases it will fall through
e.g. (this works)
case 0:
case 4: Console.WriteLine("Foo"); break;

but this will not compile without a break (or goto)
case 0: Console.WriteLine("Foo");
case 4: Console.WriteLine("Bar"); break;

Your sample should work (once the syntax errors are fixed)

Bill
 
As long as you have no code between the two cases it will fall through
e.g. (this works)
    case 0:
    case 4:  Console.WriteLine("Foo"); break;

but this will not compile without a break (or goto)
    case 0:  Console.WriteLine("Foo");
    case 4:  Console.WriteLine("Bar"); break;

Your sample should work (once the syntax errors are fixed)

    Bill
Click to expand...

Learn something new everyday.... This sort of thinks, yes, prevent a
lot of mistakes, yet makes us stupid!!!
 
Peter said:
You have to write an explicit "goto". In C#, every case must end
with something; implicit fall-through is not allowed.

This language feature is one of many designed to prevent some of the
most common typographical bugs that show up in other languages.
Click to expand...

They could have done it the Pascal way. No problems with fall-through
or common typo bugs there. <g>
 
They could have done it the Pascal way. No problems with fall-through
or common typo bugs there. <g>
Click to expand...

Yes they could have. But then again, having to mangle your source because
you can't do a switch on a string wouldn't have been fun would it?
 
Peter said:
Yes they could have. But then again, having to mangle your source
because you can't do a switch on a string wouldn't have been fun
would it?
Click to expand...

They could have done that for strings as well, no biggie. <g>

I was thinking of something along the lines of

switch (bla)
{
case 1, 3, 5:
code ...
break;
case 2, 4, 9:
code ...
break;
case 10..30:
code ...
break;
default:
code ...
break;
}
 
switch (bla)
{
case 1, 3, 5:
code ...
break;
case 2, 4, 9:
code ...
break;
case 10..30:
code ...
break;
default:
code ...
break;
}
Click to expand...


Now try that with an enum

MyThingKind.One, MyThingKind.Two, MyThingKind.Three

It gets messy really quickly. The 10..30 part is probably an improvement,
but I don't recall ever actually using it in Pascal so I've never missed it.
 
Peter said:
Now try that with an enum

MyThingKind.One, MyThingKind.Two, MyThingKind.Three

It gets messy really quickly.
Click to expand...

Not really:

case MyThingKind.One, MyThingKind.Two, MyThingKind.Three:
code;
break;

or:

case MyThingKind.One..MyThingKind.Three:
code;
break;

Not much messier than:

case MyThingKind.One:
case MyThingKind.Two:
case MyThingKind.Three:
code;
break;

They could have actually done away with break completely and used:

case A:
code;
case B:
code;
case C:
{
code;
code;
}

This would have been analogue to for(), if() and while(). Would have
been a little cleaner, IMO. But probably too far away from C++ and Java.
The 10..30 part is probably an
improvement, but I don't recall ever actually using it in Pascal so
I've never missed it.
Click to expand...

I have used it quite often, especially for character ranges like
'0'..'9', 'A'..'Z', but also for other ranges of values.

Oh well, any language has its syntactical highlights and its
syntactical problems. Not really relevant here, I guess. <g>

--
Rudy Velthuis http://rvelthuis.de

"Everywhere I go I'm asked if I think the university stifles
writers. My opinion is that they don't stifle enough of them."
-- Flannery O'Connor (1925-1964)
 
Not much messier than:

Exactly, it is messier :-)

Oh well, any language has its syntactical highlights and its
syntactical problems. Not really relevant here, I guess. <g>
Click to expand...

I expect discussing the C# language is probably one of the most on-topic
posts seen in this newsgroup for a while :-)
 
They could have done it the Pascal way. No problems with fall-through
or common typo bugs there. <g>
Click to expand...

But if I remember my Delphi7 correctly,
you could only switch on integers,
which made the case-statement almost useless.

- Michael Starberg
 
switch
{
using (MyThingKind)
{
case One, Two, Three:
doStuff();
}
}
Click to expand...

That's changing more than the way the switch statement works, it would also
require that the compiler change to assume the context when in a switch
statement, which wouldn't work because you could easily have a const
somewhere

const string One = "1";

Does "One" refer to the const, or to the MyThingKind.One enum? It would
save some typing, but could prove ambiguous I think.
 
That's changing more than the way the switch statement works, it would also
require that the compiler change to assume the context when in a switch
statement, which wouldn't work because you could easily have a const
somewhere

const string One = "1";

Does "One" refer to the const, or to the MyThingKind.One enum?  It would
save some typing, but could prove ambiguous I think.
Click to expand...

Well, the point of my fall through was that some of the cases had a
part of common functionality which i inserted in the last case, thus i
cannot just use one case.
 
Peter said:
Exactly, it is messier :-)
Click to expand...

Well said:
I expect discussing the C# language is probably one of the most
on-topic posts seen in this newsgroup for a while :-)
Click to expand...

Probably, but the language is as it is, and I doubt we will change it
by discussing how we would have liked to see it being more like another
language. So this dicussion is pretty irrelevant. Discussions about how
things actually are, are much more relevant.

--
Rudy Velthuis http://rvelthuis.de

"The chain reaction of evil -- wars producing more wars -- must
be broken, or we shall be plunged into the dark abyss of
annihilation." -- Martin Luther King, Jr.
 
Peter said:
switch
{
using (MyThingKind)
{
case One, Two, Three:
doStuff();
}
}
Click to expand...

Nah, ugly. If he wants vertical alignment:

case MyThingKindOne,
MyThingKindTwo,
MyThingKindThree:

I would rather have horizontal alignment. His format is more or less
like specifying every parameter of a function on its own line. <g>

--
Rudy Velthuis http://rvelthuis.de

"One of the symptoms of an approaching nervous breakdown is the
belief that one's work is terribly important."
-- Bertrand Russell (1872-1970)
 
Peter said:
That's changing more than the way the switch statement works, it
would also require that the compiler change to assume the context
when in a switch statement, which wouldn't work because you could
easily have a const somewhere

const string One = "1";

Does "One" refer to the const, or to the MyThingKind.One enum? It
would save some typing, but could prove ambiguous I think.
Click to expand...

:-)

There's the smiley I forgot to add. It really was tongue-in-cheek. I
have no problems with the syntax for c#'s switch statement.

If I have a lot of stuff to put in a case, or common functionality for
some cases, I'd usually write separate methods to handle that, and call
them from the appropriate cases.

Doesn't Pascal have some sort of "using" syntax? How does it handle
"using (MyThingKind)" when there is a MyThingKind.One and another
entity called "One"? (Guess I could ask in a Pascal group if I was
terribly worried about this issue).

/Peter K
 
Well, the point of my fall through was that some of the cases had a
part of common functionality which i inserted in the last case, thus i
cannot just use one case.
<<

In which case you explicitly state that you want to "fall through"


switch (k)
{
case MyThingKind.One:
DoSomething();
goto case MyThingKind.Common;

case MyThingKind.Two:
SoSomethingElse();
goto case MyThingKind.Common;

case MyThingKind.Common:
DoSomethingCommon();
break;
}


You cannot accidentally type that "goto case" statement but you can
accidentally forget to put in a "break", which I often do especially when
changing a NotImplementedException to implementation code.
 
Doesn't Pascal have some sort of "using" syntax?

You really never want to go there. I seem to remember reading an online
interview with Anders H where he was asked if C# would get a "with"
statement, he said "No". :-)

Although it was available in Delphi I stopped using it very early on because
bugs could easily creep into your code as a consequence of using it.
 
Back
Top