Right, so first off I am no great fan of having 10,000,000 flags.. But sometimes you run into a situation where you need to pass around a datastructure with ump-teen million flags so you end up turning it into an enum of type flag and doing bitwise OR and AND to to operate on your flags something like
enum Flags
{
FLAG1 = 1,
FLAG2 = 2,
FLAG3 = 4
}
And somewhere in your code you would have
Flags myCurrentVal = Flags.FLAG2;
bool Method HasFlag(Flags enum)
{
return ((enum & myCurrentVal) != 0)
}
Ok sure, that works and it doesn't suck to bad.. but it has limitations.. First off, you can only have 32 or 64 flags (depending on int or long) in your enum.. Not a big deal unless you are doing something like field level security on a very complex form that includes workflow. And frankly while simple to use these things always make some on the team roll there eyes and "Dear god, no more bitwise logic"..
So in an effort to help my flag loving client have flags and my bitwise hating teammates not have to deal with & and | more than they have to I threw togeather an flag class that will support up to Int32.MaxValue flags (not wise, but it would handle it).
So here is the flags base class, its a generic base class that takes an enum in its inherited implementation
public abstract class FlagsBase where T : struct
{
private bool[] _SetFlags;
private int _flagLength;
public int FlagLength
{
get { return _flagLength; }
}
public FlagsBase()
{
Type enumType = typeof(T);
if (enumType.IsEnum)
{
int length = getFlagsLength(enumType);
_SetFlags = new bool[length];
for (int i = 0; i < _SetFlags.Length; i++)
{
_SetFlags[i] = false;
}
_flagLength = length;
}
else
{
throw new ArgumentException("The Generic type of " + typeof(T).ToString() + " is not an enum. This base class only supports enums.");
}
}
protected int GetFlagInt(T flag)
{
return (int)Enum.Parse(typeof(T), flag.ToString());
}
public bool GetFlagValue(T flag)
{
int flagval = GetFlagInt(flag);
if (flagval <= _SetFlags.Length)
{
return _SetFlags[flagval];
}
return false;
}
public void SetFlagValue(T flag, bool newValue)
{
int flagval = GetFlagInt(flag);
if (flagval <= _SetFlags.Length)
{
_SetFlags[flagval] = state;
}
}
public T Flag(int position)
{
return (T)Enum.ToObject(typeof(T), position);
}
private int getFlagsLength(Type enumType)
{
return Enum.GetValues(enumType).Length;
}
}
So what we have here is a generic class that takes an enum as its type. So you make an enum and the length of that enum is used to create a private bool[].. Now each value in the enum becomes a point in the array and has a bool to back it. Easy sleasy as I like to say.
If I want to add new values to my flags set, I just add them to the enum and everything just keeps on working. Here is an example implementation and "use"
enum WebUI_FIELDS
{
field1,
field2,
field3,
field4,
field5,
field6,
field7,
field8,
field9,
field10,
field11,
field12,
field13,
field14,
field15,
field16,
field17,
field18,
field19,
field20,
field21,
field22,
field23,
field24,
field25,
field26,
field27,
field28,
field29,
field30,
field31,
field32,
field33,
field34
}
public class WebUIFieldSecurity : FlagsBase
{
public WebUIFieldSecurity ():base()
{
}
}
And using it may look something like this
void SetupSecurity(IPrincipal user)
{
WebUIFieldSecurity mysec = new WebUIFieldSecurity();
if(user.IsInRole("UseField1"))
{
mysec.SetFlagValue(WebUI_FIELDS.field1,true);
}
SetupPageSecurity(mysec);
}
void SetupPageSecurity(WebUIFieldSecurity sec)
{
field1.ReadOnly = sec.GetFlagValue(WebUI_FIELDS.field1);
field2.ReadOnly = sec.GetFlagValue(WebUI_FIELDS.field2);
field3.ReadOnly = sec.GetFlagValue(WebUI_FIELDS.field3);
field4.ReadOnly = sec.GetFlagValue(WebUI_FIELDS.field4);
}
See how nice and easy that is.. And readable.. Personally I like readable.. and If I need to add more flags, I just grow my enum.. no worring about bit masks, using Hex numbering to set my flags to the right values or being limited to less than 100 flags.. Granted if you need more than 64 flags then things may be a little crazy already. But one never knows, and at least with this you won't care :-).