Mit .StartsWith in einer Switch-Anweisung?

Arbeite ich an einer Switch-Anweisung und mit zwei der Voraussetzungen brauche ich, um zu sehen, ob die Werte beginnen mit einem bestimmten Wert. Die Switch-Anweisung funktioniert wie diese. Der Fehler sagt "keine verdeckten Typ bool, string".

Jeder wissen, wenn ich die StartsWith in einem Switch oder brauche ich If...Else-Anweisungen?

switch(subArea)
            {
                case "4100":
                case "4101":
                case "4102":
                case "4200":
                    return "ABC";
                case "600A":
                    return "XWZ";
                case subArea.StartsWith("3*"):
                case subArea.StartsWith("03*"):
                    return "123";
                default:
                    return "ABCXYZ123";
            }

Sie müssen mithilfe von if/else.
Ich denke, man könnte noch den Schalter benutzen, der für alle anderen Werte und setzen die StartsWith-code in der default-Fall...

InformationsquelleAutor Caverman | 2016-01-22

12

Sie wechseln ein String, und subArea.StartsWith() gibt eine Boolean, das ist, warum Sie es nicht tun. Ich schlage vor, Sie tun es so:
```
if (subArea.StartsWith("3*") || subArea.StartsWith("03*"))
    return "123";

switch(subArea)
{
    case "4100":
    case "4101":
    case "4102":
    case "4200":
        return "ABC";
    case "600A":
        return "XWZ";
    default:
        return "ABCXYZ123";
}
```
Das Ergebnis das gleiche sein wird.

Das klappte! Danke.
Ich bevorzuge diese Lösung, weil es nicht in verschachtelte Logik.
"Das Ergebnis wird dasselbe sein" - vorausgesetzt, keiner der Werte in der switch-Case-Anweisungen beginnen mit "3*" oder "03*".
Sorry, ich verstehe nicht, was du meinst. Wenn Sie sagen, dass die Fälle StartsWith "3*" und "03*" sind nicht abgedeckt, es gibt eine, wenn Sie vor dem Schalter. Wenn nicht, könnten Sie bitte erklären? Danke

InformationsquelleAutor appa yip yip
5

Den case-labels müssen strings sein, da der switch-Ausdruck ist eine Zeichenkette; jedoch StartsWith gibt einen booleschen Wert zurück. Ich schlage vor, die Behandlung dieser besonderen Fälle in der default Abschnitt.
```
switch(subArea)
{
    case "4100":
    case "4101":
    case "4102":
    case "4200":
        return "ABC";
    case "600A":
        return "XWZ";
    default:
        if (subArea.StartsWith("3") || subArea.StartsWith("03")) {
            return "123";
        }
        return "ABCXYZ123";
}
```
Auch der Stern (*) ist vermutlich falsch, es sei denn, Sie wollen subArea enthalten es. StartWith akzeptiert keine wildcards.

Alternativ könnte man regex:
```
if (Regex.IsMatch(subArea, "^3|^03")) { //or "^(3|03)"
    return "123";
}
```
wo ^ bedeutet Anfang der Zeile und | bedeutet oder.

Danke für die Anregung. Es ist immer gut zu sehen, dass verschiedene Arten der Kodierung, um die gleichen Ergebnisse zu erzielen. Ich würde nicht gedacht haben, zu verwenden Regex. BTW: in meinem Fall das * ist eigentlich ein Teil der Daten und nicht als Joker.
Wenn Sie regex verwenden, vergessen Sie nicht, zu entkommen, der star: \*.

InformationsquelleAutor Olivier Jacot-Descombes

Joe Art mich zu schlagen, aber hier ist ein anderes non-Schalter Weg, es zu tun, die im wesentlichen implementiert eine pattern-matching-Algorithmus mit einem Regelwerk.

