Qualcuno usa ancora [goto] in C # e, in caso affermativo, perché? [chiuso]

Mi chiedevo se qualcuno utilizza ancora la sintassi della parola chiave "goto" in C # e quali possibili ragioni ci sono per farlo.

Tendo a vedere tutte le affermazioni che inducono il lettore a saltare il codice come una cattiva pratica, ma mi chiedevo se esistessero scenari credibili per l'utilizzo di tale sintassi.

Vai alla definizione delle parole chiave

Ci sono alcuni (rari) casi in cui goto può effettivamente migliorare la leggibilità. In effetti, la documentazione a cui ti sei collegato elenca due esempi:

Un uso comune di goto consiste nel trasferire il controllo a una specifica etichetta switch-case o all'etichetta predefinita in un'istruzione switch.

L'istruzione goto è utile anche per uscire da loop profondamente annidati.

Ecco un esempio per quest'ultimo:

for (...) {
    for (...) {
        ...
        if (something)
            goto end_of_loop;
    }
}

end_of_loop:

Naturalmente, ci sono anche altri modi per aggirare questo problema, come il refactoring del codice in una funzione, l'utilizzo di un blocco fittizio attorno ad esso, ecc. (Vedere questa domanda per i dettagli). Come nota a margine, i progettisti del linguaggio Java hanno deciso di vietare completamente goto e introdurre invece un'istruzione break etichettata .

Ricordo questa parte

switch (a)     
{ 
    case 3: 
        b = 7;
        // We want to drop through into case 4, but C# doesn't let us
    case 4: 
        c = 3;
        break; 
    default: 
        b = 2;
        c = 4;
        break; 
}

A qualcosa di simile

switch (a)     
{
    case 3: 
        b = 7;
        goto case 4;    
    case 4: 
        c = 3;
        break;     
    default: 
        b = 2;
        c = 4;
        break;
}

Fare riferimento Questa

Lo uso ampiamente in Eduasync per mostrare il tipo di codice che il compilatore genera per te quando usi metodi asincroni in C # 5. Vedresti la stessa cosa nei blocchi iteratori.

Nel codice "normale" però, non ricordo l'ultima volta che l'ho usato ...

goto è ottimo per rompere molti loop in cui break non funzionerebbe bene (ad esempio in condizioni di errore) e, come ha detto Kragen, goto è usato dal compilatore per generare istruzioni switch e anche altre cose.

Non ricordo di aver mai usato goto. Ma forse migliora l'intento di un ciclo per sempre che non vuoi davvero mai uscire (no break, ma puoi ancora returno throw):

forever: {
  // ...
  goto forever;
}

Poi di nuovo, un semplice while (true)dovrebbe essere sufficiente ...

Inoltre, si potrebbe utilizzare in una situazione in cui si desidera che la prima iterazione di un ciclo per iniziare a metà del ciclo: cerca qui per un esempio.

Il compilatore utilizza le gotoistruzioni in varie parti del codice generato, ad esempio nei tipi di blocchi iteratori generati (generati quando si utilizza la yield returnparola chiave: sono abbastanza sicuro che i tipi di serializzazione XML generati abbiano anche alcune gotoistruzioni da qualche parte.

Vedere i dettagli sull'implementazione del blocco Iterator: macchine a stati generati automaticamente per ulteriori dettagli sul perché / come il compilatore C # gestisce questo.

Oltre al codice generato, non c'è una buona ragione per utilizzare gotoun'istruzione nel codice normale: rende il codice più difficile da capire e di conseguenza più soggetto a errori. D'altra parte usandogoto istruzioni nel codice generato come questo può semplificare il processo di generazione e normalmente va bene perché nessuno leggerà (o modificherà) il codice generato e non c'è possibilità che vengano commessi errori perché una macchina sta facendo la scrittura.

Vedere la dichiarazione Go-to considerata dannosa per un argomento contro gotononché un classico pezzo di storia della programmazione.

Il processore implementa almeno un'istruzione di salto e sono sicuro che molte istruzioni usano quelle nella loro implementazione o interpretazione.

Uno degli aspetti positivi dell'utilizzo di un linguaggio di terza o quarta generazione è che questi dettagli fisici vengono astratti da noi. Sebbene dovremmo essere consapevoli della legge dell'astrazione leaky, penso che dovremmo anche usare i nostri strumenti come sono previsti ( scusa ). Se stessi scrivendo codice e mi gotosembrasse una buona idea, sarebbe il momento di eseguire il refactoring. Lo scopo di un linguaggio strutturato è evitare questi "salti" e creare un flusso logico nella nostra ingegneria.

Dovrei evitare l'uso di, breakma non posso trascurare il vantaggio in termini di prestazioni. Tuttavia, se ho loop annidati che ne hanno bisogno reciprocamente break, è tempo di refactoring.

Se qualcuno può proporre un uso gotoche sembra migliore del refactoring, ritirare volentieri la mia risposta.

Spero di non essere colpevole di essere corso al " deposito delle biciclette " qui. Come dice Kragen, ciò che è abbastanza buono per Dijkstra è abbastanza buono per me.

Goto non è mai migliore. E continuare, interrompere (eccetto in caso di cambio / caso), ritorno (multiplo) e lancio dovrebbero essere mantenuti al minimo. Non vuoi mai scappare dal centro dei loop del nido. Vuoi sempre che le istruzioni di controllo del ciclo abbiano tutto il controllo del ciclo. Il rientro contiene informazioni e tutte queste affermazioni gettano via quelle informazioni. Potresti anche eliminare tutti i rientri.