title: Switch statement without default when dealing with enumerations
body: <p>This has been a pet peeve of mine since I started using .NET but I was curious in case I was missing something. My code snippet won't compile (please forgive the forced nature of the sample) because (according to the compiler) a return statement is missing:</p>
  
  <pre><code>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";
  
              }
          }
      }
  </code></pre>
  
  <p>Now I know I can simply place a default statement to get rid of the complier warning, but to my mind not only is that redundant code, its dangerous code. If the enumeration was in another file and another developer comes along and adds <em>Maybe</em> to my enumeration it would be handled by my default clause which knows nothing about <em>Maybe</em>s and there's a really good chance we're introducing a logic error.</p>
  
  <p>Whereas, if the compiler let me use my code above, it could then identify that we have a problem as my case statement would no longer cover all the values from my enumeration. Sure sounds a lot safer to me.</p>
  
  <p>This is just so fundamentally wrong to me that I want to know if its just something I'm missing, or do we just have to be very careful when we use enumerations in switch statements?</p>
  
  <p><strong>EDIT:</strong>
  I know I can raise exceptions in the default or add a return outside of the switch, but this are still fundamentally hacks to get round a compiler error that shouldn't be an error.</p>
  
  <p>With regards an enum really just being an int, that's one of .NET's dirty little secrets which is quite embarassing really. Let me declare an enumeration with a finite number of possibilities please and give me a compilation for:</p>
  
  <pre><code>Decision fred = (Decision)123;
  </code></pre>
  
  <p>and then throw an exception if somebody tries something like:</p>
  
  <pre><code>int foo = 123;
  Decision fred = (Decision)foo;
  </code></pre>
  
  <p><strong>EDIT 2:</strong></p>
  
  <p>A few people have made comments about what happens when the enum is in a different assembly and how this would result in problems. My point is that this is the behaviour I think should happen. If I change a method signature this will lead to issues, my premis is that changing an enumeration should be this same. I get the impression that a lot of people don't think I understand about enums in .NET. I do I just think that the behaviour is wrong, and I'd hoped  that someone might have known about some very obscure feature that would have altered my opinion about .NET enums. </p>