C# Switch case goto Default mit Syntax Error!

[roker002]

Ich habe ein kleines Problem. Eigentlich sollte es keine Probleme mit dem Syntax geben. Nagut, erst der Code!

switch (this.ProtocolVersion)
{
    case SnmpVersion.v1:
        ///Nur SNMP Version 1 spezifische Voreinstellungen.
        goto default;

    case SnmpVersion.v2:
        ///Nur SNMP Version 2 spezifische Voreinstellungen.
        goto default;

    case default: //<- Hier Syntax Error (Erwartet "(" )
        //Tu was generelles für alle Fälle
        break;
}

direkt beim Doppelpunkt nach dem "case default" erwartet der Compiler statt ":" - Doppelpunk eine "(" - Klammer auf.
WIESO?

 

[Tiger_UP23]

das letzte sollte nur "default" und nicht " case default" heißen

 

[1668mib]

Doofe frage... wenn es für alle Fälle ist, wieso machst du es nicht nach dem switch? oO

 

[R²-H]

//Tu was generelles für alle Fälle

Nach dem switch setzen

default tritt nur ein wenn keiner der definierten fälle zutrifft

 

[roker002]

ups, haha danke @Tiger....

@1668
Es gibt keine Doofe Frage!

OK, mir geht es um die Aufstellung der SNMP Nachricht. Der aufbau der Version 1 und 2 sind sehr ähnlich. Die Version 3 der SNMP nachricht, hat eigene Struktur die sich von den ersten beiden abgrenzt. Deswegen dachte ich, ich springe auf default wenn ich V1 und V2 benutze und für V3 wird einfach alles neu ausgeschrieben.

@R²
Ich kenne schon wofür switch case gebraucht wird, ich will einfach so wenig wie möglich den doppelten Code vermeiden.

 

[R²-H]

Deswegen dachte ich, ich springe auf default wenn ich V1 und V2 benutze und für V3 wird einfach alles neu ausgeschrieben.

Bitte klare Definitionen
am Besten mit Beispielen ...
Das versteht ja kein Mensch

 

[roker002]

@R²

StringBuilder sb = new StringBuilder();

switch (this.ProtocolVersion)
{
    case SnmpVersion.v1:
        sb.Append(" -v ");
        sb.Append((int)this.ProtocolVersion);
        goto default;

    case SnmpVersion.v2:
        sb.Append(" -v");
        sb.Append((int)this.ProtocolVersion);
        sb.Append("c");
        goto default;
    default:
        sb.Append(" ");

        ///Community
        sb.Append("-c ");
        sb.Append(this.Community);
        sb.Append(" ");

        ///Destination IP
        sb.Append(this.IPAddress.ToString());

        ///Message
        sb.Append(" ");
        sb.Append(this.Message);
break;
    case SnmpVersion.v3:
        throw new Exception("SNMP Trap Version 3 is not supported yet.");
    case SnmpVersion.none:
        throw new Exception("No SNMP Trap Version has been selected");
}

Letzte Erklärung, dieser Code wird für MS SQL CLR benutzt. StringBuilder ist nur wegen der Performance drin, da es am besten skaliert, als + Zeichen. Es werden da es bis zu mehrere 100 Traps versendet werden muss auch an die Performance gedacht werden.

 

[toeffi]

Unsinn was ich schrieb.

Grad erst gesehen was du gemacht hast. Trotzdem bin ich der Meinung das man es ohne Goto hinbekäme. Wie das musst du alleine rausfinden

 

[R²-H]

StringBuilder sb = new StringBuilder();

        private void AddDefault()
        {
            sb.Append(" ");

            ///Community
            sb.Append("-c ");
            sb.Append(this.Community);
            sb.Append(" ");

            ///Destination IP
            sb.Append(this.IPAddress.ToString());

            ///Message
            sb.Append(" ");
            sb.Append(this.Message);
        }

        private void yourMethod()
        {
            sb.Append(" -v ");
            sb.Append((int)this.ProtocolVersion);

            switch (this.ProtocolVersion)
            {
                case SnmpVersion.v1:
                    AddDefault();
                    break;
                case SnmpVersion.v2:
                    sb.Append("c");
                    AddDefault();
                    break;
                case SnmpVersion.v3:
                    throw new Exception("SNMP Trap Version 3 is not supported yet.");
                default:
                    throw new Exception("Invalid SNMP Trap Version has been selected");
            }
        }

Was sagst du, hab mal was aufgeräumt?

Nie vergessen goto ist ein nogo

 

[Grantig]

[korinthenkack]

throw new Exception("SNMP Trap Version 3 is not supported yet.");

Statt ner Exception wär hier ne NotImplementedException schöner find ich.
[/korinthenkack]

 

[R²-H]

Hab nur sein QT übernommen
Vllt. hats ja einen tieferen sinn man weiß es nicht...

 

[Yuuri]

Wozu gotos verwenden?

StringBuilder sb = new StringBuilder();

switch (this.ProtocolVersion)
{
    case SnmpVersion.v1:
        sb.Append(" -v ");
        sb.Append((int)this.ProtocolVersion);
        break;

    case SnmpVersion.v2:
        sb.Append(" -v");
        sb.Append((int)this.ProtocolVersion);
        sb.Append("c");
        break;
        
    case SnmpVersion.v3:
        throw new Exception("SNMP Trap Version 3 is not supported yet.");
    case SnmpVersion.none:
        throw new Exception("No SNMP Trap Version has been selected");
    default:
        break;
}

sb.Append(" ");

///Community
sb.Append("-c ");
sb.Append(this.Community);
sb.Append(" ");

///Destination IP
sb.Append(this.IPAddress.ToString());

