¿Alguien todavía usa [goto] en C # y si es así por qué? [cerrado]

Me preguntaba si alguien todavía usa la sintaxis de la palabra clave "goto" en C # y qué posibles razones existen para hacerlo.

Tiendo a ver cualquier declaración que haga que el lector salte el código como una mala práctica, pero me preguntaba si había escenarios creíbles para usar tal sintaxis.

Ir a definición de palabra clave

Hay algunos casos (raros) en los que goto puede mejorar la legibilidad. De hecho, la documentación a la que vinculó enumera dos ejemplos:

Un uso común de goto es transferir el control a una etiqueta de caja de interruptor específica o la etiqueta predeterminada en una declaración de interruptor.

La instrucción goto también es útil para salir de bucles profundamente anidados.

Aquí hay un ejemplo para el último:

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

end_of_loop:

Por supuesto, también hay otras formas de solucionar este problema, como refactorizar el código en una función, usar un bloque ficticio a su alrededor, etc. (consulte esta pregunta para obtener más detalles). Como nota al margen, los diseñadores del lenguaje Java decidieron prohibir goto por completo e introducir una declaración de ruptura etiquetada en su lugar.

Recuerdo esta 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 algo como esto

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

Refiera esto

Lo uso extensamente en Eduasync para mostrar el tipo de código que el compilador genera para usted cuando usa métodos asíncronos en C # 5. Vería lo mismo en bloques iteradores.

Sin embargo, en el código "normal", no recuerdo la última vez que lo usé ...

goto es genial para romper muchos bucles donde break no funcionaría bien (digamos en condiciones de error), y como Kragen dijo, el compilador usa goto para generar declaraciones de cambio y algunas otras cosas también.

No recuerdo haber usado nunca goto. Pero tal vez mejore la intención de un bucle para siempre del que realmente nunca querrás salir (no break, pero aún puedes returno throw):

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

Por otra parte, un simple while (true)debería ser suficiente ...

Además, puede usarlo en una situación en la que desee que la primera iteración de un bucle comience en el medio del bucle: busque aquí un ejemplo.

El compilador usa gotodeclaraciones en varias piezas de código generado, por ejemplo, en tipos de bloques de iteradores generados (generados cuando se usa la yield returnpalabra clave; estoy bastante seguro de que los tipos de serialización XML generados también tienen algunas gotodeclaraciones allí en algún lugar también.

Consulte Detalles de implementación del bloque Iterator: máquinas de estado generadas automáticamente para obtener más detalles sobre por qué / cómo el compilador de C # maneja esto.

Aparte del código generado, no hay una buena razón para usar una gotodeclaración en el código normal; hace que el código sea más difícil de entender y, como resultado, más propenso a errores. Por otro lado, usar gotodeclaraciones en el código generado como este puede simplificar el proceso de generación y normalmente está bien porque nadie va a leer (o modificar) el código generado y no hay posibilidad de que se cometan errores porque una máquina está escribiendo.

Vea la declaración Go-to considerada dañina para un argumento en contra goto, así como una pieza clásica de la historia de la programación.

El procesador implementa al menos una instrucción de salto y estoy seguro de que muchas declaraciones las usan en su implementación o interpretación.

Una de las cosas buenas de usar un lenguaje de tercera o cuarta generación es que estos detalles físicos se abstraen de nosotros. Si bien deberíamos tener en cuenta la ley de la abstracción con fugas , creo que también deberíamos usar nuestras herramientas como están diseñadas (lo siento ). Si estuviera escribiendo código y me gotopareciera una buena idea, sería hora de refactorizar. El propósito de un lenguaje estructurado es evitar estos "saltos" y crear un flujo lógico en nuestra ingeniería.

Debería evitar el uso de, breakpero no puedo pasar por alto el beneficio de rendimiento. Sin embargo, si tengo bucles anidados que se necesitan mutuamente break, es hora de refactorizar.

Si alguien puede proponer un uso de gotoeso que parece mejor que refactorizar, con mucho gusto retiraré mi respuesta.

Espero no ser culpable de correr al " cobertizo de bicicletas " aquí. Como dice Kragen, lo que es lo suficientemente bueno para Dijkstra es lo suficientemente bueno para mí.

Goto nunca es mejor. Y continuar, romper (excepto en caso de cambio / caso), retorno (múltiple) y lanzamiento también deben mantenerse al mínimo. Nunca querrás escapar del medio de los bucles del nido. Siempre quiere que las sentencias de control de bucle tengan todo el control de bucle. La sangría tiene información, y todas estas declaraciones desechan esa información. También puede quitar todas las sangrías.