切换vs选择案例 [英] switch vs Select Case

问题描述

在C＃中，以下代码生成编译器错误

（预期值为常量值）：


public void Test（字符串值）

{

开关（价值）

{

case SimpleEnum.One.ToString（）：

MessageBox.Show（" Test 1"）;

break;

case SimpleEnum.Two.ToString（）：

MessageBox.Show（" Test 2"）;

break;

case SimpleEnum.Three.ToString（）：

MessageBox.Show （测试3）;

休息;

}

}


视觉Basic.NET版本没有：


公共子测试（ByVal值为字符串）

选择案例值

Case SimpleEnum。 One.ToString（）

MessageBox.Show（" Test 1"）

Case SimpleEnum.Two.ToString（）

MessageBox.Show （测试2）

Case SimpleEnum.Three.ToString（）

MessageBox.Show（" Test 3"）

案例其他
结束选择

结束子

如何在C＃中完成这个以及为什么这是真的？

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.Three.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.Three.ToString()
MessageBox.Show("Test 3")
Case Else
End Select
End Sub
How can this be done in C# and also why is this true?

推荐答案

" case"表达式必须是C＃中的常量。一旦你使用

" ToString"你正在使用一个方法结果，它可以通过

定义来改变。


无论如何，在VB.NET和C＃中我都不会这样做办法。对我来说，你是
让它向后翻转。你最好将

字符串转换为枚举，然后进行切换。唯一额外的

代码是为了捕获错误：


public void Test（字符串值）

{

尝试

{

SimpleEnum enumVal = Enum.Parse（typeof（SimpleEnum），value，

false）;

switch（enumVal）

{

case SimpleEnum.One：MessageBox.Show（" Test 1"）; break;

case SimpleEnum.Two：MessageBox.Show（" Test 2"）; break;

case SimpleEnum.Three：MessageBox.Show（" Test 3"）; break;

默认值：

MessageBox.Show（String.Format（"添加新枚举{0}

而不修改开关"，enumValue ）;

休息;

}

}

catch（ArgumentException）

{

MessageBox.Show（String.Format（" String {0}不是

SimpleEnum。"，value）;

}

}

"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(typeof(SimpleEnum), value,
false);
switch (enumVal)
{
case SimpleEnum.One: MessageBox.Show("Test 1"); break;
case SimpleEnum.Two: MessageBox.Show("Test 2"); break;
case SimpleEnum.Three: MessageBox.Show("Test 3"); break;
default:
MessageBox.Show(String.Format("Added new enum {0}
without modifying switch", enumValue);
break;
}
}
catch (ArgumentException)
{
MessageBox.Show(String.Format("String {0} is not a
SimpleEnum.", value);
}
}

显然VB.NET对可以测试的东西并不严格。我的怀疑

是一个C＃开关，如果你可以满足它的要求，那就更快了，虽然我怀疑它在现实世界中很重要。


AC＃construct如下所示将做你想做的事：


if（value == SimpleEnum.One.ToString（））{

MessageBox。显示（测试1）;

}否则if（value == SimpleEnum.Two.ToString（））{

MessageBox.Show（" Test 2" ）;

} else if（value == SimpleEnum.Three.ToString（））{

MessageBox.Show（" Test 3"）;

} else {

MessageBox.Show（" Default Test"）;

}


--BOB


ME写道：

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.Three.ToString()) {
MessageBox.Show("Test 3");
} else {
MessageBox.Show("Default Test");
}

--Bob

ME wrote:

在C＃中，以下代码生成编译器错误
（预期值为常数值）：

public void Test（字符串值）
{
switch（value）
{
MessageBox.Show（" Test 1"）;
break;
case SimpleEnum.Two.ToString（）：
MessageBox .Show（" Test 2"）;
break;
case SimpleEnum.Three.ToString（）：
MessageBox.Show（" Test 3"）;
break;
}





公共子测试（ByVal值为字符串）
Select Case值Simple /Enum.One.ToString（）
MessageBox.Show（" Test 1"）
Case SimpleEnum.Two.ToString（）
MessageBox.Show（" Test 2）
Case SimpleEnum。 Three.ToString（）
MessageBox.Show（" Test 3"）
Case Else
End Select
End Sub

如何做到这一点在C＃以及为什么这是真的？

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.Three.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.Three.ToString()
MessageBox.Show("Test 3")
Case Else
End Select
End Sub
How can this be done in C# and also why is this true?

C＃规格表明如果

子句，你应该放置常量表达式。你对ToString（）的调用不是。

VB.NET Select Case显然更动态。并在运行时计算表达式

，然后检查是否相等。这个方案可能看起来更有活力，但是b $ b但是代码优化的机会更少。

我认为你应该重写你的方法以便不接收字符串，但是

a SimpleEnum参数，可以在以后的switch语句中使用。它将会更安全，更高效：


public void Test（SimpleEnum se）

{

switch（se）

{

case SimpleEnum.One：

MessageBox.Show（" Test 1"）;

休息;

case SimpleEnum.Two：

MessageBox.Show（" Test 2"）;

break; < br $>
}

}


问候 - Octavio

" ME" < TR ********* @ comcast.netREMOVETHIS> escribióenel mensaje

news：Pr ******************** @ comcast.com ...

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*********@comcast.netREMOVETHIS> escribió en el mensaje
news:Pr********************@comcast.com...

在C＃中，以下代码生成编译器错误
（预期值为常量值）：

public void Test（字符串值）

转换（值）
案例SimpleEnum.One.ToString（）：
MessageBox.Show（" Test 1"）;
break;
case SimpleEnum.Two。 ToString（）：
MessageBox.Show（" Test 2"）;
break;
case SimpleEnum.Three.ToString（）：
MessageBox.Show（" Test 3" ;）;
休息;
}





公共子测试（ByVal值）作为字符串）
Select Case值
Case SimpleEnum.One.ToString（）
MessageBox.Show（" Test 1"）
Case SimpleEnum.Two.ToString（）
Case SimpleEnum.Three.ToString（）
MessageBox.Show（" Test 3"）
Case Else
End Select
结束Sub

怎样才能在C＃中完成，为什么会这样呢？

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.Three.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.Three.ToString()
MessageBox.Show("Test 3")
Case Else
End Select
End Sub
How can this be done in C# and also why is this true?

这篇关于切换vs选择案例的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！