Enums and Structs in C# [Author:Nishant Sivakumar]

http://www.codeproject.com/KB/cs/csenums01.aspx

Introduction

Just about everything is a heap object when you are using C#. Only elementary  native types like int are treated as value types. But there are two value types  in C# that are pretty much more useful that first glances would tell you. They  are the enum and struct types. Very few tutorials even cover these topics, but  they have their own uses. And both of them are a lot more efficient than classes  and you can use them in place of classes when they meet your requirements to  improve performance.

Enums

Enums are basically a set of named constants. They are declared in C# using  the enum keyword. Every enum type  automatically derives from System.Enum and thus we can use System.Enum methods on our Enums. Enums are value types and are created  on the stack and not on the heap. You don't have to use new  to create an enum type. Declaring an enum  is a little like setting the members of an array as shown below.

Collapse | Copy Code

enum Rating {Poor, Average, Okay, Good, Excellent}

You can pass enums to member functions just as if they were normal objects.  And you can perform arithmetic on enums too. For example we can write two  functions, one to increment our  enum and the other to  decrement our enum.

Collapse | Copy Code

Rating IncrementRating(Rating r)
{
    if(r == Rating.Excellent)
        return r;
    else
        return r+1;
}
Rating DecrementRating(Rating r)
{
    if(r == Rating.Poor)
        return r;
    else
        return r-1;
}

Both functions take a Rating object as argument and return back a Rating  object. Now we can simply call these functions from elsewhere.

Collapse | Copy Code

for (Rating r1 = Rating.Poor; 
    r1 < Rating.Excellent ; 
    r1 = IncrementRating(r1))
{           
    Console.WriteLine(r1);
}

Console.WriteLine();

for (Rating r2 = Rating.Excellent; 
    r2 > Rating.Poor; 
    r2 = DecrementRating(r2))
{
    Console.WriteLine(r2);          
}

And here is a sample code snippet showing how you can call System.Enum methods on our Enum object. We call the GetNames method which retrieves an array of the names of the constants in  the enumeration.

Collapse | Copy Code

foreach(string s in Rating.GetNames(typeof(Rating)))
    Console.WriteLine(s);

Where to use enums

Quite often we have situations where a class method takes as an argument a  custom option. Let's say we have some kind of file access class and there is a  file open method that has a parameter that might be one of read-mode,  write-mode, read-write-mode, create-mode and append-mode. Now you might think of  adding five static member fields to your class for these modes. Wrong approach!  Declare and use an enumeration which is a whole lot more efficient and is better  programming practice in my opinion.

Structs

In C++ a struct is just about the same as a class for  all purposes except in the default access modifier for methods. In C# a struct are a pale puny version of a class. I am not  sure why this was done so, but perhaps they decided to have a clear distinction  between structs and classes. Here are some of the drastic areas where classes  and structs differ in functionality.

• structs are stack objects and however much you try you cannot create them   on the heap
• structs cannot inherit from other structs though they can derive from   interfaces
• You cannot declare a default constructor for a struct,   your constructors must have parameters
• The constructor is called only if you create your struct   using new, if you simply declare the struct   just as in  declaring a native type like int, you   must explicitly set each member's value before you can use the struct

Collapse | Copy Code

struct Student : IGrade
{   
    public int maths;
    public int english;
    public int csharp;

    //public member function

    public int GetTot()
    {
        return maths+english+csharp;
    }

    //We have a constructor that takes an int as argument

    public Student(int y)
    {
        maths = english = csharp = y;
    }

    //This method is implemented because we derive

    //from the IGrade interface

    public string GetGrade()
    {
        if(GetTot() > 240 )
            return "Brilliant";
        if(GetTot() > 140 )
            return "Passed";
        return "Failed";
    }
}

interface IGrade
{
    string GetGrade();
}

Well, now let's take a look at how we can use our struct.

Collapse | Copy Code

Student s1 = new Student();
Console.WriteLine(s1.GetTot());
Console.WriteLine(s1.GetGrade());

//Output

0
Failed

Here the default constructor gets called. This is automatically implemented  for us and we cannot have our own default parameter-less constructor. The  default parameter-less constructor simply initializes all values to their  zero-equivalents. This is why we get a 0 as the total.

Collapse | Copy Code

Student s2;
s2.maths = s2.english = s2.csharp = 50;
Console.WriteLine(s2.GetTot());
Console.WriteLine(s2.GetGrade());

//Output

150
Passed

Because we haven't used new, the constructor does not get called. Of all the  silly features this one must win the annual contest by a long way. I see no sane  reason why this must be so. Anyway you have to initialize all the member fields.  If you comment out the line that does the initialization you will get a compiler  error :- Use of unassigned local variable 's2'

Collapse | Copy Code

Student s3 = new Student(90);
Console.WriteLine(s3.GetTot());
Console.WriteLine(s3.GetGrade());

//Output

270
Brilliant

This time we use our custom constructor that takes an int  as argument.

When to use structs

Because structs are value types they would be easier to handle and more  efficient that classes. When you find that you are using a class mostly for  storing a set of values, you must replace those classes with structs. When you  declare arrays of structs because they are created on the heap, efficiency again  improves. Because if they were classes each class object would need to have  memory allocated on the heap and their references would be stored. In fact lots  of classes within the .NET framework are actually structs. For example System.Drawing.Point is actually a struct and not a class.