switch vs Select Case

[ME]

In C# the following code generates a compiler error
("A constant value is expected"):

public void Test(string value)
{
switch (value)
{
case SimpleEnum.One. ToString():
MessageBox.Show ("Test 1");
break;
case SimpleEnum.Two. ToString():
MessageBox.Show ("Test 2");
break;
case SimpleEnum.Thre e.ToString():
MessageBox.Show ("Test 3");
break;
}
}

The Visual Basic.NET version does not:

Public Sub Test(ByVal value As String)
Select Case value
Case SimpleEnum.One. ToString()
MessageBox.Show ("Test 1")
Case SimpleEnum.Two. ToString()
MessageBox.Show ("Test 2")
Case SimpleEnum.Thre e.ToString()
MessageBox.Show ("Test 3")
Case Else
End Select
End Sub
How can this be done in C# and also why is this true?

[Bruce Wood]

"case" expressions must be constants in C#. As soon as you use
"ToString" you are using a method result, which is variable by
definition.

Anyway, in both VB.NET and C# I wouldn't do it that way. To me, you
have it flipped around backward. You're better off converting the
string to the enumeration, and then doing the switch. The only extra
code is to catch errors:

public void Test(string value)
{
try
{
SimpleEnum enumVal = Enum.Parse(type of(SimpleEnum), value,
false);
switch (enumVal)
{
case SimpleEnum.One: MessageBox.Show ("Test 1"); break;
case SimpleEnum.Two: MessageBox.Show ("Test 2"); break;
case SimpleEnum.Thre e: MessageBox.Show ("Test 3"); break;
default:
MessageBox.Show (String.Format( "Added new enum {0}
without modifying switch", enumValue);
break;
}
}
catch (ArgumentExcept ion)
{
MessageBox.Show (String.Format( "String {0} is not a
SimpleEnum.", value);
}
}

[Bob Grommes]

Clearly VB.NET is not as strict about what can be tested. My suspicion
is that a C# switch, if you can live within its requirements, is faster,
although I doubt it matters in the real world very often.

A C# construct like the following will do what you want:

if (value == SimpleEnum.One. ToString()) {
MessageBox.Show ("Test 1");
} else if (value == SimpleEnum.Two. ToString()) {
MessageBox.Show ("Test 2");
} else if (value == SimpleEnum.Thre e.ToString()) {
MessageBox.Show ("Test 3");
} else {
MessageBox.Show ("Default Test");
}

--Bob

ME wrote:

In C# the following code generates a compiler error
("A constant value is expected"):

public void Test(string value)
{
switch (value)
{
case SimpleEnum.One. ToString():
MessageBox.Show ("Test 1");
break;
case SimpleEnum.Two. ToString():
MessageBox.Show ("Test 2");
break;
case SimpleEnum.Thre e.ToString():
MessageBox.Show ("Test 3");
break;
}
}

The Visual Basic.NET version does not:

Public Sub Test(ByVal value As String)
Select Case value
Case SimpleEnum.One. ToString()
MessageBox.Show ("Test 1")
Case SimpleEnum.Two. ToString()
MessageBox.Show ("Test 2")
Case SimpleEnum.Thre e.ToString()
MessageBox.Show ("Test 3")
Case Else
End Select
End Sub
How can this be done in C# and also why is this true?

[Octavio Hernandez]

Hi,

The C# specs indicate that you should place constant expressions in case
clauses. Your calls to ToString() are not.
VB.NET Select Case is obviously more "dynamic" and calculates the expression
at runtime and then checks for equality. This scheme may look more dynamic,
but offers less opportunities for code optimization.
I think you should rewrite your method in order to receive not a string, but
a SimpleEnum parameter, which can be used later in the switch statement. It
will be safer and more efficient:

public void Test(SimpleEnum se)
{
switch (se)
{
case SimpleEnum.One:
MessageBox.Show ("Test 1");
break;
case SimpleEnum.Two:
MessageBox.Show ("Test 2");
break;
}
}

Regards - Octavio
"ME" <tr*********@co mcast.netREMOVE THIS> escribió en el mensaje
news:Pr******** ************@co mcast.com...

In C# the following code generates a compiler error
("A constant value is expected"):

public void Test(string value)
{
switch (value)
{
case SimpleEnum.One. ToString():
MessageBox.Show ("Test 1");
break;
case SimpleEnum.Two. ToString():
MessageBox.Show ("Test 2");
break;
case SimpleEnum.Thre e.ToString():
MessageBox.Show ("Test 3");
break;
}
}

The Visual Basic.NET version does not:

Public Sub Test(ByVal value As String)
Select Case value
Case SimpleEnum.One. ToString()
MessageBox.Show ("Test 1")
Case SimpleEnum.Two. ToString()
MessageBox.Show ("Test 2")
Case SimpleEnum.Thre e.ToString()
MessageBox.Show ("Test 3")
Case Else
End Select
End Sub
How can this be done in C# and also why is this true?

[Brooke]

Not sure if this is what you are trying to do, but this works fine under 2.0
framework.

using System;

public class MyTestClass {

private enum Nums {
One = 1,
Two,
Three
}

public static void Test(string Value) {

switch(Value) {

case "One":
Console.WriteLi ne("Test One");
break;

case "Two":
Console.WriteLi ne("Test Two");
break;

case "Three":
Console.WriteLi ne("Test Three");
break;
}
}

public static int Main() {

Test(Enum.GetNa me(typeof(Nums) , Nums.Two));
Test(Enum.GetNa me(typeof(Nums) , Nums.One));
Test(Enum.GetNa me(typeof(Nums) , Nums.Three));
Test(Enum.GetNa me(typeof(Nums) , Nums.Two));

System.Console. Write("\nPress any key to continue...");
System.Console. ReadKey();

return 0;
}
}
Bye

"Bruce Wood" <br*******@cana da.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

"case" expressions must be constants in C#. As soon as you use
"ToString" you are using a method result, which is variable by
definition.

Anyway, in both VB.NET and C# I wouldn't do it that way. To me, you
have it flipped around backward. You're better off converting the
string to the enumeration, and then doing the switch. The only extra
code is to catch errors:

public void Test(string value)
{
try
{
SimpleEnum enumVal = Enum.Parse(type of(SimpleEnum), value,
false);
switch (enumVal)
{
case SimpleEnum.One: MessageBox.Show ("Test 1"); break;
case SimpleEnum.Two: MessageBox.Show ("Test 2"); break;
case SimpleEnum.Thre e: MessageBox.Show ("Test 3"); break;
default:
MessageBox.Show (String.Format( "Added new enum {0}
without modifying switch", enumValue);
break;
}
}
catch (ArgumentExcept ion)
{
MessageBox.Show (String.Format( "String {0} is not a
SimpleEnum.", value);
}
}

[Wiebe Tijsma]

Hi Brooke,

Yes, it works the way you apply it, you use string constants, but you
can't use variables. In general practice, it's better to avoid 'magic'
string constants like these.

Bruce's way is preferable...

Wiebe

Brooke wrote:

Not sure if this is what you are trying to do, but this works fine under 2.0
framework.

using System;

public class MyTestClass {

private enum Nums {
One = 1,
Two,
Three
}

public static void Test(string Value) {

switch(Value) {

case "One":
Console.WriteLi ne("Test One");
break;

case "Two":
Console.WriteLi ne("Test Two");
break;

case "Three":
Console.WriteLi ne("Test Three");
break;
}
}

public static int Main() {

Test(Enum.GetNa me(typeof(Nums) , Nums.Two));
Test(Enum.GetNa me(typeof(Nums) , Nums.One));
Test(Enum.GetNa me(typeof(Nums) , Nums.Three));
Test(Enum.GetNa me(typeof(Nums) , Nums.Two));

System.Console. Write("\nPress any key to continue...");
System.Console. ReadKey();

return 0;
}
}
Bye

"Bruce Wood" <br*******@cana da.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

"case" expressions must be constants in C#. As soon as you use
"ToString" you are using a method result, which is variable by
definition.

Anyway, in both VB.NET and C# I wouldn't do it that way. To me, you
have it flipped around backward. You're better off converting the
string to the enumeration, and then doing the switch. The only extra
code is to catch errors:

public void Test(string value)
{
try
{
SimpleEnum enumVal = Enum.Parse(type of(SimpleEnum), value,
false);
switch (enumVal)
{
case SimpleEnum.One: MessageBox.Show ("Test 1"); break;
case SimpleEnum.Two: MessageBox.Show ("Test 2"); break;
case SimpleEnum.Thre e: MessageBox.Show ("Test 3"); break;
default:
MessageBox.Show (String.Format( "Added new enum {0}
without modifying switch", enumValue);
break;
}
}
catch (ArgumentExcept ion)
{
MessageBox.Show (String.Format( "String {0} is not a
SimpleEnum. ", value);
}
}

[ME]

I can see the enum example is throwing several off the point. Here is another EXAMPLE of a time when I would like to use a dynamic switch:

private void WorkWithSelecte dColumn(Templat eADataSet.SiteO ptionsRow row, string columnName)
{

//Switch 1 works:
switch (columnName)
{
case "Key":
break;
case "Value":
break;
case "UniqueID":
break;
}

//Switch 2 does not work in c# but the vb version will work
switch (columnName)
{
case row.Key:
break;
case row.Value:
break;
case row.UniqueID:
break;
}
}

I realize that C# requires a constant. My question is, why give the VB guys the "option" of creating a dynamic switch/select case but not give it to the C# guys? Typically the way I handle this particular example is by using SQL to generate some code constants (public constants of every column name of every table in my data base) and use those in place of the "xxx" in switch 1. It would be nice to be able to perform the task in switch 2, which would leave out a step (VS builds the dataset for me just fine).

Thanks,

Matt
"ME" <tr*********@co mcast.netREMOVE THIS> wrote in message news:Pr******** ************@co mcast.com...

In C# the following code generates a compiler error
("A constant value is expected"):

public void Test(string value)
{
switch (value)
{
case SimpleEnum.One. ToString():
MessageBox.Show ("Test 1");
break;
case SimpleEnum.Two. ToString():
MessageBox.Show ("Test 2");
break;
case SimpleEnum.Thre e.ToString():
MessageBox.Show ("Test 3");
break;
}
}

The Visual Basic.NET version does not:

Public Sub Test(ByVal value As String)
Select Case value
Case SimpleEnum.One. ToString()
MessageBox.Show ("Test 1")
Case SimpleEnum.Two. ToString()
MessageBox.Show ("Test 2")
Case SimpleEnum.Thre e.ToString()
MessageBox.Show ("Test 3")
Case Else
End Select
End Sub


How can this be done in C# and also why is this true?

[Bruce Wood]

I believe that the answer to the question, "Why doesn't C# allow
variables or expressions as 'case' values?" is as follows.

Languages that allow variable 'case' values, or that go even farther
and allow conditions case 'case' values, have little choice but to turn
switches with variable or conditional cases into a long sequence of if
/ then / else if / ... else statements. As such, VB.NET (for example)
is doing some magic behind the scenes to turn what looks like a switch
into something that isn't a switch at all, in order to allow the
programmer to use a more pleasing construct.

C# (and C and C++) take the attitude that what you code is what you
get. The language doesn't play monkey business behind the scenes. In
C#, a 'switch' is always a fast selection amongst alternatives. The
language might choose to generate a switch as a sequence of tests, but
only if it were faster to do it that way. In keeping with this
philosophy, the language doesn't allow you to write code that looks
like a fast selection amongst alternatives but in fact is not.
Therefore, 'case' values must be constants, so that the strategy for
deciding how to arrive at the correct case can be decided at compile
time.

[Jon Skeet [C# MVP]]

Bruce Wood <br*******@cana da.com> wrote:

<snip>

C# (and C and C++) take the attitude that what you code is what you
get. The language doesn't play monkey business behind the scenes. In
C#, a 'switch' is always a fast selection amongst alternatives. The
language might choose to generate a switch as a sequence of tests, but
only if it were faster to do it that way. In keeping with this
philosophy, the language doesn't allow you to write code that looks
like a fast selection amongst alternatives but in fact is not.
Therefore, 'case' values must be constants, so that the strategy for
deciding how to arrive at the correct case can be decided at compile
time.

Ironically, C# *does* play monkey business behind the scenes when it
comes to strings, as noted elsewhere (using a Hashtable when there are
more than a few strings). Fortunately, it's still a fast selection, but
perhaps not quite as fast as might be expected.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[ME]

Bruce,

I agree with your logic. So the next question I would have is why does VB
still allow it? Shouldn't the languages be close here? The diffence
between a dynamic construct(vb) and a static one could cause some major
grief if re-wrote from VB to C#. It could be said that this WOULD make C# a
better language. Isn't that what MS is trying to squash?

Thanks,

Matt
"Bruce Wood" <br*******@cana da.com> wrote in message
news:11******** **************@ g43g2000cwa.goo glegroups.com.. .

I believe that the answer to the question, "Why doesn't C# allow
variables or expressions as 'case' values?" is as follows.

Languages that allow variable 'case' values, or that go even farther
and allow conditions case 'case' values, have little choice but to turn
switches with variable or conditional cases into a long sequence of if
/ then / else if / ... else statements. As such, VB.NET (for example)
is doing some magic behind the scenes to turn what looks like a switch
into something that isn't a switch at all, in order to allow the
programmer to use a more pleasing construct.

C# (and C and C++) take the attitude that what you code is what you
get. The language doesn't play monkey business behind the scenes. In
C#, a 'switch' is always a fast selection amongst alternatives. The
language might choose to generate a switch as a sequence of tests, but
only if it were faster to do it that way. In keeping with this
philosophy, the language doesn't allow you to write code that looks
like a fast selection amongst alternatives but in fact is not.
Therefore, 'case' values must be constants, so that the strategy for
deciding how to arrive at the correct case can be decided at compile
time.