Alguém ainda usa [goto] em C # e se sim, por quê? [fechadas]

Eu queria saber se alguém ainda usa a sintaxe de palavra-chave "goto" em C # e quais são as possíveis razões para isso.

Eu tendo a ver quaisquer declarações que façam o leitor pular o código como má prática, mas me pergunto se há algum cenário confiável para o uso de tal sintaxe.

Ir para definição de palavra-chave

Existem alguns casos (raros) em que goto pode realmente melhorar a legibilidade. Na verdade, a documentação à qual você vinculou lista dois exemplos:

Um uso comum de goto é transferir o controle para um rótulo de switch-case específico ou o rótulo padrão em uma instrução switch.

A instrução goto também é útil para sair de loops profundamente aninhados.

Aqui está um exemplo para o último:

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

end_of_loop:

Obviamente, também existem outras maneiras de contornar esse problema, como refatorar o código em uma função, usar um bloco fictício em torno dele, etc. (consulte esta questão para obter detalhes). Como uma observação lateral, os designers da linguagem Java decidiram banir goto completamente e introduzir uma instrução break rotulada .

Eu me lembro dessa 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; 
}

Para algo assim

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

Consulte isto

Eu o uso extensivamente no Eduasync para mostrar o tipo de código que o compilador gera para você ao usar métodos assíncronos em C # 5. Você veria a mesma coisa nos blocos iteradores.

No entanto, em código "normal", não me lembro da última vez que o usei ...

goto é ótimo para quebrar muitos loops onde break não funcionaria bem (digamos em condições de erro), e como Kragen disse, goto é usado pelo compilador para gerar instruções switch e algumas outras coisas também.

Não me lembro de nunca ter usado goto. Mas talvez melhore a intenção de um loop eterno do qual você realmente nunca deseja sair (não break, mas você ainda pode returnou throw):

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

Então, novamente, um simples while (true) deve bastar ...

Além disso, você pode usar em uma situação em que deseja que a primeira iteração de um loop comece no meio do loop: veja aqui um exemplo.

O compilador usa gotoinstruções em várias partes do código gerado, por exemplo, em tipos de blocos iteradores gerados (gerados ao usar a yield returnpalavra-chave - tenho certeza de que os tipos de serialização XML gerados também têm algumas gotoinstruções em algum lugar também.

Consulte os detalhes de implementação do bloco Iterator: máquinas de estado geradas automaticamente para obter mais detalhes sobre por que / como o compilador C # lida com isso.

Além do código gerado, não há um bom motivo para usar uma gotoinstrução no código normal - torna o código mais difícil de entender e, como resultado, mais sujeito a erros. Por outro lado, usandogoto instruções em código gerado como este pode simplificar o processo de geração e normalmente é bom porque ninguém vai ler (ou modificar) o código gerado e não há chance de erros serem cometidos porque uma máquina está fazendo a escrita.

Veja a declaração Go-to considerada prejudicial para um argumento contra goto, bem como um pedaço clássico da história da programação.

O processador implementa pelo menos uma instrução de salto e tenho certeza que muitas instruções as usam em sua implementação ou interpretação.

Uma das coisas boas em usar um idioma de 3ª ou 4ª geração é que esses detalhes físicos são abstraídos de nós. Embora devamos estar atentos à lei da abstração com vazamento , acho que também devemos usar nossas ferramentas da maneira pretendida ( desculpe ). Se eu estivesse escrevendo código e umgoto parecesse uma boa ideia, seria hora de refatorar. O objetivo de uma linguagem estruturada é evitar esses "saltos" e criar um fluxo lógico em nossa engenharia.

Devo evitar o uso de, breakmas não posso ignorar o benefício de desempenho. No entanto, se eu tiver loops aninhados que precisam ser mutuamente break, é hora de refatorar.

Se alguém pode propor o uso de goto que pareça melhor do que refatorar, retirarei minha resposta de bom grado.

Espero não ser culpado de correr para o " galpão de bicicletas " aqui. Como Kragen diz, o que é bom para Dijkstra é bom o suficiente para mim.

Goto nunca é melhor. E continuar, interromper (exceto em interruptor / caso), retorno (múltiplo) e lançamento também devem ser mantidos ao mínimo. Você nunca quer escapar do meio de loops de ninho. Você sempre deseja que as instruções de controle do loop tenham todo o controle do loop. O recuo contém informações, e todas essas afirmações jogam essas informações fora. Você também pode remover todo o recuo.