private static string GetSomeStringOrOther(string subArea)
{
    //Create a set of pattern matching functions...
    Func<string, string, bool> matchEquals = (a, b) => a.Equals(b);
    Func<string, string, bool> matchStarts = (a, b) => a.StartsWith(b);

    //Create a rule set...
    Tuple<string, string, Func<string, string, bool>>[] cases = new []
    {
        new Tuple<string, string, Func<string, string, bool>>("4100", "ABC", matchEquals),
        new Tuple<string, string, Func<string, string, bool>>("4101", "ABC", matchEquals),
        new Tuple<string, string, Func<string, string, bool>>("4102", "ABC", matchEquals),
        new Tuple<string, string, Func<string, string, bool>>("4200", "ABC", matchEquals),
        new Tuple<string, string, Func<string, string, bool>>("600A", "XWZ", matchEquals),
        new Tuple<string, string, Func<string, string, bool>>("3*", "123", matchStarts),
        new Tuple<string, string, Func<string, string, bool>>("03*", "123", matchStarts),
    };

    //Look for a match...
    foreach(var matchCase in cases)
    {
        if(matchCase.Item3(subArea, matchCase.Item1))
        {
            //Return if it matches...
            return matchCase.Item2;
        }
    }

    //Otherwise return the default...
    return "ABCXYZ123";
}

Vorteile

Wenn Sie eine neue Regel, es ist einfach zu addieren, um den Regel-Satz.
Wenn Sie eine neue pattern-matching-Funktion, wieder, einfach hinzufügen.
Nicht benötigen viel Nacharbeit, wenn eine Regel ändert.

Nachteile

Neuling/Anfänger und auch einige fortgeschrittene Entwickler, die vielleicht keine Ahnung haben, was Los ist.

Verbesserungen

Ersetzen Tuple<string, string, Func<string, string, bool>> mit einem semantischen Objekt repräsentiert eine Rule

Sehr schön. Ich habe vorgeschlagen eine bescheidene variation in meine Antwort, dass sein Appell an diejenigen, die interessiert sind, in die Verwendung von LINQ.

InformationsquelleAutor series0ne

Mit LINQ, die nette Antwort von @seriesOne werden kann "vereinfachte" ein bisschen durch den Austausch der foreach und return Aussagen mit:

//using System.Linq;

//Look for a match...
var result = cases
    .Where(c => c.Item3(subArea, c.Item1))
    .FirstOrDefault();

//Return the match or the default.
return result == null ? "ABCXYZ123" : result.Item2;

Eine gute Verbesserung. +1

InformationsquelleAutor DavidRR

Nur so zum Spaß, hier ' s eine andere Lösung, die vermeidet, dass die switch-Anweisung.

var map = new[] {
    new { Value = "4100", StartsWith = false, Result="ABC" },
    new { Value = "4101", StartsWith = false, Result="ABC" },
    new { Value = "4102", StartsWith = false, Result="ABC" },
    new { Value = "4200", StartsWith = false, Result="ABC" },
    new { Value = "600A", StartsWith = false, Result="XWZ" },
    new { Value = "3*", StartsWith = true, Result="123" },
    new { Value = "03*", StartsWith = true, Result="123" },
};

var subarea = ... whatever ...;

var result = map.Where(e =>
        {
            if (e.StartsWith)
            {
                return subarea.StartsWith(e.Value);
            }
            else
            {
                return subarea == e.Value;
            }
        }
    )
    .Select(e => e.Result)
    .FirstOrDefault() ?? "ABCXZ123";

Die Reihenfolge im array map bestimmt die Priorität, so dass, zum Beispiel, können Sie eine exakte übereinstimmung auf, sagen wir, "3*11", sowie eine StartsWith match auf "3*", z.B.:

var map = new[] {
    new { Value = "3*11", StartsWith = false, Result="ABC" },
    new { Value = "4100", StartsWith = false, Result="ABC" },
    new { Value = "4101", StartsWith = false, Result="ABC" },
    new { Value = "4102", StartsWith = false, Result="ABC" },
    new { Value = "4200", StartsWith = false, Result="ABC" },
    new { Value = "600A", StartsWith = false, Result="XWZ" },
    new { Value = "3*", StartsWith = true, Result="123" },
    new { Value = "03*", StartsWith = true, Result="123" },
};

InformationsquelleAutor Joe

Dank der wenn-Klausel, können Sie jetzt tun:

            switch (subArea)
            {
                //Skipping regular cases with string literals
                case string dummy
                    when subArea.StartsWith("3*") ||
                         subArea.StartsWith("03*"):
                    return "123";
                default:
                    return "ABCXYZ123";
            }

InformationsquelleAutor Bhu

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.