ansaurus

Question

What to do when bit mask (flags) enum gets too large.

Answer 1

+7 A:

I see values from at least a handful of different enumerations in there...

My first thought was to approach the problem by splitting the permissions up in logical groups (RuleGroupPermissions, RulePermissions, LocationPermissions, ...) and then having a class (WebAgentPermissions) exposing a property for each permission enum type.

Since the permission values seem repetitive, you could probably get away with a single enum in the end:

[Flags]
public enum Permissions
{
    View = 1,
    Add = 2,
    Edit = 4,
    Delete = 8
}

And then have the WebAgentPermissions class expose a property for each area where permissions are to be set;

class WebAgentPermissions
{
    public Permissions RuleGroup { get; set; }
    public Permissions Rule{ get; set; }
    public Permissions Location{ get; set; }
    // and so on...
}

Fredrik Mörk 2009-06-29 21:58:12

I like this, and while they are pretty standard, I think there is enough deviation to make this solution somewhat cumbersome. In the end I think I will just have to suck it up and break this beast up into smaller pieces, and re engineer a few sections of my application to handle the changes. I was just hoping there was a magic bullet out there I hadn't found. Thanks for your time.

Matthew Vines 2009-06-29 22:27:33

Answer 2

A:

Language documentation says:

http://msdn.microsoft.com/en-us/library/system.flagsattribute.aspx

"The underlying type is Int32 and so the maximum single bit flag is 1073741824 and obviously there are a total of 32 flags for each enum."

However... UPDATED:

Commenter is correct. Check out this:

http://msdn.microsoft.com/en-us/library/ms182147(VS.80).aspx

Int32 is only the DEFAULT datatype! In fact you can specify Int64.

public enum MyEnumType : Int64

...allowing up to 64 values. But that certainly seems to be the maximum, after that you're going to be looking at re-engineering. Without knowing too much about the rest of your solution, I can't say exactly what might suit. But an array (or hash-map) of privilege identifiers is probably the most natural approach.

the.jxc 2009-06-29 21:58:28

the quote you posted is from a commenter, and I believe he is incorrect. The Flag attribute does not specify any type information at all. Though enums are Int32 by default if you do not explicitly specify a type.

Matthew Vines 2009-06-29 22:23:37

Answer 3

+2 A:

In C#, one flexible way to represent a value that is sort of an enumeration but more flexible is to represent it as a static class with precooked values available, like this:

public sealed class WebAgentPermission
{
    private long ID;

    public static readonly WebAgentPermission
        ViewRuleGroup = new WebAgentPermission { ID = 1 };
    public static readonly WebAgentPermission
        AddRuleGroup  = new WebAgentPermission { ID = 2 };

    private WebAgentPermission() { } 

    // considerations: override equals/gethashcode, probably override tostring,
    // maybe implicit cast to/from long, maybe other stuff
}

Alternatively, just split the thing up; it looks like you could, if you really tried.

mquander 2009-06-29 21:59:08

This is a decent way to look at this problem as well, and not one I had considered until now. Thanks for your input.

Matthew Vines 2009-06-29 22:29:00

Answer 4

A:

I have not been in this situation.

Here is what I think, create separate enums for each of the category & accept those as parameters.

RuleGroupPermission
    None = 0
    ViewRuleGroup = 1,
    AddRuleGroup = 2,
    EditRuleGroup = 4,
    DeleteRuleGroup = 8,

LocationOperations
    None = 0
    Add = 1
    View = 2
    Delete = 4

void setPermission(RuleGroupPermission ruleGroupOpsAllowed, LocationOperations locationOptions)
{
   ...
}

EDIT: Look at how messagebox.show does it. OK, OKCancel separated from Question, Information, Exclamation.

shahkalpesh 2009-06-29 22:02:07

Answer 5

+1 A:

If I were in control of this application, I would probably come up with a common set of permissions (View, Add, Edit, Delete, Upload/Import) and a set of resources (Users, Roles, Rules, etc). On the web page find the resource type associated with that page and then check the permissions. Perhaps something like:

Permissions perms = agent.GetPermissions(ResourceType.User);
if((perms & Permissions.View) == Permissions.View) { /* do work */ }

or

Permissions perms = agent.Permissions[ResourceType.User];
if((perms & Permissions.View) == Permissions.View) { /* do work */ }

or even

if(agent.IsAuthorized(ResourceType.User, Permissions.View)) { /* do work */ }

You have a couple of permissions that don't make sense with everything else (Assign Permissoins to user, to name one). I'm not sure how I would handle that based on how little I know the problem.

Talljoe 2009-06-29 22:06:42

+1 for your comment above if nothing else, thanks for your time.

Matthew Vines 2009-06-29 22:48:19

Answer 6

+4 A:

You can check BitArray class. Maybe you will use it in future.

arbiter 2009-06-29 23:11:16

This is a good option, but of course you should encapsulate it in a class that gives names to all those bits as some of the other posters suggested.

Doug McClean 2009-06-29 23:13:41

The BitArray class is ideal - define a class with a public enumeration for the permisions (just successive integers starting at 0), and have a query function that just returns the values of the private BitArray member indexed by the permission enumeration). This will handle an arbitrary number of permissions efficiently.

Stephen C. Steel 2009-06-29 23:36:33

ansaurus

tags:

views:

answers:

What to do when bit mask (flags) enum gets too large.

related questions