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

Question

I have a very large set of permissions in my application that I represent with a Flags enumeration. It is quickly approaching the practical upper bound of the long data type. And I am forced to come up with a strategy to transition to a different structure soon. Now, I could break this list down into smaller pieces, however, this is already just a subset of the overall permissions for our application, based on our applications layout. We use this distinction extensively for display purposes when managing permissions and I would rather not have to revisit that code at this time if I can avoid it. Has anybody else run into this issue? How did you get past it? General examples are fine, but I am most interested in a c# specific example if there are any language specific tricks that I can employ to get the job done. May not be neccessary, but here is the list of Permissions currently defined for the portion of the app I am dealing with. ``` //Subgroup WebAgent [Flags] public enum WebAgent…

Accepted Answer

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...
}
```

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

Solution

Problem