///Message
sb.Append(" ");
sb.Append(this.Message);

Den default-Zweig machst du doch sowieso immer und bei der Exception wird der Code eh nicht weiter bearbeitet. Somit kannst du den default-Zweig auch nach dem switch ablaufen lassen.

 

[schlzber]

Nie vergessen goto ist ein nogo

Dieser Aussage kann ich so nicht zustimmen. Prinzipiell läßt sich syntaktisch jedes goto in äquivalenten Code ohne goto umwandeln (und sollte auch angestrebt werden), aber wenn dadurch die Übersichtlichkeit darunter leidet, ist es auch manchmal kontrakproduktiv.

Beispiel: Eine mehrfach verschachtelte Schleife aus der innersten verlassen? Am einfachsten mit goto direkt dahinter springen, andere Methoden wie mit Hilfe von Flags machen den Code meistens komplizierter und unübersichtlicher.

 

[R²-H]

Ist mit Sicherheit so wie du es beschreibst, hab nur eingetrichtert bekommen immer möglichst gotos zu vermeiden.

Ist ja eig. auch egal jeder hat seine eigenen Programmierstiel & das ist auch gut so

 

[schlzber]

Ich versuchs auch wo ich kann ;-)

Ist noch aus den 70ern überliefert, als viel mit BASIC programmiert wurde. Der Code wurde wegen der vielen gotos und der dadurch fehlenden Möglichket, ihm in Gedanken zu folgen, als Spaghetticode bezeichnet.
Siehe auch: http://c2.com/cgi/wiki?GotoConsideredHarmful

 

[roker002]

@Yuuri,

ja das war mein erster ansatz, aber wenn es wirklich eine Version 3 im code eingebaut werden sollte, so kann ich ja nach dem switch case keine weitere eingabe erlauben! Die Version 3 hat anderen Syntax und ist daher mit den ersten beiden inkompatibel...

eine andere Frage....

bin jetzt kein SNMP freund... ich meine, vorher nix damit zutun...

-v = version
-c = community
=> kommt die Destination IP
=> Absender?

was genau soll danach eingegeben werden?
ID der Nachricht?
dann kann man mit "s" String anhängen?

Irgendwie finde ich keine gute Erklärung zu dem ganzen

 

[1668mib]

Meiner Meinung nach ist der Versuch hier, gemeinsamen Code zwanghaft nur einmal zu schreiben ein gutes Beispiel dafür, dass weniger Code oft genug nicht besser ist...

Ich persönlich würde wohl für die verschiedenen SNMP-Versionen direkt eigene Methoden machen die dann den String wie du ihn brauchst zurückliefern...

 

[Whiz-zarD]

Dito.

Dann stehen eben halt einige Zeilen doppelt. Aber so kann man halt individuell auf jede Version reagieren, ohne dass Abhängigkeiten entstehen.

Ich versteh auch nicht, warum öfters append() aufgerufen wird. Einmal reicht doch völlig. Anstatt Z.B.

sb.Append(" -v");
sb.Append((int)this.ProtocolVersion);
sb.Append("c");

kann man auch

sb.Append("-v" + (int)this.ProtocolVersion + "c");

schreiben.

 

[lynxx]

Nie vergessen goto ist ein nogo

Lol .. hier aus meinem aktuellen Projekt:

short k = 0;
switch (lPart) {
  case 20: pixel[t + k] += curField[u + k++]; goto case 19;
  case 19: pixel[t + k] += curField[u + k++]; goto case 18;
  case 18: pixel[t + k] += curField[u + k++]; goto case 17;
  case 17: pixel[t + k] += curField[u + k++]; goto case 16;
  case 16: pixel[t + k] += curField[u + k++]; goto case 15;
  case 15: pixel[t + k] += curField[u + k++]; goto case 14;
  case 14: pixel[t + k] += curField[u + k++]; goto case 13;
  case 13: pixel[t + k] += curField[u + k++]; goto case 12;
  case 12: pixel[t + k] += curField[u + k++]; goto case 11;
  case 11: pixel[t + k] += curField[u + k++]; goto case 10;
  case 10: pixel[t + k] += curField[u + k++]; goto case 9;
  case 9: pixel[t + k] += curField[u + k++]; goto case 8;
  case 8: pixel[t + k] += curField[u + k++]; goto case 7;
  case 7: pixel[t + k] += curField[u + k++]; goto case 6;
  case 6: pixel[t + k] += curField[u + k++]; goto case 5;
  case 5: pixel[t + k] += curField[u + k++]; goto case 4;
  case 4: pixel[t + k] += curField[u + k++]; goto case 3;
  case 3: pixel[t + k] += curField[u + k++]; goto case 2;
  case 2: pixel[t + k] += curField[u + k++]; goto case 1;
  case 1: pixel[t + k] += curField[u + k]; break;
  default: break;
}

Das ist eine sozusagen eine "for (short k = 0; k < lPart; pixel[t+k] += curField[u+k++]);"-Schleife, nur schneller .. dann zeig mir mal wie das ohne goto geht ohne das der Code 7 Seiten lang ist.

 

[Yuuri]

@ lnyxx: So wie das aussieht, hättest du auch einfach das goto weglassen können, wenn nachfolgende Zweige sowieso abgearbeitet werden sollen. Das goto ist überflüssig. Ein case-Zweig endet ja nur, wenn es auf ein break; trifft.

Das ist eine sozusagen eine "for (short k = 0; k < lPart; pixel[t+k] += curField[u+k++]);"-Schleife, nur schneller ..

Nur der Wartungsaufwand ist 1000 Mal höher, ergo (für mich) komplett unproduktiv.