Istruzione Switch fallthrough in C#?

Istruzione Switch fallthrough è uno dei miei principali motivi per amare switch vs if/else if costrutti. Un esempio è qui:

static string NumberToWords(int number)
{
    string[] numbers = new string[] 
        { "", "one", "two", "three", "four", "five", 
          "six", "seven", "eight", "nine" };
    string[] tens = new string[] 
        { "", "", "twenty", "thirty", "forty", "fifty", 
          "sixty", "seventy", "eighty", "ninety" };
    string[] teens = new string[]
        { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
          "sixteen", "seventeen", "eighteen", "nineteen" };

    string ans = "";
    switch (number.ToString().Length)
    {
        case 3:
            ans += string.Format("{0} hundred and ", numbers[number / 100]);
        case 2:
            int t = (number / 10) % 10;
            if (t == 1)
            {
                ans += teens[number % 10];
                break;
            }
            else if (t > 1)
                ans += string.Format("{0}-", tens[t]);
        case 1:
            int o = number % 10;
            ans += numbers[o];

            break;
        default:
            throw new ArgumentException("number");
    }
    return ans;
}

Che le persone intelligenti sono servile, perché il string[]s deve essere dichiarata al di fuori della funzione: beh, sono, questo è solo un esempio.

Il compilatore non riesce con il seguente messaggio di errore:

Controllo non è possibile il passaggio da un'etichetta di caso (caso 3:') a un altro 
Controllo non è possibile il passaggio da un'etichetta di caso (caso 2:') a un altro 

Perché? E c’è un modo per ottenere questo tipo di comportamento, senza dover tre ifs?

 

