I’m not sure about everyone else, but I just love Enumerated types. What's more, I love the Flags Attribute when you combine them together. This post explores how you can use these two things along with Extension Methods to make your code more compact and easier to understand.
If you’ve never used this combination before, then you’re missing out. Consider the following code…
class User {
bool CanDelete;
bool CanRead;
bool CanWrite;
bool CanModify;
bool CanCreate;
}
Okay, so that’s no big deal even though it may be quite a few extra lines of code. It would be nice to be able to combine all of those permissions into a single value. That’s where an Enumerated Type with a FlagAttribute
comes in.
enum PermissionTypes : int {
None = 0,
Read = 1,
Write = 2,
Modify = 4,
Delete = 8
Create = 16,
All = Read | Write | Modify | Delete | Create
}
class User {
PermissionTypes Permissions = PermissionTypes.None;
}
Excellent…. So Now What?
So now, what's great about this is we can assign multiple values onto the same property. Not only that, we can also check for existing values with a (strange) comparison.
User admin = new User();
admin.Permissions = PermissionTypes.Read
| PermissionTypes.Write
| PermissionTypes.Delete;
bool canRead = ((PermissionTypes.Read & admin.Permissions) == PermissionTypes.Read);
bool canWrite = ((PermissionTypes.Write & admin.Permissions) == PermissionTypes.Write);
bool canCreate = ((PermissionTypes.Create & admin.Permissions) == PermissionTypes.Create);
Console.WriteLine(canRead);
Console.WriteLine(canWrite);
Console.WriteLine(canCreate);
Now shorter and easier to read — sorta. See that really odd comparison? That’s what you need to write each time you want to check for a value. It’s not that bad, but it isn’t really something I’d like to type very often. You could write a separate function to do these comparisons for you, but we can do even better than that.
Taking Advantage of Extension Methods
Since an Enumerated Type isn’t really a class, you can’t extend methods onto them. However, you can extend methods onto the class System.Enum
. Methods added to this class will appear in the methods for all of your enumerated types!
Here is an example method…
public static class EnumerationExtensions {
public static bool Has<T>(this System.Enum type, T value) {
try {
return (((int)(object)type &
(int)(object)value) == (int)(object)value);
}
catch {
return false;
}
}
}
Now, this code does make an assumption that it can cast your Enumerated Type to an integer. You could do some type checking before you do the comparisons, but for the sake of this example, we’re going to keep this short.
So, just how do you use this extension?
PermissionTypes permissions = PermissionTypes.Read | PermissionTypes.Write;
bool canRead = permissions.Has(PermissionTypes.Read);
bool canWrite = permissions.Has(PermissionTypes.Write);
bool canDelete = permissions.Has(PermissionTypes.Delete);
Now, that is much easier to read! Even better, you’ll notice despite the fact this has a Generic parameter, we don’t have to provide the type at the start since the method can infer it from the parameter (implicitly typed parameters — sweeeeet!).
And don’t forget, System.Enum
isn’t the only class you can do this with, there are other classes (like System.Array
, for example) that you can add your own extension methods to for surprising results!
As I stated before, this doesn't cover all cases of what you could expect - this code should be modified depending on how you plan to use it. For example, if you're using long
, uint
, ulong
, this code won't cover all of your cases.
You may also wonder why we cast to an object
before we cast to an int
. When you're working with Generics, you can't cast to a value (non-nullable) type immediately, you have to either cast to an object
and then to a value type, or just cast directly to a nullable value type, such as int
.
Below is the full source code for the EnumerationExtensions
class. If you have any improvements, please let me know! I'm currently working on a revised version to improve this code.
namespace Enum.Extensions {
public static class EnumerationExtensions {
public static bool Has<T>(this System.Enum type, T value) {
try {
return (((int)(object)type & (int)(object)value) == (int)(object)value);
}
catch {
return false;
}
}
public static bool Is<T>(this System.Enum type, T value) {
try {
return (int)(object)type == (int)(object)value;
}
catch {
return false;
}
}
public static T Add<T>(this System.Enum type, T value) {
try {
return (T)(object)(((int)(object)type | (int)(object)value));
}
catch(Exception ex) {
throw new ArgumentException(
string.Format(
"Could not append value from enumerated type '{0}'.",
typeof(T).Name
), ex);
}
}
public static T Remove<T>(this System.Enum type, T value) {
try {
return (T)(object)(((int)(object)type & ~(int)(object)value));
}
catch (Exception ex) {
throw new ArgumentException(
string.Format(
"Could not remove value from enumerated type '{0}'.",
typeof(T).Name
), ex);
}
}
}
}
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.