C # Classi i membri dell'istanza rispetto all'enum

Aggiunta alla risposta di Eldritch Conundrum (poiché non l'ha aggiornata):

In C#, enums can be declared in the same places as classes (which can be nested).

In molti casi potresti davvero essere in grado di sostituire Enums
con semplici costanti o classi statiche con costanti pubbliche, ma c'è più di Enum di quanto non sembri.

Intellisense (= completamento automatico in VS, MonoDevelop, ecc ...) fornisce supporto per le enumerazioni, non lo fa per le costanti.

Dovresti utilizzare le enumerazioni per applicare una strong digitazione su parametri, proprietà e valori di ritorno che rappresentano un insieme di valori. L'insieme di valori dovrebbe essere chiuso, non soggetto a cambiamenti costanti.

Puoi estendere le enumerazioni:
Tratto da: link

public enum Duration { Day, Week, Month };

public static class DurationExtensions
{
    public static DateTime From(this Duration duration, DateTime dateTime) 
    {
        switch (duration)
        {
            case Duration.Day:
                return dateTime.AddDays(1);
            case Duration.Week:
                return dateTime.AddDays(7);
            case Duration.Month:
                return dateTime.AddMonths(1);
            default:
                throw new ArgumentOutOfRangeException("duration");
        }
    }
}

E ovviamente Enums è utile per i confronti bitwise con l'attributo [Flags] e nelle ultime versioni di .NET hanno un metodo .HasFlag.

Non proprio una risposta, solo alcune informazioni extra.

Per prima cosa ti incoraggio a leggere questo post di piccole dimensioni di Microsoft.

In C #, le enumerazioni non possono avere un comportamento. Se aiuta, puoi pensare alle enumerazioni come membri di una classe speciale in cui le istanze hanno solo nomi ma non metodi [questo è in senso stretto non una visualizzazione corretta].

I membri della classe tuttavia possono avere metodi utili incorporati in essi.

Esempio

public struct Color {
    public static readonly Blue = new Color (0, 0, 255);
    public static readonly Red  = new Color (255, 0, 0);
    //...etc.


    public int GetHue() {
        //Return the hue of the color
    }

    public int GetSimilarityCoefficient(Color another_) {
        //Some really ingenious algo to identify similarity of colors
    }
}

vs.

public enum Color {
    Blue,
    Red,
    Green
} //Cannot do anything much but use if-else/switch-case and make decisions in those blocks

Questo mostra enum in una cattiva luce e quindi viene la domanda -quando usare enum? E quindi arriva una risposta molto personale, anche se spero non largamente respinta,

Personalmente preferisco usare le enumerazioni quando i miei membri hanno solo significati simbolici (cioè sono stati puri) e quando voglio che siano estremamente leggeri e quando voglio assicurarmi che tutte le enumerazioni possano essere prese in considerazione.

Esempio in un modulo con diverse scelte di pulsanti di opzione (diciamo per scegliere quale tipo di copia eseguire),

public enum UserChoice {
    Copy,
    DeepCopy,
    PreviewOnly
}
…
//Somewhere
UserChoice userChoice = form.GetUserChoice();
switch (userChoice) {
    case UserChoice.Copy:
        //Run the copy algorithm
        break;
    case UserChoice.DeepCopy:
        //Run the deep copy algorithm
        break;
    //Forgot to handle PreviewOnly —> gives a compile exception
}

Nota che posso realizzare lo stesso usando anche le variabili di classe:

public class UserChoice {
    public static UserChoice Copy = new UserChoice();
    public static UserChoice DeepCopy = new UserChoice();
    public static UserChoice PreviewOnly = new UserChoice();
}
…
//Then somewhere 
UserChoice userChoice = form.GetUserChoice();
if (userChoice == UserChoice.Copy) {
    //Run the copy algorithm
}
else if (userChoice == UserChoice.DeepCopy) {
    //Run the deep copy algorithm
}
//Forgot to handle preview only. No compile exception.

Inoltre, le enumerazioni possono essere bandiere.

[Flags]
public enum  UserChoice{
    Copy = 0,
    Deep = 1,
    Preview = 2,
    NoActualOp = 4
} //Thus, DeepCopy = Copy | Deep; DeepCopyWithPreview = Copy | Deep | Preview; CopyWithPreviewOnly = Copy | Preview | NoActualOp etc..

Ho intenzione di fare una supposizione selvaggia e andare con l'idea che tu abbia qualcosa di simile:

public class Foo
{
    private int Var1;
    private enum TransmissionType 
    {
         TEXT, HEX
    }

    public void DoesSomething()
    {
        if (somethingIsTrue)
            Var1 = HEX;
        else
            Var1 = TEXT;

        //more code.....
    }

}

In questo caso l'enum viene realmente utilizzato come sostituto per la dichiarazione di due costanti come questa

private const int TEXT = 0;
private const int HEX = 1;

L'enum è solo un tipo privato simile a come è possibile avere una classe privata all'interno di una classe pubblica e / o con ambito interno. D'altra parte, la Var1 sopra è una istanza in ambito privato di un intero (int). .NET (o almeno C # comunque) esegue automaticamente una conversione da un enum a un int per te. Questo è abbastanza comune quando si guarda una classe che è un confine tra codice gestito e non gestito. Il codice gestito in genere avrebbe un enume che userebbe per descrivere il valore / significato della variabile in cui il codice più vecchio / non gestito userebbe tipicamente le costanti.

In C #, le enumerazioni possono essere dichiarate nelle stesse posizioni delle classi (che possono essere annidate).