14 Replies
  1. 619

    (Copia/incolla di un la risposta che ho fornito altrove)

    Cadere attraverso switchcases può essere ottenuto con un codice in un case (vedi case 0), o utilizzando l’apposito goto case (vedi case 1) o goto default (vedi case 2) forme:

    switch (/*...*/) {
        case 0: //shares the exact same code as case 1
        case 1:
            //do something
            goto case 2;
        case 2:
            //do something else
            goto default;
        default:
            //do something entirely different
            break;
    }
    • Penso che, in questo particolare esempio, il goto non è considerato nocivo.
    • Accidenti ho ricevuto una programmazione con C#, fin dai primi giorni di 1.0 e ho mai visto fino ad ora. Va solo a dimostrare, si imparano cose nuove ogni giorno.
    • Va tutto bene, Erik. L’unica ragione per la /mi/ lo sapeva, è che io sono la teoria dei compilatori nerd che leggere ECMA-334 specifiche con una lente di ingrandimento.
    • Wow… ho appena usato un goto nel mio codice. Devo sentire sporco?
    • Sì, probabilmente. Ma non è niente di che, una doccia calda e un po ‘ di rifattorizzazione non risolvere 😛
    • Non ho mai pensato che io possa mai usare goto istruzione nella mia vita dopo l’ultima volta che l’ho usato negli anni 80′, in qualche oscuro Turbo Pascal 3 funzione. 🙂 Questo mi ha salvato un paio di minuti, in realtà.
    • Sarebbe eccessivo per creare una nuova parola riservata fallthrough che si potrebbe utilizzare per indicare il desiderio esplicito di consentire cadere attraverso. Il compilatore potrebbe quindi controllare per caduta accidentale, ma consentire propositivo di utilizzo.
    • Al momento la funzionalità è stata scritta, C# non era ancora aggiunto nessun “soft” parole chiave (come la ‘resa’, ‘var’, ‘da’, e ‘selezionare’), quindi avevano tre opzioni reali: 1) fare ‘fallthrough’ un duro parola chiave (non puoi usarlo come un nome di variabile), 2) scrivere il codice necessario per sostenere un morbido parola chiave, 3) uso già riservato parole chiave. #1 è stato un grosso problema per coloro porting di codice; #2 è stata una abbastanza grande engineering task, da quello che ho capito; e, in opzione, sono andato con, #3 aveva un vantaggio collaterale: gli altri sviluppatori lettura di un codice dopo il fatto, hanno potuto conoscere le caratteristiche di base del concetto di goto
    • Che il codice non ha funzionato per me (in Visual Studio 2010), ho ancora l’errore del compilatore “Controllo non è possibile il passaggio da un’etichetta di caso (caso 1:’) a un altro”. Ho anche aggiunto una break; istruzione dopo il goto e ora ho solo un messaggio di avviso (codice irraggiungibile rilevato) con l’errore.
    • Assicurarsi che hai un caso che dice “caso 2:” non può qualcos’altro — questo ha lavorato fin .NET 1.0, e funziona ancora in VS2012 con .NET 4.5.
    • Non ho esplorato in dettaglio, ma ero ancora di ricevere questo errore, anche con un goto, quando ero commutazione su una stringa, invece di un valore intero.
    • Dege – se stai passando una stringa, il goto istruzione per case("XYZ"): dovrebbe essere scritto goto case ("XYZ");
    • Tutto questo parlare di nuovo/speciale parole chiave per un esplicito fallthrough. Non sono solo usato il ‘continua’, parola chiave? In altre parole. Rompere l’interruttore o proseguire verso il successivo caso (caduta attraverso).
    • Che cosa succede se il switch è all’interno di un ciclo?
    • Un buon punto. La proposta di continuare sarebbe vincolata all’ambito del caso solo.
    • Io odio, odio, ODIO questo. Non una riflessione sulla domanda o risposta, ho appena odio il fatto che questo è necessario in C#.
    • Perché? Si preferisce implicita autunno-attraverso? Sono abbastanza sicuro che gli ultimi 30 anni di C-come la lingua d’uso e ci ha detto come orribile un’idea. L’unica alternativa reale non è anche a sostegno di questo, e forzare né una duplicazione del codice, o (gasp) standard goto etichette.
    • Come su un join case istruzione che si sarebbero comportati come case salvo che il precedente caso sarebbe caduta attraverso? Io credo che il più pulito di un goto gli obiettivi che la prossima istruzione eseguibile, ma non per evitare tutti i problemi connessi con implicita autunno-attraverso.
    • Questo dovrebbe comunque evitato quando è possibile. Casi non sempre in modo lineare come in questo esempio, e se qualcuno mai mescola il loro ordine nell’istruzione switch vi ritroverete a saltare casi, invece di cadere attraverso.
    • Grazie Alex, non sapevo che possiamo usare ‘goto’ in C#, l’ultima volta che l’ho usato, nel 2001, quando ero all’Università in una classe di Intro. per la Programmazione in Turbo Pascal e QBasic. So ‘goto’ è una parola riservata, ma questa è la mia prima volta che ho usato in C#, quando stavo imparando più circa l’istruzione Switch fallthrough in C#. Ho aggiunto il mio codice e funziona. Grazie ancora.
    • goto ha perfettamente legale ed elegante per altri usi di questo.

  2. 40

    Il “perché” è quello di evitare la caduta accidentale-attraverso, per la quale sono grato. Questa è una rara fonte di bug in C e Java.

    La soluzione è utilizzare goto, ad esempio,

    switch (number.ToString().Length)
    {
        case 3:
            ans += string.Format("{0} hundred and ", numbers[number / 100]);
            goto case 2;
        case 2:
        //Etc
    }

    Il progetto generale di switch/case è un po ‘ sfortunato, a mio avviso. Mi è rimasto troppo vicino al C – ci sono alcune modifiche che potrebbero essere apportate in termini di scoping etc. Forse un intelligente interruttore che potrebbe fare il pattern matching ecc, sarebbe molto utile, ma davvero cambiando da passare a “controllare una sequenza di condizioni” – al punto che un nome diverso sarebbe forse essere chiamato per.

    • Questa è la differenza tra switch e if/elseif nella mia mente. Interruttore per il controllo di vari membri di una singola variabile, mentre if/elseif può essere utilizzato per controllare un qualsiasi numero di cose che si è collegato, ma non necessariamente un singolo, o la stessa variabile.
    • Il Pattern matching in C# sarebbe spettacolare…
    • Se è per impedire l’accidentale caduta attraverso quindi mi sento un avviso del compilatore sarebbe stato meglio. Esattamente come uno se la vostra istruzione se ha un incarico: if (result = true) { }
    • Avvisi del compilatore in realtà dovrebbe essere per i casi in cui si riesce quasi sempre a correggere il codice per essere migliore. Personalmente preferisco implicita di rottura, quindi non sarebbe un problema all’inizio, ma questa è un’altra questione.
  3. 26

    Interruttore fallthrough è storicamente una delle principali fonte di errori nei moderni software. La lingua designer hanno deciso di rendere obbligatorio per saltare alla fine del caso, a meno che non si renda inadempiente al caso successivo direttamente senza trattamento.

    switch(value)
    {
        case 1://this is still legal
        case 2:
    }
    • Io bene perché non lo capirà mai che non è il “caso 1, 2:”
    • Pfeffer: Yup è, e così è case 1, 2: in lingue che permettono che. Quello che non capirò mai è perché qualsiasi lingua moderna non sarebbe scegliere di consentire che.
    • con l’istruzione goto, più separati da virgola opzioni potrebbe essere difficile da gestire?
    • potrebbe essere più preciso dire che case 1, 2: è una singola etichetta, ma con più nomi. — FWIW, io penso che la maggior parte delle lingue che vietano la caduta attraverso non caso speciale la “consecutivi etichette caso” indio, ma piuttosto di trattare il caso di etichette come un’annotazione sulla prossima dichiarazione e richiedono l’ultima istruzione prima di una dichiarazione contrassegnati con (uno o più) in caso le etichette per essere un salto.
  4. 20

    Per aggiungere alle risposte qui, penso che vale la pena considerare l’opposto domanda in concomitanza con questo, viz. perché C consente autunno-attraverso, in primo luogo?

    Qualsiasi linguaggio di programmazione, naturalmente, serve a due scopi:

    1. Fornire le istruzioni per il computer.
    2. Lasciare una traccia di le intenzioni del programmatore.

    La creazione di qualsiasi linguaggio di programmazione è quindi un equilibrio tra il modo di servire al meglio questi due obiettivi. Da un lato, il più facile è quello di trasformare in istruzioni per il computer (se tali sono in codice macchina, il bytecode come IL, o le istruzioni sono interpretati esecuzione) poi più in grado che il processo di compilazione o interpretazione sarà quello di essere efficiente, affidabile e compatto in uscita. Portato all’estremo, questo obiettivo nei nostri risultati di scrivere in assembly, IL, o anche crudo op-codici, perché il modo più semplice compilazione, dove non c’è la compilation a tutti.

    Al contrario, più la lingua che esprime l’intenzione del programmatore, piuttosto che i mezzi presi a tal fine, il più comprensibile il programma sia durante la scrittura e durante la manutenzione.

    Ora, switch potrebbe sempre sono stati compilati dalla conversione in equivalenti catena di if-else blocchi o simili, ma è stato progettato come consente la compilazione in una particolare assemblea comune modello in cui si assume un valore, calcola un offset da esso (se guardando una tabella indicizzata da un hash perfetta del valore, o da un reale aritmetica del valore*). Vale la pena notare a questo punto che, oggi, C# compilation a volte girare switch nell’equivalente if-else, e a volte uso un hash-based salto di approccio (e anche con C, C++ e altri linguaggi, confrontabile con la sintassi).

    In questo caso ci sono due buone ragioni per consentire l’autunno-attraverso:

    1. Succede solo che, naturalmente, in ogni caso: se si crea una tabella di collegamento in un set di istruzioni, e uno dei precedenti lotti di istruzioni non contiene alcuni sorta di salto o di ritorno, dopo di che l’esecuzione sarà solo naturalmente progressi nella prossima partita. Permettendo autunno-attraverso era ciò che avrebbe capitare se si è attivata la switch-utilizzo di C in jump-tabella–uso di codice macchina.

    2. Programmatori che hanno scritto in assemblea sono stati già utilizzati per l’equivalente: quando si scrive un salto tabella a mano in assemblea, avrebbero dovuto valutare se un determinato blocco di codice, il risultato sarebbe un ritorno, un salto al di fuori della tabella, oppure di passare al blocco successivo. Come tali, non avendo il coder aggiungere un’esplicita break quando era necessario “naturale” per il coder troppo.

    Al momento, pertanto, è stato un ragionevole tentativo di bilanciare i due obiettivi di un linguaggio per computer in quanto si riferisce al prodotto in codice macchina, e l’espressività del codice sorgente.

    Quattro decenni più tardi, però, le cose non sono proprio la stessa cosa, per un paio di motivi:

    1. Programmatori C oggi può avere poco o nessun assemblea esperienza. Programmatori in molti altri di tipo C le lingue sono anche meno (soprattutto il Javascript!). Qualsiasi concetto di “ciò che le persone sono abituati a dall’assemblea” non è più rilevante.
    2. Miglioramenti in ottimizzazioni significa che la probabilità di switch essere trasformato in if-else perché ritenuta l’approccio probabilmente più efficiente, oppure trasformato in un particolare esoterico variante del salto-tabella approccio sono più alti. La mappatura tra il più alto e più basso livello di approcci non è così forte come era una volta.
    3. Esperienza ha dimostrato che la caduta-tende a essere la minoranza caso, piuttosto che la norma (uno studio del Sole compilatore trovato 3% di switch blocchi usati una caduta-per il tramite di altri di più etichette sullo stesso blocco, e si pensava che il caso d’uso qui inteso che questo 3% è stato in realtà molto più alto rispetto al normale). Così la lingua studiata fare l’insolito più facilmente soddisfatti-che il comune.
    4. Esperienza ha dimostrato che la caduta-tende a essere fonte di problemi, sia nei casi in cui è eseguito accidentalmente, e anche nei casi in cui una corretta fall-through è perso da qualcuno gestione del codice. Quest’ultimo è un sottile, oltre al bug associati autunno-attraverso, perché anche se il codice è perfettamente privo di bug, il fall-through può ancora causare problemi.

    Relative a questi due ultimi punti, si consideri la seguente citazione dall’attuale edizione di K&R:

    Che cade da un caso all’altro non è robusto, essendo incline alla disgregazione quando il programma viene modificato. Con l’eccezione di più etichette per un singolo calcolo, fall-through dovrebbe essere usato con parsimonia, e commentato.

    Come una questione di buona forma, mettere una pausa dopo l’ultimo caso (l’impostazione predefinita), anche se è logicamente necessaria. Da qualche giorno quando un altro caso viene aggiunto alla fine, questo po ‘ di defensive programming vi salva.

    Così, dalla bocca del cavallo, fall-through in C è problematico. E ‘ considerata buona pratica sempre documento fall-through con i commenti, che è un’applicazione del principio generale che si dovrebbe documento in cui si fa qualcosa di insolito, perché è di questo che si metteranno in viaggio dopo l’esame del codice e/o rendere il vostro codice di guardare come si dispone di un richiedente bug quando è in realtà corretto.

    E quando pensate a questo proposito, un codice come questo:

    switch(x)
    {
      case 1:
       foo();
       /* FALLTHRU */
      case 2:
        bar();
        break;
    }

    È aggiunta di qualcosa per rendere la caduta-attraverso esplicito nel codice, non è qualcosa che può essere rilevato (o la cui assenza può essere rilevato dal compilatore.

    Come tale, il fatto che deve essere esplicito con fall-through in C# non aggiunge alcuna penale per la gente che ha scritto anche in altre C-stile comunque le lingue, dal momento che potrebbero già essere espliciti nella loro caduta-through.†

    Infine, l’uso di goto qui è già una norma da C e altri linguaggi:

    switch(x)
    {
      case 0:
      case 1:
      case 2:
        foo();
        goto below_six;
      case 3:
        bar();
        goto below_six;
      case 4:
        baz();
        /* FALLTHRU */
      case 5:
      below_six:
        qux();
        break;
      default:
        quux();
    }

    In questo tipo di caso in cui si desidera un blocco per essere inclusi nel codice eseguito per un valore di diverso da quello che porta al precedente blocco, quindi siamo già a dover utilizzare goto. (Naturalmente, ci sono modi e modi per evitare questo con diverse istruzioni condizionali, ma questo è vero per appena circa tutto ciò che riguarda questa domanda). Come tale, C#, costruito sulla già normale modo di affrontare una situazione in cui vogliamo colpire più di un blocco di codice in un switch, e solo generalizzate per coprire autunno-attraverso pure. Inoltre, fatto in entrambi i casi, più conveniente e di auto-documentazione, dal momento che abbiamo per aggiungere una nuova etichetta in C, ma può utilizzare l’ case come un’etichetta in C#. In C# siamo in grado di sbarazzarsi di below_six etichetta e utilizzare goto case 5 che è più chiaro di cosa stiamo facendo. (Ci sarebbe anche da aggiungere break per il default, che ho lasciato fuori solo per fare il sopra C codice chiaramente non il codice C#).

    In sintesi quindi:

    1. C# non riguarda più unoptimised output del compilatore come direttamente come codice C 40 anni fa (né C in questi giorni), che la rende una delle ispirazioni di caduta-attraverso irrilevante.
    2. C#, rimane compatibile con il C e non solo, avendo implicita break, per un più facile apprendimento della lingua da parte di coloro che hanno familiarità con linguaggi simili, e più semplice porting.
    3. C# rimuove una possibile fonte di errori o frainteso il codice che è stato ben documentato come la causa di problemi per gli ultimi quattro decenni.
    4. C# rende gli attuali best practice con C (documento di cadere attraverso le) esecutiva dal compilatore.
    5. C# rende l’insolito caso più esplicito codice, il caso di solito quello con il codice di uno solo scrive automaticamente.
    6. C# utilizza la stessa gotoapproccio per colpire il blocco da diversi case etichette come è utilizzato in C. solo generalizza ad alcuni altri casi.
    7. C#, fa che gotoapproccio più conveniente, e più chiaro, quello che è in C, consentendo case dichiarazioni di agire come etichette.

    In tutto, abbastanza ragionevole decisione di progettazione


    *Alcune forme di BASE permetterebbe di fare del calibro di GOTO (x AND 7) * 50 + 240 che mentre fragili e, quindi, un particolare caso convincente per divieto di goto, non servono a mostrare una maggiore equivalente in lingua di una sorta di modo che il codice di livello più basso possibile fare un salto a base di aritmetica su un valore, che è molto più ragionevole quando è il risultato della compilazione, piuttosto che qualcosa che deve essere mantenuto manualmente. Implementazioni di Duff Dispositivo, in particolare, si prestano bene per l’equivalente codice macchina o IL perché di ogni blocco di istruzioni spesso sarà la stessa lunghezza senza l’aggiunta di nop riempitivi.

    †Duff Dispositivo si presenta di nuovo qui, come un ragionevole eccezione. Il fatto che con quella e modelli simili c’è una ripetizione di operazioni serve a rendere l’uso di caduta-relativamente chiaro anche senza un esplicito commento a tale effetto.

  5. 15

    Si puo ‘goto etichetta di caso’
    http://www.blackwasp.co.uk/CSharpGoto.aspx

    L’istruzione goto è un semplice comando che incondizionatamente trasferisce il controllo del programma e l’altro economico. Il comando è stato spesso oggetto di critiche ad alcuni sviluppatori, sostenendo la sua rimozione da tutti i linguaggi di alto livello, che può portare a spaghetti code. Questo si verifica quando ci sono così tanti goto o simili salto dichiarazioni che il codice diventa difficile da leggere e da mantenere. Tuttavia, ci sono programmatori che l’istruzione goto, se utilizzato con attenzione, fornisce un’elegante soluzione per alcuni problemi…

  6. 8

    Hanno lasciato fuori questo comportamento legato alla progettazione per evitare, quando non è stato usato dai, ma causato problemi.

    Può essere utilizzato solo se non c’è nessuna dichiarazione nel caso in parte, come:

    switch (whatever)
    {
        case 1:
        case 2:
        case 3: boo; break;
    }
  7. 4

    Hanno cambiato l’istruzione switch (da C/Java/C++) comportamento per c#. Credo che il ragionamento era che la gente dimenticato la caduta attraverso e gli errori sono stati causati. Un libro che ho letto ha detto di usare il goto per simulare, ma questo non suona come una buona soluzione per me.

    • C# supporta goto, ma non fallthrough? Wow. E non solo quelli. C# è l’unica lingua che so di che si comporta in questo modo.
    • Non ho proprio come in un primo momento, ma “la caduta-thru” è in realtà una ricetta per il disastro (in particolare tra programmatori junior.) Come molti hanno sottolineato, C# consente ancora l’autunno-thru per linee vuote (che è la maggioranza dei casi.) “Kenny” postato un link che mette in evidenza elegante Goto uso con switch-case.
    • Non è un affare enorme, a mio parere. Il 99% del tempo non voglio cadere attraverso e sono stato bruciato da errori in passato.
    • “questo non suona come una buona soluzione per me” — mi dispiace sentire che su di voi, perché questo è ciò che goto case è per. Il suo vantaggio rispetto fallthrough è che è esplicito. Che alcune persone qui oggetto di goto case, mostra solo che sono stati indottrinati contro il “goto”, senza alcuna comprensione del problema e sono incapaci di pensare in proprio. Quando Dijkstra ha scritto “VAI Considerati Nocivi”, si rivolgeva lingue che non hanno altro mezzo per cambiare il flusso di controllo.
    • e poi quante persone che citano Dijkstra su che verrà offerta Knuth che “l’ottimizzazione è la radice di ogni male”, anche se quella frase era quando Knuth era esplicitamente scritto di quale utile goto può essere quando l’ottimizzazione del codice?
    • Perché, allora, fece richiamare “Hoare è detto”? Knuth che la carta era più sulla chiarezza di ottimizzazione. La citazione non è effettivamente indicato nella carta; piuttosto, egli scrive: “Nella nostra discussione precedente abbiamo concluso che prematura enfasi sull’efficienza energetica è un grosso errore che può essere all’origine di programmazione complessità e di dolore”.
    • La citazione dare apparve p. 294 del giornale in questione, con “l’ottimizzazione è la radice di ogni male” avendo, infatti, è apparso a pag. 268. Il libro chiama per un punto di vista equilibrato, che elimina goto in un sacco di casi, ma li accetta in altri, almeno fino lingue e/o compilatori rimuovere i vantaggi sono conservati ancora oggi rilevanti: ad esempio con C# etichettati pausa potrebbe probabilmente rimuovere alcuni altri usi, mentre con l’ .NET jitter, più aggressivo di coda di chiamata ottimizzazione vorresti rimuovere il suo utilizzo per il manuale di coda-chiamata di eliminazione).
    • Come per “Hoare del dictum”, Knuth si riferiva ad esso come che circa 15 anni più tardi. Hoare a sua volta negato ricordo di averlo mai detto e suggerito (ironicamente) che potrebbe essere stato Dijkstra del conio. In ogni modo, la cosa che ho più di Knuth di carta che contiene la prima versione conosciuta di esso, è che il pensiero per le conseguenze è più importante la corrispondenza di un grande suono citazione, comunque.
    • Mi stai dicendo cose che già so, solo che ho perso il precedente preventivo. Ancora più usi di goto potrebbe essere eliminato con multi-livello di pausa/continua e con funzioni locali, ancora non disponibile in C#, mentre in più lingue-anche se le chiusure, infine, rendere il “mainstream” per le lingue (tranne C) può essere utilizzato in sostituzione.
    • Ho pensato, probabilmente, era molto, dal momento che il mio primo commento era a sostegno di voi, dopo tutto.

  8. 0

    Un salto istruzione come una pausa è
    necessaria dopo ogni caso di blocco,
    compreso l’ultimo blocco se si tratta di
    un caso di dichiarazione o di default
    istruzione. Con una sola eccezione, (a differenza di
    l’istruzione switch di C++, C# non
    il supporto di un passaggio implicito da
    in un caso l’etichetta di un altro. Quello
    eccezione è il caso in un caso la dichiarazione ha
    nessun codice.

    C# switch() documentazione

    • Mi rendo conto che questo comportamento è documentato, voglio sapere PERCHÉ è così com’è, e le eventuali alternative per ottenere il comportamento.
    • Non hai bisogno di break dopo l’ultimo caso…
  9. 0

    Dopo ogni istruzione richiede pausa o goto istruzione anche se si tratta di un caso di default.

    • Se solo qualcuno aveva postato che due anni prima!
    • e ‘ stato divertente la prima volta… Shilpa non hai bisogno di una pausa o vai per ogni caso, per ogni caso, con il proprio codice. È possibile avere più casi che condividono codice bene.
  10. 0

    È possibile ottenere cadono attraverso come il c++ da goto parola chiave.

    EX:

    switch(num)
    {
       case 1:
          goto case 3;
       case 2:
          goto case 3;
       case 3:
          //do something
          break;
       case 4:
          //do something else
          break;
       case default:
          break;
    }
    • Se solo qualcuno aveva postato che due anni prima!
  11. 0

    Solo una breve nota per aggiungere che il compilatore per Xamarin in realtà ho sbagliato e permette fallthrough. Ha presumibilmente è stato risolto, ma non è stato rilasciato. Lo ha scoperto nel codice che in realtà era caduta e il compilatore non si lamentano.

  12. -1

    C# non supporta la caduta con switch/case dichiarazioni. Non so perché, ma non c’è davvero alcun supporto per esso. Collegamento

    • Questo è così sbagliato. Vedi le altre risposte … l’effetto di un implicita fallthrough può essere ottenuto con un esplicito goto case. Questo è stato intenzionale, saggia scelta di design per il C# designer.
  13. -1

    switch (riferimenti per C#) dice:

    C# si richiede la fine di passare sezioni, tra cui quella finale,

    Così è anche necessario aggiungere un break; al tuo default sezione, altrimenti ci sarà ancora sarà un errore del compilatore.

    • Thx, questo mi ha aiutato 😉
  14. -12

    Hai dimenticato di aggiungere la “pausa”; istruzione in caso di 3. Nel caso 2 è stato scritto nel blocco if.
    Quindi, provare questo:

    case 3:            
    {
        ans += string.Format("{0} hundred and ", numbers[number / 100]);
        break;
    }
    
    
    case 2:            
    {
        int t = (number / 10) % 10;            
        if (t == 1)            
        {                
            ans += teens[number % 10];                
        }            
        else if (t > 1)                
        {
            ans += string.Format("{0}-", tens[t]);        
        }
        break;
    }
    
    case 1:            
    {
        int o = number % 10;            
        ans += numbers[o];            
        break;        
    }
    
    default:            
    {
        throw new ArgumentException("number");
    }
    • Questo produce enormemente sbagliato uscita. Ho lasciato l’interruttore dichiarazioni di progettazione. La domanda è perché il compilatore C# vede questo come un errore quando quasi non ha questa limitazione.
    • Quale grande errore di comprendere. E avete avuto 5 anni per eliminare questo e ancora non l’avete fatto? Qualcosa di sbalorditivo.

Lascia un commento