C# Wyliczenia i powielone wartości - niebezpieczeństwa?

Question

Zastanawiam się nad wyliczeniami C# i co dzieje się z duplikatami wartości. I stworzył następującą mały program do testowania rzeczy:

namespace ConsoleTest 
{ 

    enum TestEnum 
    { 
     FirstElement = -1, 
     SecondElement, 
     ThirdElement, 
     Duplicate = FirstElement 
    } 

    /// <summary> 
    /// Summary description for MainConsole. 
    /// </summary> 
    public class MainConsole 
    { 
     /// <summary> 
     /// Constructor for the class. 
     /// </summary> 
     public MainConsole() 
     { 
      // 
      // TODO: Add constructor logic here 
      // 
     } 
     /// <summary> 
     /// Entry point for the application. 
     /// </summary> 
     /// <param name="args">Arguments to the application</param> 
     public static void Main(string[] args) 
     { 
      TestEnum first = TestEnum.FirstElement; 
      TestEnum second = TestEnum.SecondElement; 
      TestEnum duplicate = TestEnum.Duplicate; 

      foreach (string str in Enum.GetNames(typeof(TestEnum))) 
      { 
       Console.WriteLine("Name is: " + str); 
      } 

      Console.WriteLine("first string is: " + first.ToString()); 
      Console.WriteLine("value is: " + ((int)first).ToString()); 
      Console.WriteLine("second string is: " + second.ToString()); 
      Console.WriteLine("value is: " + ((int)second).ToString()); 
      Console.WriteLine("duplicate string is: " + duplicate.ToString()); 
      Console.WriteLine("value is: " + ((int)duplicate).ToString()); 

      TestEnum fromStr = (TestEnum)Enum.Parse(typeof(TestEnum), "duplicate", true); 
      Console.WriteLine("fromstr string is: " + fromStr.ToString()); 
      Console.WriteLine("value is: " + ((int)fromStr).ToString()); 
      if (fromStr == TestEnum.Duplicate) 
      { 
       Console.WriteLine("Duplicate compares the same as FirstElement"); 
      } 
      else 
      { 
       Console.WriteLine("Duplicate does NOT compare the same as FirstElement"); 
      } 

     } 
    } 
} 

która produkuje następujące dane wyjściowe:

Name is: SecondElement 
Name is: ThirdElement 
Name is: FirstElement 
Name is: Duplicate 
first string is: FirstElement 
value is: -1 
second string is: SecondElement 
value is: 0 
duplicate string is: FirstElement 
value is: -1 
fromstr string is: FirstElement 
value is: -1 
Duplicate compares the same as FirstElement 
Press any key to continue . . . 

to wydaje się być dokładnie tym, czego chcą i oczekują, ponieważ jestem konstruowaniem czegoś, że wersja Tag będzie się zwiększał co jakiś czas, więc chcę coś, co mogę "przydzielić" do aktualnej wersji, a nawet porównać z nią.

Oto jednak pytanie: jakie są pułapki tego podejścia? Czy jest jeden? Czy to po prostu zły styl (nie chcę skończyć na thedailywtf)? Czy jest o wiele lepszy sposób robienia czegoś takiego? Jestem na .NET 2.0 i NIE mam opcji, aby przejść do 3.5 lub 4.0.

Opinie są mile widziane.

Answer 1

Nie jest jasne, co próbujesz osiągnąć, ale nie wygląda mi to dobrze. Dodanie kolejnego wpisu do wyliczenia po "Duplikowaniu" na przykład przyjmie wartość 0, chyba że ponownie ustawisz wartość ponownie.

Answer 2

Nie widzę w tym nic złego, aw rzeczywistości robię to samo przy okazji. Są chwile, kiedy metoda (szczególnie natywne P/Invoke do APi, które rosło w czasie) może przyjmować te same wartości liczbowe, ale mają na myśli coś innego, więc lubię mieć nazwę wartości wyliczeniowej, która opisuje użycie.

Answer 3

Podanie wartości wyliczenia aliasu może być przydatne w przypadku wyliczenia flag. Na przykład.

[Flags] 
enum Rows { 
    Even = 0x01, 
    Odd = = 0x02, 
    All = Even | Odd 
} 

Jeśli jednak zapoznać się ze wskazówkami dla teksty stałe w ramowych wytycznych projektowych przez Cwalina i Abrams znajdziesz następujące informacje:

NIE korzystania enum dla zbiorów otwartych (takie jak wersja systemu operacyjnego, nazwiska znajomych itp.).

i

NIE zawierać wartości wskaźnikowych w teksty stałe.

Posiadanie aktualnej wersji jest wartością wartownika.

Niniejsze wytyczne dotyczą projektowania ram i jeśli po prostu chcesz użyć enum w swojej aplikacji, nie ma znaczenia, czy złamiesz te wytyczne. Jednak Microsoft opracował te wytyczne, aby uniknąć typowych pułapek, gdy inni deweloperzy muszą używać Twojego kodu.