C# 我想要类似switch语句的东西（当然不同）

是否有一个C#结构，比如

switch

语句，允许控制进入下一个级别？我有这样的想法：

    public static IEnumerable<string> SeverityOrHigher(string severity)
    {
        var result = new List<string>();

        switch (severity.ToUpper())
        {
            case "ALL":
                result.Add("ALL");
            case "DEBUG":
                result.Add("DEBUG");
            case "INFO":
                result.Add("INFO");
            case "WARN":
                result.Add("WARN");
            case "ERROR":
                result.Add("ERROR");
            case "FATAL":
                result.Add("FATAL");
            case "OFF":
                result.Add("OFF");
            default:
                break;
        }

        return result;
    }

switch (severity.ToUpper())
{
  case "ALL":
    result.Add("ALL");
    goto case "DEBUG";
  case "DEBUG":
    result.Add("DEBUG");
    goto case "INFO";
  case "INFO":
    result.Add("INFO");
    goto case "WARN";
  case "WARN":
    result.Add("WARN");
    goto case "ERROR";
  case "ERROR":
    result.Add("ERROR");
    goto case "FATAL";
  case "FATAL":
    result.Add("FATAL");
    goto case "OFF";
  case "OFF":
    result.Add("OFF");
    break;
  default:
    break;
}

公共静态IEnumerable severity或更高（字符串严重性）
{
var result=新列表（）；
开关（severity.ToUpper（））
{
案例“全部”：
结果。添加（“全部”）；
案例“调试”：
添加（“调试”）；
案例“信息”：
结果。添加（“信息”）；
案例“警告”：
结果。添加（“警告”）；
案例“错误”：
结果。添加（“错误”）；
"致命个案:
结果。添加（“致命”）；
案例“关闭”：
结果。添加（“关闭”）；
违约：
打破
}
返回结果；
}

---

…这显然在C#中不起作用，（

控制不能从一个案例标签上掉下来…

），但在我看来似乎应该这样做。我知道它期望在那里中断，但这不会给我我正在寻找的数据流。怎样才能让这一切按我所希望的方式发生？

看起来不太好，但可以为您完成这项工作：

string s = severity.ToUpper();
result.add("OFF");
if (s == "OFF")
  return result;
result.add("FATAL");
if (s == "FATAL")
  return result;
result.add("ERROR");
if (s == "ERROR")
  return result;
// ...
result.add("ALL");
return result;

---

在您的案例中，您可以使用一点LINQ模拟“下降案例”：

