Enum VS Classe statica (normale e con valori di stringa)

Question

Sono stato sviluppato per Windows Mobile e Android per qualche tempo. E sono confuso riguardo questi due concetti.

Diciamo che voglio prendere una decisione in base ad alcune dimensioni dello schermo del dispositivo dell'utente. Quindi mi aspetterò valori così predefiniti. Potrei usare un'istruzione switch per gestire la mia logica. Ma non sono sicuro se dovrei usare Enum di una classe statica per questo scopo. Quale è un approccio migliore. Posso fare la mia logica in questi due modi diversi. Qual è l'approccio corretto? Non ho capito bene. E posso anche usare i valori di stringa? Perché al momento sto seguendo le lezioni, ho bisogno di aggiornare per usare tutte le enumerazioni. Quindi, come posso cambiare la mia classe in String Enum? Comunque. Grazie.

Utilizzando Enum

//My predefined values 
public enum ScreenSizeEnum 
{ 
    Small, Medium, Large, XLarge, 
} 
//Handling Logic 
private void SetScreenSize(ScreenSizeEnum Screen) 
{ 
    switch (Screen) 
    { 
     case ScreenSizeEnum.Large: 
      //Do Logic 
      break; 
     case ScreenSizeEnum.Small: 
      //Do Logic 
      break; 
    } 
} 

Utilizzando Classe

//My predefined values 
public class ScreenSizeClass 
{ 
    public const int Small = 0; 
    public const int Medium = 1; 
    public const int Large = 2; 
    public const int XLarge = 3; 
} 
//Handling Logic 
private void SetScreenSize(int Screen) 
{ 
    switch (Screen) 
    { 
     case ScreenSizeClass.Large: 
      //Do Logic 
      break; 
     case ScreenSizeClass.Small: 
      //Do Logic 
      break; 
    } 
} 

Answer 1

Da Enumeration Types (C# Programming Guide):

Tipo di elencazione (anche chiamato un'enumerazione o di un enum) fornisce una modo efficiente per definire un insieme di costanti integrali con nome che possono essere assegnate a una variabile.

I seguenti sono i vantaggi dell'utilizzo di un enum invece di un numerica tipo:

1. È chiaramente specificati per codice client che i valori validi per la variabile.

2. In Visual Studio, IntelliSense elenca i valori definiti.

Quindi, se si passa enum, si è fortemente tipizzato, in modo da ottenere automaticamente il controllo su ciò che si può passare in un metodo.

ScreenSizeEnum size = ScreenSizeEnum.Medium; 
SetScreenSize(size); 

Quando si utilizza const o static campi che sicuramente bisogno di controllare se il int valore passato è preso dal diapason previsto.

int somevalue = ...;//anything 
SetScreenSize(somevalue); //compiles 

private void SetScreenSize(int Screen) 
{ 
    switch (Screen) 
    { 
     case ScreenSizeClass.Large: 
      //Do Logic 
      break; 
     case ScreenSizeClass.Small: 
      //Do Logic 
      break; 
     default: 
      // something else, what to do?? 
      break; 
    } 
} 

---

Sulla base di commenti:

Se è necessario verificare, se alcuni int è definito in enum, si può fare qualcosa di simile:

int somevallue = 0; 
if(Enum.IsDefined(typeof(ScreenSizeEnum), somevallue)) 
{ 
    //it's ok 
} 

O un metodo di estensione:

public static T GetEnumValue<T>(this string value) where T : struct 
{ 
    Type t = typeof(T); 
    if (!t.IsEnum) 
     throw new Exception("T must be an enum"); 
    else 
    { 
     T result; 
     if (Enum.TryParse<T>(value, out result)) 
      return result; 
     else 
      return default(T); 
    } 
} 

che potrebbe essere utilizzato

int somevalue = 1; 
ScreenSizeEnum size = somevalue.GetEnumValue<ScreenSizeEnum>(); 

---

Per quanto riguarda il string (sulla base degli domanda Edited PO):

Da enum (C# Reference):

I tipi approvati per un enum sono byte, sbyte, short, ushort, int, uint, long o ulong.

Quindi non si può avere un enum di archi. Ma puoi usare nomi da enumerazioni, poiché il metodo ToString restituisce il nome, non il valore dell'enumerazione.

ScreenSizeEnum.Small.ToString(); //Small 

in modo da poter avere un altro metodo di estensione sulle stringhe:

public static T GetEnumValue<T>(this string value) where T : struct 
{ 
    Type t = typeof(T); 
    if (!t.IsEnum) 
     throw new Exception("T must be an enum"); 
    else 
    { 
     if (Enum.IsDefined(t, value)) 
      return (T)Enum.Parse(t, value); 
     else 
      return default(T); 
    } 
} 

Così che

int i = (int)ScreenSizeEnum.Small; 
string str = ScreenSizeEnum.Small.ToString(); 
ScreenSizeEnum isize = i.GetEnumValue<ScreenSizeEnum>();//ScreenSizeEnum.Small 
ScreenSizeEnum strsize = str.GetEnumValue<ScreenSizeEnum>();//ScreenSizeEnum.Small 

Answer 2

Questo è esattamente ciò che le enumerazioni ci sono per. Non che non è possibile utilizzare la classe statica con le costanti, ma enum è di gran lunga più pulito ...

Answer 3

enumerazioni sono essenzialmente utilizzati quando si desidera una variabile o un parametro di avere valore da un fisso insieme di possibili costanti. È possibile sostituire l'enumerazione con la classe con un insieme di costanti int finali finali statiche. Ma l'uso di enumerazione è più flessibile di una lettura leggibile di &.