Enums on steroids

onelopez

Rate me:

4.00/5 (1 vote)

1 Feb 2013CPOL1 min read

8.4K

If enums' could be used OOP style.

Download source code - 1.1 KB

Introduction

This snippet of code allows me to use classes and treat them like enums (to a certain extent). Since it is based on a class type paradigm, this allows me to introduce other properties as well.

Also, I'd like to mention that this is my first article written and published on the web, not much of a blogger, but I do like helping out other fellow coders.

Background

A few months ago I came across this CP article a few months ago and found it quite interesting. So I basically took this code and ran with it.... Or so the expression goes.

Like to thank Cassio Mosqueira for giving me a head start on this enum snippet idea; hope you find it rather useful.

Using the code

Think that using this code is pretty simple and straight forward to use. Since enum style is taking an OOP approach, we must first inherit from Enum<T>.

Like so:

public class UserRole : Enum<UserRole>
{
    public static readonly UserRole
        Guest = new UserRole(0x02, "Guest"),
        User = new UserRole(0x04, "User"),
        Admin = new UserRole(0x0c, "Admin"),
        Super = new UserRole(0x1c, "Super");

    public UserRole(int key, string value) : base(key, value) { }
}

Then we can use something like so

EnumCollection<UserRole> roles = UserRole.GetBaseOrKey(0x1c); // Retrieves a collection of User, Admin, Super
bool isguest = roles == UserRole.Guest;                       // Compare if roles is just Guest
bool isnotguest = roles > UserRole.Guest;                     // Compare if is an authenticated user 
bool isadmin = (roles & UserRole.Admin) == UserRole.Admin;    // Compare if user is admin    
roles = UserRole.Admin;                                       // Role is just admin
string str = roles.ToString(); 
str =  UserRole.Admin.Value; 
str = UserRole.Admin;  
int int32 = UserRole.Admin;

Pretty simple to use.

Points of Interest

Not gonna lie. It was fun coding this. One thing I did not test for was performance, not really sure how well this is going to test out when this is added on a larger project. But for small ones, seems kind of fun.

I have attached the source code and not the solution. Figure you can always just drop it into your project and run with it.

History

2/1 - Original version released.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Written By

onelopez

Software Developer tw telecom holdings

United States

This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.

public sealed class CodeVisibility { [Flags] internal enum CodeVisibilityType { Private = 0, Public = 2, Protected = 4, Internal = 8, Static = 16 } private IntPtr codeVisibilityHandle; public static readonly CodeVisibility Private = new CodeVisibility(0), Public = new CodeVisibility(CodeVisibility.CodeVisibilityType.Public), Protected = new CodeVisibility(CodeVisibility.CodeVisibilityType.Protected), Internal = new CodeVisibility(CodeVisibility.CodeVisibilityType.Internal), Static = new CodeVisibility(CodeVisibility.CodeVisibilityType.Static), ProtectedInternal = CodeVisibility.BitwiseOr(CodeVisibility.Protected, CodeVisibility.Internal), PublicStatic = CodeVisibility.BitwiseOr(CodeVisibility.Public, CodeVisibility.Static), InternalStatic = CodeVisibility.BitwiseOr(CodeVisibility.Internal, CodeVisibility.Static); internal string Name { get { int hashCode = this.GetHashCode(); CodeVisibility.CodeVisibilityType codeVisibilityType = (CodeVisibility.CodeVisibilityType)hashCode; if (int.TryParse(codeVisibilityType.ToString(), out hashCode)) { return null; } string text = codeVisibilityType.ToString().ToLower(); if (text.Contains(",")) { text = text.Replace(",", ""); } return text; } } public IntPtr Handle { get { return this.codeVisibilityHandle; } } internal CodeVisibility(CodeVisibility.CodeVisibilityType codeVisibilityType) { this.codeVisibilityHandle = (IntPtr)((int)codeVisibilityType); } public override int GetHashCode() { return this.Handle.ToInt32(); } public bool Equals(CodeVisibility codeVisibility) { return codeVisibility != null && codeVisibility == this; } public static bool operator ==(CodeVisibility a, CodeVisibility b) { return a.Name == b.Name; } public static bool operator !=(CodeVisibility a, CodeVisibility b) { return !(a == b); } public static bool operator <(CodeVisibility a, CodeVisibility b) { return !(a == b) && a.IsLessThan(b); } public static bool operator <=(CodeVisibility a, CodeVisibility b) { return a == b || a < b; } public static bool operator >(CodeVisibility a, CodeVisibility b) { return !(a == b) && a.IsGreaterThan(b); } public static bool operator >=(CodeVisibility a, CodeVisibility b) { return a == b || a > b; } private bool IsGreaterThan(CodeVisibility codeVisibility) { return !this.IsLessThan(codeVisibility); } private bool IsLessThan(CodeVisibility codeVisibility) { if (codeVisibility == CodeVisibility.PublicStatic) { return true; } if (codeVisibility == CodeVisibility.Public) { return this != CodeVisibility.PublicStatic; } if (codeVisibility == CodeVisibility.Protected) { return this != CodeVisibility.Public && this != CodeVisibility.PublicStatic; } if (codeVisibility == CodeVisibility.ProtectedInternal) { return this != CodeVisibility.Public && this != CodeVisibility.PublicStatic && this != CodeVisibility.Protected; } if (codeVisibility == CodeVisibility.InternalStatic) { return this != CodeVisibility.Public && this != CodeVisibility.PublicStatic && this != CodeVisibility.Protected && this != CodeVisibility.ProtectedInternal; } if (codeVisibility == CodeVisibility.Internal) { return this != CodeVisibility.Public && this != CodeVisibility.PublicStatic && this != CodeVisibility.Protected && this != CodeVisibility.ProtectedInternal && this != CodeVisibility.InternalStatic; } if (codeVisibility == CodeVisibility.Private) { return this != CodeVisibility.Public && this != CodeVisibility.PublicStatic && this != CodeVisibility.Protected && this != CodeVisibility.ProtectedInternal && this != CodeVisibility.InternalStatic && this != CodeVisibility.Internal; } return codeVisibility == CodeVisibility.Static && this != CodeVisibility.Public && this != CodeVisibility.PublicStatic && this != CodeVisibility.Protected && this != CodeVisibility.ProtectedInternal && this != CodeVisibility.InternalStatic && this != CodeVisibility.Internal && this != CodeVisibility.Private; } private static CodeVisibility BitwiseOr(CodeVisibility a, CodeVisibility b) { return new CodeVisibility((CodeVisibility.CodeVisibilityType)(a.GetHashCode() | b.GetHashCode())); } public override bool Equals(object obj) { return obj != null && obj is CodeVisibility && this.Equals((CodeVisibility)obj); } public override string ToString() { string text = base.ToString(); if (this.Name != null) { text = text + " : " + this.Name; } return text; } }

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.