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.
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
.
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.
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.
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
struct Student : IGrade
{
public int maths;
public int english;
public int csharp;
public int GetTot()
{
return maths+english+csharp;
}
public Student(int y)
{
maths = english = csharp = y;
}
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
.
Student s1 = new Student();
Console.WriteLine(s1.GetTot());
Console.WriteLine(s1.GetGrade());
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.
Student s2;
s2.maths = s2.english = s2.csharp = 50;
Console.WriteLine(s2.GetTot());
Console.WriteLine(s2.GetGrade());
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'
Student s3 = new Student(90);
Console.WriteLine(s3.GetTot());
Console.WriteLine(s3.GetGrade());
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
.