What are the properties of enumerations we want to be able
to replicate?
·
Strongly typed access
·
Unchanging at runtime
·
Name and value pairing
·
Customizable values
·
Conversion to integers
·
Get by value
·
Get by name
·
List all
So in order to replace our enumeration we are going to need
to include these. Since we are using objects, the first one should be easily
done. Our object will need to have at least two properties for the Name and the
Value. So if we were just going to create a regular object we would have
something like this.
Listing 3: Normal Object
public class MyObject
{
public int Id { get; set; }
public string Name { get; set; }
}With this object we could create instances of it at runtime,
but this is not what we want yet. The next step is making sure that we have a
set of instances to start with and no more can be created. To do this we will
make out constructor private. With the constructor private, we will need to
declare the instances of this object inside the class, so the instances will
need to be static. We will need to make sure that all of the values can be
passed into the constructor so the instances can be created easily as static
properties of the class This has the nice effect of allowing us to access them
using ClassName.InstanceName. That naming convention
will look similar to the one for enumerations which is Enumname.InstanceName.
Our new code which uses static instances and a private
constructor looks like this.
Listing 4: Static Instances and Private Constructor
public class MyObject
{
public static MyObject MyObjectOne = new MyObject(1, "MyObjectOne");
public static MyObject MyObjectTwo = new MyObject(2, "MyObjectTwo");
public static MyObject MyObjectThree = new MyObject(3, "MyObjectThree");
public int Id { get; private set; }
public string Name { get; private set; }
private MyObject(int id, string name)
{
Id = id;
Name = name;
}
}This object will already do a lot of what we need. It
maintains a limited set, is strongly typed, has a name, has a value, you have
control over the values for each, and the Id property lets you have it as an
integer. Now we need to be able to get these based on the Id and the Name, and
we also need to maintain a list of them.
Listing all of the values is useful for displaying them in
different places such as a DropDownList or something similar.
Listing 5: Listing All of the Instances
public static List<MyObject> ListAll()
{
return new List<MyObject>
{
MyObjectOne,
MyObjectTwo,
MyObjectThree
};
}For this it is pretty easy to just put them in a list like
this or something similar. Not too difficult to maintain, it gives you good
control of what is in the list.
Getting the instance of the object by Id and by Name is also
pretty easy. With very little effort we are able to get them, and we throw some
exceptions if we receive invalid method arguments.
Listing 6: FromId and FromName
public static MyObject FromId(int id)
{
List<MyObject> items = ListAll();
MyObject match = Array.Find(items.ToArray(), instance => instance.Id == id);
if (match == null)
{
throw new ArgumentOutOfRangeException(string.Format(
"Id '{0}' is invalid for {1}", id, typeof(MyObject).Name));
}
return match;
}
public static MyObject FromName(string name)
{
List<MyObject> items = ListAll();
MyObject match = Array.Find(items.ToArray(), instance => instance.Name == name);
if (match == null)
{
throw new ArgumentOutOfRangeException(string.Format(
"Name '{0}' is not a valid {1}", name, typeof(MyObject).Name));
}
return match;
}At this point our object does pretty much everything we want
it to do. This class is fairly testable, and is designed in such a way that we
can add extra information to it. We can also add extra properties for any
attributes we want like descriptions.