public static IEnumerable<string> SeverityOrHigher(string severity)
{
    var result = new List<string>() 
        { "ALL", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF" };
    return result.SkipWhile(l => l != severity.ToUpper()).ToArray();
}

公共静态IEnumerable severity或更高（字符串严重性）
{
var result=新列表（）
{“全部”、“调试”、“信息”、“警告”、“错误”、“致命”、“关闭”}；
返回result.SkipWhile（l=>l！=severity.ToUpper（））.ToArray（）；
}

这不是最佳解决方案，但您可以使用如下

goto

语句：

    public static IEnumerable<string> SeverityOrHigher(string severity)
    {
        var result = new List<string>();

        switch (severity.ToUpper())
        {
            case "ALL":
                result.Add("ALL");
            case "DEBUG":
                result.Add("DEBUG");
            case "INFO":
                result.Add("INFO");
            case "WARN":
                result.Add("WARN");
            case "ERROR":
                result.Add("ERROR");
            case "FATAL":
                result.Add("FATAL");
            case "OFF":
                result.Add("OFF");
            default:
                break;
        }

        return result;
    }

switch (severity.ToUpper())
{
  case "ALL":
    result.Add("ALL");
    goto case "DEBUG";
  case "DEBUG":
    result.Add("DEBUG");
    goto case "INFO";
  case "INFO":
    result.Add("INFO");
    goto case "WARN";
  case "WARN":
    result.Add("WARN");
    goto case "ERROR";
  case "ERROR":
    result.Add("ERROR");
    goto case "FATAL";
  case "FATAL":
    result.Add("FATAL");
    goto case "OFF";
  case "OFF":
    result.Add("OFF");
    break;
  default:
    break;
}

---

我会创建另一个代表所有有效严重性的列表，并检查输入严重性是否为其中之一：

public static IEnumerable<string> SeverityOrHigher(string severity)
{
    var result = new List<string>();
    var severities = new List<string> { "ALL", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF" };

    severity = severity.ToUpper();

    if (severities.Contain(severity))
            result.Add(severity);

    return result;
}

公共静态IEnumerable severity或更高（字符串严重性）
{
var result=新列表（）；
var严重性=新列表{“全部”、“调试”、“信息”、“警告”、“错误”、“致命”、“关闭”}；
严重性=严重性。ToUpper（）；
if（严重性。包含（严重性））
结果。添加（严重性）；
返回结果；
}

使用转到：

        switch (severity.ToUpper())
        {
            case "ALL":
                result.Add("ALL");
                goto case "DEBUG";
            case "DEBUG":
                result.Add("DEBUG");
                goto case "INFO";
            case "INFO":
                result.Add("INFO");
                goto case "WARN";
            case "WARN":
                result.Add("WARN");
                goto case "ERROR";
            case "ERROR":
                result.Add("ERROR");
                goto case "FATAL";
            case "FATAL":
                result.Add("FATAL");
                goto case "OFF";
            case "OFF":
                result.Add("OFF");
                break;
            default:
                break;
        }

---

Microsoft（暗示）建议使用此选项：

与gotos等一起使用，您可以使用枚举和一点linq：

    public static IEnumerable<Severity> SeverityOrHigher(Severity severity)
    {
        var value = (int) severity;

        return Enum.GetValues(typeof (Severity))
            .Cast<int>()
            .Where(i => i >= value)
            .Select(i => (Severity) i);
    }

    public enum Severity
    {
        All = 0,
        Trace = 1,
        Debug = 2,
        Information = 3,
        Warning = 4,
        Error = 5,
        Fatal = 6
    }

公共静态IEnumerable严重性或更高（严重性）
{
var值=（int）严重性；
返回Enum.GetValues（typeof（严重性））
.Cast（）
。其中（i=>i>=值）
.选择（i=>（严重性）i）；
}
公共枚举严重性
{
全部=0，
Trace=1，
调试=2，
信息=3，
警告=4，
误差=5，
致命=6
}

@nemesv的Linq答案是更好的解决方案，但如果您想使用交换机，您可以这样做，并将得到相同的结果

public static IEnumerable<string> SeverityOrHigher(string severity)
{
  var lastFound = -1;

  var severityList = new List<string>() { "ALL", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF" };
  var results = new List<string>();

  foreach (var t in severityList)
  {

    if (lastFound > -1)
    {
      for (var index = lastFound + 1; index < severityList.Count; index++)
      {
        results.Add(severityList[index]);
      }
      return results;
    }

    switch (severity.ToUpper())
    {
      case "ALL":
        results.Add(severity);
        lastFound = 0;
        break;
      case "DEBUG":
        lastFound = 1;
        results.Add(severity);
        break;
      case "INFO":
        lastFound = 2;
        results.Add(severity);
        break;
      case "WARN":
        lastFound = 3;
        results.Add(severity);
        break;
      case "ERROR":
        lastFound = 4;
        results.Add(severity);
        break;
      case "FATAL":
        lastFound = 5;
        results.Add(severity);
        break;
      case "OFF":
        lastFound = 6;
        results.Add(severity);
        break;
    }
  }

  return results;
}

---

你到底想达到什么目的？你可以使用

goto case“DEBUG”

等，但你使用的是

goto

，因此Dijkstra会讨厌你。看起来枚举更适合你的根需求。@ChrisF，我希望能清楚地知道我想达到什么目的。给定一个特定的严重性级别，我想要一个该严重性级别和所有高于该级别的严重性的可枚举列表。现在你已经解释清楚了。bleargh。。。是 啊这也会起作用，但我希望有一个C#结构，它不会那么笨重。这看起来。。。有趣。仍然不是我所希望的C语言结构，但它似乎比switch子句中的goto语句更干净。也许它有点“聪明”，但我认为它仍然比使用

goto case

更可读。可读。。。无聊的。我想说goto案例更具可读性。但是我不喜欢在任何地方的项目中输入单词

goto

。但是我不喜欢在任何地方的项目中输入goto这个词。叫我老式“这个。。。看起来不对。我不认为这会达到正确的结果。是的，这会起作用，但也是的，这不是最佳的。我真不敢相信微软会用GOTO的声明而不是让控制权从标签上掉下来。@JeremyHolovacs:相信吧。“失败会导致更多的错误，而不是它所阻止的。”杰森：我认为这是一个遥远的话题，但我不喜欢政府保护我自己；语言的目的是通过提供灵活性来最大限度地利用工具。限制某些事情，因为它可能会把你搞砸，这是荒谬的；但是，如果他们对此一筹莫展，那么一个明确声明的

continue

/

yield

关键字或类似的东西来启用潜在的危险代码将是合适的。对于我想做的事情来说，这将是一个优雅、易读的解决方案，而且它在许多语言中都能很好地实现这一点。@Jeremy Holovacs:例如：“设计语言以防止某些类别的细微错误对我们来说是一个巨大的优先任务。”这与你的语言哲学是完全相反的。如果你想开枪打自己的脚，用另一种语言。我不认为这能完成我想做的事。我想过要这么做。。。不幸的是，这意味着要用每个条目解析我的日志严重性（通过log4net解析一个字符串），我对此避而远之；这似乎很愚蠢，这是必要的。这可能是美学上的，但在我的代码中加入一个

goto

子句的想法。。。不吸引人。：）我同意，我认为一个明确的错误关键字将是理想的，但至少这是一个选项。