Esta tem sido uma implicância minha desde que comecei a usar o .net, mas fiquei curioso no caso de estar faltando alguma coisa. Meu trecho de código não irá compilar (por favor, perdoe a natureza forçada do exemplo) porque (de acordo com o compilador) uma declaração de retorno está faltando:

public enum Decision { Yes, No}

    public class Test
    {
        public string GetDecision(Decision decision)
        {
            switch (decision)
            {
                case Decision.Yes:
                    return "Yes, that's my decision";
                case Decision.No:
                    return "No, that's my decision";

            }
        }
    }

Agora eu sei que posso simplesmente colocar uma declaração padrão para me livrar do aviso do complier, mas na minha opinião não é apenas esse código redundante, seu código perigoso. Se a enumeração estava em outro arquivo e outro desenvolvedor aparece e adicionaTalvez a minha enumeração seria tratado pela minha cláusula padrão que não sabe nada sobreTalveze há uma boa chance de introduzirmos um erro lógico.

Por outro lado, se o compilador me permitir usar o código acima, ele poderá identificar que temos um problema, pois minha declaração de caso não cobriria mais todos os valores da minha enumeração. Claro que parece muito mais seguro para mim.

Isto é tão fundamentalmente errado para mim que eu quero saber se é apenas algo que eu estou perdendo, ou nós apenas temos que ter muito cuidado quando usamos enumerações em instruções switch?

EDITAR: Eu sei que posso levantar exceções no padrão ou adicionar um retorno fora do switch, mas isso ainda é fundamentalmente hacks para contornar um erro do compilador que não deve ser um erro.

Com relação a um enum sendo apenas um int, esse é um dos pequenos segredos sujos do .NET, o que é muito constrangedor. Deixe-me declarar uma enumeração com um número finito de possibilidades, por favor e me dê uma compilação para:

Decision fred = (Decision)123;

e depois lançar uma exceção se alguém tentar algo como:

int foo = 123;
Decision fred = (Decision)foo;

EDIT 2:

Algumas pessoas fizeram comentários sobre o que acontece quando o enum está em uma montagem diferente e como isso resultaria em problemas. Meu ponto é que este é o comportamento que eu acho que deveria acontecer. Se eu alterar uma assinatura de método, isso levará a problemas, minha premissa é que alterar uma enumeração deve ser o mesmo. Tenho a impressão de que muitas pessoas não acham que eu entendo sobre enums no .NET. Eu só acho que o comportamento está errado, e eu esperava que alguém pudesse saber sobre algum recurso muito obscuro que teria alterado minha opinião sobre enums .NET.