C# Classes instance members vs. enum

Question

What is the difference between private variables in a clsClass type and using enumeration enum to instantiate the variable. This question arose when I was looking at some C# Class code for serial ports. example: private int SomeClassMember; and private enum TransmissionType{TEXT,HEX} ?

Where do the enum statements appear in a Class definition?

Answer 1

Adding to Eldritch Conundrum's answer (since he has not updated it):

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

In many cases you might indeed be able to replace Enums
by simple constants or static classes with public constants, but there is more to Enums than meets the eye.

Intellisense (= auto completion in VS, MonoDevelop, etc...) provides support for enums, it does not do so for constants.

You should use enums to enforce strong typing on parameters, properties and return values that represent a set of values. The set of values should be closed, not subject to constant change.

You can extend enums:
Taken from: http://damieng.com/blog/2012/10/29/8-things-you-probably-didnt-know-about-csharp

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");
        }
    }
}

And of course Enums are usefull for Bitwise comparisons with the [Flags] attribute and in recent versions of .NET they have a .HasFlag method.

Not really an answer, just some extra info.

Answer 2

I would first encourage you to read this small post by Microsoft.

In C#, enums cannot have a behaviour. If it helps, you can think of enums as members of a special class where instances just have names but no methods [this is strictly speaking not a correct visualization].

Class members however can have useful methods embedded into them.

Example,

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

This shows enums in a bad light and hence comes the question —when to use enums? And thus comes a highly personal, though I hope not widely rejected, answer.

I personally prefer to use enums when my members are supposed to only have token meanings (i.e., they are pure states) and when I want them to be extremely lightweight and when I want to ensure that all enumerations can be accounted for.

Example in a form that has several radio button choices (let's say to choose which type of copy to run),

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
}

Note that I can accomplish the same using class variables too:

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.

Also, enums can be Flags.

[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..

Answer 3

I'm going to take a wild guess and go with the idea that you've got something like this:

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

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

        //more code.....
    }

}

In this case the enum is really being used as a substitute for declaring two constants like this

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

The enum is just a private type similar in how you can have a private class within a public and/or internally scoped class. On the other hand Var1 above is a privately scoped instance of an integer (int). .NET (or at least C# anyhow) performs a conversion from an enum to an int automatically for you. This is fairly common when looking at a class that is a boundary between managed and unmanaged code. The managed code typically would have an enum that it would use to describe the value/meaning of the variable where older/unmanaged code typically would use constants.

Answer 4

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