当位掩码（标志）枚举变得太大时该怎么办
Posted
技术标签:
【中文标题】当位掩码（标志）枚举变得太大时该怎么办【英文标题】：What to do when bit mask (flags) enum gets too large 【发布时间】：2010-11-06 20:11:24 【问题描述】：我的应用程序中有大量权限，我用 Flags 枚举表示。它正在迅速接近长数据类型的实际上限。我不得不想出一个策略来尽快过渡到不同的结构。现在，我可以将这个列表分解成更小的部分，但是，这已经只是我们应用程序整体权限的一个子集，基于我们的应用程序布局。在管理权限时，我们将这种区别广泛用于显示目的，如果可以避免的话，我宁愿此时不必重新访问该代码。
还有其他人遇到过这个问题吗？你是怎么过去的？一般的例子很好，但如果有任何语言特定的技巧可以用来完成工作，我最感兴趣的是 c# 特定的例子。
可能不是必需的，但这里是当前为我正在处理的应用程序部分定义的权限列表。
//Subgroup WebAgent
[Flags]
public enum WebAgentPermission : long
[DescriptionAttribute("View Rule Group")]
ViewRuleGroup = 1,
[DescriptionAttribute("Add Rule Group")]
AddRuleGroup = 2,
[DescriptionAttribute("Edit Rule Group")]
EditRuleGroup = 4,
[DescriptionAttribute("Delete Rule Group")]
DeleteRuleGroup = 8,
[DescriptionAttribute("View Rule")]
ViewRule = 16,
[DescriptionAttribute("Add Rule")]
AddRule = 32,
[DescriptionAttribute("Edit Rule")]
EditRule = 64,
[DescriptionAttribute("Delete Rule")]
DeleteRule = 128,
[DescriptionAttribute("View Location")]
ViewLocation = 256,
[DescriptionAttribute("Add Location")]
AddLocation = 512,
[DescriptionAttribute("Edit Location")]
EditLocation = 1024,
[DescriptionAttribute("Delete Location")]
DeleteLocation = 2048,
[DescriptionAttribute("View Volume Statistics")]
ViewVolumeStatistics = 4096,
[DescriptionAttribute("Edit Volume Statistics")]
EditVolumeStatistics = 8192,
[DescriptionAttribute("Upload Volume Statistics")]
UploadVolumeStatistics = 16384,
[DescriptionAttribute("View Role")]
ViewRole = 32768,
[DescriptionAttribute("Add Role")]
AddRole = 65536,
[DescriptionAttribute("Edit Role")]
EditRole = 131072,
[DescriptionAttribute("Delete Role")]
DeleteRole = 262144,
[DescriptionAttribute("View User")]
ViewUser = 524288,
[DescriptionAttribute("Add User")]
AddUser = 1048576,
[DescriptionAttribute("Edit User")]
EditUser = 2097152,
[DescriptionAttribute("Delete User")]
DeleteUser = 4194304,
[DescriptionAttribute("Assign Permissions To User")]
AssignPermissionsToUser = 8388608,
[DescriptionAttribute("Change User Password")]
ChangeUserPassword = 16777216,
[DescriptionAttribute("View Audit Logs")]
ViewAuditLogs = 33554432,
[DescriptionAttribute("View Team")]
ViewTeam = 67108864,
[DescriptionAttribute("Add Team")]
AddTeam = 134217728,
[DescriptionAttribute("Edit Team")]
EditTeam = 268435456,
[DescriptionAttribute("Delete Team")]
DeleteTeam = 536870912,
[DescriptionAttribute("View Web Agent Reports")]
ViewWebAgentReports = 1073741824,
[DescriptionAttribute("View All Locations")]
ViewAllLocations = 2147483648,
[DescriptionAttribute("Access to My Search")]
AccessToMySearch = 4294967296,
[DescriptionAttribute("Access to Pespective Search")]
AccessToPespectiveSearch = 8589934592,
[DescriptionAttribute("Add Pespective Search")]
AddPespectiveSearch = 17179869184,
[DescriptionAttribute("Edit Pespective Search")]
EditPespectiveSearch = 34359738368,
[DescriptionAttribute("Delete Pespective Search")]
DeletePespectiveSearch = 68719476736,
[DescriptionAttribute("Access to Search")]
AccessToSearch = 137438953472,
[DescriptionAttribute("View Form Roles")]
ViewFormRole = 274877906944,
[DescriptionAttribute("Add / Edit Form Roles")]
AddFormRole = 549755813888,
[DescriptionAttribute("Delete UserFormRolesDifferenceMasks")]
DeleteFormRole = 1099511627776,
[DescriptionAttribute("Export Locations")]
ExportLocations = 2199023255552,
[DescriptionAttribute("Import Locations")]
ImportLocations = 4398046511104,
[DescriptionAttribute("Manage Location Levels")]
ManageLocationLevels = 8796093022208,
[DescriptionAttribute("View Job Title")]
ViewJobTitle = 17592186044416,
[DescriptionAttribute("Add Job Title")]
AddJobTitle = 35184372088832,
[DescriptionAttribute("Edit Job Title")]
EditJobTitle = 70368744177664,
[DescriptionAttribute("Delete Job Title")]
DeleteJobTitle = 140737488355328,
[DescriptionAttribute("View Dictionary Manager")]
ViewDictionaryManager = 281474976710656,
[DescriptionAttribute("Add Dictionary Manager")]
AddDictionaryManager = 562949953421312,
[DescriptionAttribute("Edit Dictionary Manager")]
EditDictionaryManager = 1125899906842624,
[DescriptionAttribute("Delete Dictionary Manager")]
DeleteDictionaryManager = 2251799813685248,
[DescriptionAttribute("View Choice Manager")]
ViewChoiceManager = 4503599627370496,
[DescriptionAttribute("Add Choice Manager")]
AddChoiceManager = 9007199254740992,
[DescriptionAttribute("Edit Chioce Manager")]
EditChoiceManager = 18014398509481984,
[DescriptionAttribute("Delete Choice Manager")]
DeleteChoiceManager = 36028797018963968,
[DescriptionAttribute("Import Export Choices")] //57
ImportExportChoices = 72057594037927936
【问题讨论】：
为了清楚起见，我通常使用：(1 谢谢，我尝试了几种方法来做类似的事情，但我总是得到不能使用枚举错误的计算值。 我认为 ^ 并不像你认为的那样。 如果你想做一个长位移，告诉编译器这就是你想要的。 (1L 好吧，解释一下，这就是我匆忙完成的结果，再次感谢您指出我所做的一些愚蠢的事情:) 【参考方案1】：我在其中至少看到了一些不同枚举的值...
我的第一个想法是通过将权限拆分为逻辑组（RuleGroupPermissions、RulePermissions、LocationPermissions、...），然后让一个类（WebAgentPermissions）公开一个属性来解决这个问题对于每个权限枚举类型。
由于权限值似乎是重复的，因此您最终可能会使用单个枚举：
[Flags]
public enum Permissions
View = 1,
Add = 2,
Edit = 4,
Delete = 8
然后让WebAgentPermissions 类为要设置权限的每个区域公开一个属性；
class WebAgentPermissions
public Permissions RuleGroup get; set;
public Permissions Rule get; set;
public Permissions Location get; set;
// and so on...
【讨论】：
我喜欢这个，虽然它们很标准，但我认为有足够的偏差使这个解决方案有些麻烦。最后，我认为我只需要收拾它并将这个野兽分解成更小的部分，然后重新设计我的应用程序的几个部分来处理这些更改。我只是希望那里有一颗我没有找到的灵丹妙药。感谢您的宝贵时间。 在这种情况下这是一个很好的解决方案。不幸的是，它没有给出处理类似问题的通用方法，除了“尝试将其拆分为枚举含义的最佳”。 如果您可能的操作不仅仅是 CRUD，这会变得很棘手，您可能需要多个权限枚举。我也无法想象尝试将所有这些存储到数据库中，每次需要用户权限时，您都会加入大量表。【参考方案2】：语言文档说：
http://msdn.microsoft.com/en-us/library/system.flagsattribute.aspx
“底层类型是 Int32，因此最大单个位标志是 1073741824，显然每个枚举总共有 32 个标志。”
但是...更新：
评论者是正确的。看看这个：
http://msdn.microsoft.com/en-us/library/ms182147(VS.80).aspx
Int32 只是 DEFAULT 数据类型！事实上你可以指定 Int64。
public enum MyEnumType : Int64
...最多允许 64 个值。但这似乎是最大的，在那之后你将考虑重新设计。在不了解您的解决方案的其余部分的情况下，我无法确切地说出什么适合。但是特权标识符的数组（或哈希映射）可能是最自然的方法。
【讨论】：
您发布的报价来自评论者，我认为他是不正确的。 Flag 属性根本没有指定任何类型信息。虽然如果你没有明确指定类型，枚举默认是 Int32。 这个答案中引用的引用似乎不再出现在它的来源页面上。 @MatthewVines 指定了public enum WebAgentPermission : long，这与使用Int64 相同
@leigero 这对我来说是设计的味道。也许考虑打破这些价值观或改变结构？例如，如果它是为了权限，也许可以考虑使用声明，除非有特殊原因为此结构使用二进制文件。即使你必须使用二进制，你仍然可以跨多个字段执行按位运算（例如((p.group | p.location) & MY_PERMISSION) == MY_PERMISSION）你知道吗？
提示：当使用 enum MyEnumType : Int64 和移位运算符时：[Flags] public enum MyEnumFlags : Int64 None = 0, A = 1 << 0, B = 1 << 1, C = 1 << 2, ...etc... 一定要使用 1L A = 1L << 0, B = 1L << 1, 告诉编译器 1 是 long/Int64 .否则，它将其解释为 int32，并在第 32 次从 1 重新开始，为其他枚举名称提供双倍值。【参考方案3】：
你可以查看BitArray类。也许你以后会用到它。
【讨论】：
这是一个不错的选择，但是您当然应该将它封装在一个类中，该类为所有这些位命名，正如其他一些海报所建议的那样。 BitArray 类是理想的 - 定义一个具有公共枚举权限的类（只是从 0 开始的连续整数），并有一个查询函数，它只返回由索引的私有 BitArray 成员的值权限枚举）。这将有效地处理任意数量的权限。 不错。它在 1.0 中得到支持。 @arbiter。这是一个有趣的解决方案。当值存储在数据库中时，如果我想检查是否存在位怎么办？【参考方案4】：结果证明这是一个比我想象的更常见的问题，我将 CSS 类表示为标志类型，并且有超过 64 种可能性。我已经把我从这个过程中学到的所有东西都变成了一个可重用的模式，尽管它是一个结构，它是一个复制粘贴类型的模式。
这是BigFlags“枚举类型”。它使用来自System.Numerics 的BigInteger，或者如果您无法引用该程序集，则可以通过简单地关闭NUMERICS 预处理器指令来使用BitArray。
它的行为非常像 Flags 枚举，甚至定义了 HasFlag(...)、GetNames()、GetValues()、TryParse(...)、TypeConverter、IConvertible 等。因为它确实定义了一个TypeConverter 和 IConvertible，它也适合存储在数据存储中，尽管总是作为字符串或文本数据类型。
您将“枚举”值公开为public static readonly 成员。组合的枚举值作为 get-only 属性公开。
要使用它，请复制并粘贴代码，然后在 BigFlags 上进行搜索并用您的结构名称替换，然后删除 TODO 部分中的枚举并添加您的值。
希望有人觉得它有用。
#define NUMERICS
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
#if NUMERICS
using System.Numerics;
#endif
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace Aim
/// <summary>
/// The BigFlags struct behaves like a Flags enumerated type.
/// <para>
/// Note that if this struct will be stored in some type of data
/// store, it should be stored as a string type. There are two
/// reasons for this:
/// </para>
/// <para>
/// 1. Presumably, this pattern is being used because the number
/// of values will exceed 64 (max positions in a long flags enum).
/// Since this is so, there is in any case no numeric type which
/// can store all the possible combinations of flags.
/// </para>
/// <para>
/// 2. The "enum" values are assigned based on the order that the
/// static public fields are defined. It is much safer to store
/// these fields by name in case the fields are rearranged. This
/// is particularly important if this represents a permission set!
/// </para>
/// </summary>
[
TypeConverter( typeof( BigFlagsConverter ) )
]
public struct BigFlags : IEquatable<BigFlags>,
IComparable<BigFlags>, IComparable, IConvertible
#region State...
private static readonly List<FieldInfo> Fields;
private static readonly List<BigFlags> FieldValues;
#if NUMERICS
private static readonly bool ZeroInit = true;
private BigInteger Value;
/// <summary>
/// Creates a value taking ZeroInit into consideration.
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private static BigInteger CreateValue( int index )
if( ZeroInit && index == 0 )
return 0;
int idx = ZeroInit ? index - 1 : index;
return new BigInteger( 1 ) << idx;
#else
private BitArray Array;
/// <summary>
/// Lazy-initialized BitArray.
/// </summary>
private BitArray Bits
get
if( null == Array )
Array = new BitArray( Fields.Count );
return Array;
#endif
#endregion ...State
#region Construction...
/// <summary>
/// Static constructor. Sets the static public fields.
/// </summary>
static BigFlags()
Fields = typeof( BigFlags ).GetFields(
BindingFlags.Public | BindingFlags.Static ).ToList();
FieldValues = new List<BigFlags>();
for( int i = 0; i < Fields.Count; i++ )
var field = Fields[i];
var fieldVal = new BigFlags();
#if NUMERICS
fieldVal.Value = CreateValue( i );
#else
fieldVal.Bits.Set( i, true );
#endif
field.SetValue( null, fieldVal );
FieldValues.Add( fieldVal );
#endregion ...Construction
#region Operators...
/// <summary>
/// OR operator. Or together BigFlags instances.
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static BigFlags operator |( BigFlags lhs, BigFlags rhs )
var result = new BigFlags();
#if NUMERICS
result.Value = lhs.Value | rhs.Value;
#else
// BitArray is modified in place - always copy!
result.Array = new BitArray( lhs.Bits ).Or( rhs.Bits );
#endif
return result;
/// <summary>
/// AND operator. And together BigFlags instances.
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static BigFlags operator &( BigFlags lhs, BigFlags rhs )
var result = new BigFlags();
#if NUMERICS
result.Value = lhs.Value & rhs.Value;
#else
// BitArray is modified in place - always copy!
result.Array = new BitArray( lhs.Bits ).And( rhs.Bits );
#endif
return result;
/// <summary>
/// XOR operator. Xor together BigFlags instances.
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static BigFlags operator ^( BigFlags lhs, BigFlags rhs )
var result = new BigFlags();
#if NUMERICS
result.Value = lhs.Value ^ rhs.Value;
#else
// BitArray is modified in place - always copy!
result.Array = new BitArray( lhs.Bits ).Xor( rhs.Bits );
#endif
return result;
/// <summary>
/// Equality operator.
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static bool operator ==( BigFlags lhs, BigFlags rhs )
return lhs.Equals( rhs );
/// <summary>
/// Inequality operator.
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static bool operator !=( BigFlags lhs, BigFlags rhs )
return !( lhs == rhs );
#endregion ...Operators
#region System.Object Overrides...
/// <summary>
/// Overridden. Returns a comma-separated string.
/// </summary>
/// <returns></returns>
public override string ToString()
#if NUMERICS
if( ZeroInit && Value == 0 )
return Fields[0].Name;
#endif
var names = new List<string>();
for( int i = 0; i < Fields.Count; i++ )
#if NUMERICS
if( ZeroInit && i == 0 )
continue;
var bi = CreateValue( i );
if( ( Value & bi ) == bi )
names.Add( Fields[i].Name );
#else
if( Bits[i] )
names.Add( Fields[i].Name );
#endif
return String.Join( ", ", names );
/// <summary>
/// Overridden. Compares equality with another object.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals( object obj )
if( obj is BigFlags )
return Equals( (BigFlags)obj );
return false;
/// <summary>
/// Overridden. Gets the hash code of the internal BitArray.
/// </summary>
/// <returns></returns>
public override int GetHashCode()
#if NUMERICS
return Value.GetHashCode();
#else
int hash = 17;
for( int i = 0; i < Bits.Length; i++ )
if( Bits[i] )
hash ^= i;
return hash;
#endif
#endregion ...System.Object Overrides
#region IEquatable<BigFlags> Members...
/// <summary>
/// Strongly-typed equality method.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Equals( BigFlags other )
#if NUMERICS
return Value == other.Value;
#else
for( int i = 0; i < Bits.Length; i++ )
if( Bits[i] != other.Bits[i] )
return false;
return true;
#endif
#endregion ...IEquatable<BigFlags> Members
#region IComparable<BigFlags> Members...
/// <summary>
/// Compares based on highest bit set. Instance with higher
/// bit set is bigger.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public int CompareTo( BigFlags other )
#if NUMERICS
return Value.CompareTo( other.Value );
#else
for( int i = Bits.Length - 1; i >= 0; i-- )
bool thisVal = Bits[i];
bool otherVal = other.Bits[i];
if( thisVal && !otherVal )
return 1;
else if( !thisVal && otherVal )
return -1;
return 0;
#endif
#endregion ...IComparable<BigFlags> Members
#region IComparable Members...
int IComparable.CompareTo( object obj )
if( obj is BigFlags )
return CompareTo( (BigFlags)obj );
return -1;
#endregion ...IComparable Members
#region IConvertible Members...
/// <summary>
/// Returns TypeCode.Object.
/// </summary>
/// <returns></returns>
public TypeCode GetTypeCode()
return TypeCode.Object;
bool IConvertible.ToBoolean( IFormatProvider provider )
throw new NotSupportedException();
byte IConvertible.ToByte( IFormatProvider provider )
#if NUMERICS
return Convert.ToByte( Value );
#else
throw new NotSupportedException();
#endif
char IConvertible.ToChar( IFormatProvider provider )
throw new NotSupportedException();
DateTime IConvertible.ToDateTime( IFormatProvider provider )
throw new NotSupportedException();
decimal IConvertible.ToDecimal( IFormatProvider provider )
#if NUMERICS
return Convert.ToDecimal( Value );
#else
throw new NotSupportedException();
#endif
double IConvertible.ToDouble( IFormatProvider provider )
#if NUMERICS
return Convert.ToDouble( Value );
#else
throw new NotSupportedException();
#endif
short IConvertible.ToInt16( IFormatProvider provider )
#if NUMERICS
return Convert.ToInt16( Value );
#else
throw new NotSupportedException();
#endif
int IConvertible.ToInt32( IFormatProvider provider )
#if NUMERICS
return Convert.ToInt32( Value );
#else
throw new NotSupportedException();
#endif
long IConvertible.ToInt64( IFormatProvider provider )
#if NUMERICS
return Convert.ToInt64( Value );
#else
throw new NotSupportedException();
#endif
sbyte IConvertible.ToSByte( IFormatProvider provider )
#if NUMERICS
return Convert.ToSByte( Value );
#else
throw new NotSupportedException();
#endif
float IConvertible.ToSingle( IFormatProvider provider )
#if NUMERICS
return Convert.ToSingle( Value );
#else
throw new NotSupportedException();
#endif
string IConvertible.ToString( IFormatProvider provider )
return ToString();
object IConvertible.ToType( Type conversionType, IFormatProvider provider )
var tc = TypeDescriptor.GetConverter( this );
return tc.ConvertTo( this, conversionType );
ushort IConvertible.ToUInt16( IFormatProvider provider )
#if NUMERICS
return Convert.ToUInt16( Value );
#else
throw new NotSupportedException();
#endif
uint IConvertible.ToUInt32( IFormatProvider provider )
#if NUMERICS
return Convert.ToUInt32( Value );
#else
throw new NotSupportedException();
#endif
ulong IConvertible.ToUInt64( IFormatProvider provider )
#if NUMERICS
return Convert.ToUInt64( Value );
#else
throw new NotSupportedException();
#endif
#endregion ...IConvertible Members
#region Public Interface...
/// <summary>
/// Checks <paramref name="flags"/> to see if all the bits set in
/// that flags are also set in this flags.
/// </summary>
/// <param name="flags"></param>
/// <returns></returns>
public bool HasFlag( BigFlags flags )
return ( this & flags ) == flags;
/// <summary>
/// Gets the names of this BigFlags enumerated type.
/// </summary>
/// <returns></returns>
public static string[] GetNames()
return Fields.Select( x => x.Name ).ToArray();
/// <summary>
/// Gets all the values of this BigFlags enumerated type.
/// </summary>
/// <returns></returns>
public static BigFlags[] GetValues()
return FieldValues.ToArray();
/// <summary>
/// Standard TryParse pattern. Parses a BigFlags result from a string.
/// </summary>
/// <param name="s"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool TryParse( string s, out BigFlags result )
result = new BigFlags();
if( String.IsNullOrEmpty( s ) )
return true;
var fieldNames = s.Split( ',' );
foreach( var f in fieldNames )
var field = Fields.FirstOrDefault( x =>
String.Equals( x.Name, f.Trim(),
StringComparison.OrdinalIgnoreCase ) );
if( null == field )
result = new BigFlags();
return false;
#if NUMERICS
int i = Fields.IndexOf( field );
result.Value |= CreateValue( i );
#else
result.Bits.Set( Fields.IndexOf( field ), true );
#endif
return true;
//
// Expose "enums" as public static readonly fields.
// TODO: Replace this section with your "enum" values.
//
public static readonly BigFlags None;
public static readonly BigFlags FirstValue;
public static readonly BigFlags ValueTwo;
public static readonly BigFlags ValueThree;
public static readonly BigFlags ValueFour;
public static readonly BigFlags ValueFive;
public static readonly BigFlags ValueSix;
public static readonly BigFlags LastValue;
/// <summary>
/// Expose flagged combinations as get-only properties.
/// </summary>
public static BigFlags FirstLast
get
return BigFlags.FirstValue | BigFlags.LastValue;
#endregion ...Public Interface
/// <summary>
/// Converts objects to and from BigFlags instances.
/// </summary>
public class BigFlagsConverter : TypeConverter
/// <summary>
/// Can convert to string only.
/// </summary>
/// <param name="context"></param>
/// <param name="destinationType"></param>
/// <returns></returns>
public override bool CanConvertTo( ITypeDescriptorContext context,
Type destinationType )
return destinationType == typeof( String );
/// <summary>
/// Can convert from any object.
/// </summary>
/// <param name="context"></param>
/// <param name="sourceType"></param>
/// <returns></returns>
public override bool CanConvertFrom( ITypeDescriptorContext context,
Type sourceType )
return true;
/// <summary>
/// Converts BigFlags to a string.
/// </summary>
/// <param name="context"></param>
/// <param name="culture"></param>
/// <param name="value"></param>
/// <param name="destinationType"></param>
/// <returns></returns>
public override object ConvertTo( ITypeDescriptorContext context,
CultureInfo culture, object value, Type destinationType )
if( value is BigFlags && CanConvertTo( destinationType ) )
return value.ToString();
return null;
/// <summary>
/// Attempts to parse <paramref name="value"/> and create and
/// return a new BigFlags instance.
/// </summary>
/// <param name="context"></param>
/// <param name="culture"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object ConvertFrom( ITypeDescriptorContext context,
CultureInfo culture, object value )
var s = Convert.ToString( value );
BigFlags result;
BigFlags.TryParse( s, out result );
return result;
【讨论】：
【参考方案5】：不是您问题的答案，而是相关建议：我们使用位移来指定数值，如下所示：
[Flags]
public enum MyEnumFlags : Int64
None = 0,
A = 1 << 0,
B = 1 << 1,
C = 1 << 2,
D = 1 << 3,
E = 1 << 4,
F = 1 << 5,
...etc...
前十个没那么重要，但之后就很方便了。
【讨论】：
【参考方案6】：在 C# 中，表示值的一种灵活方法是一种枚举，但更灵活的方法是将其表示为具有可用预煮值的静态类，如下所示：
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
或者，只是把事情分开；如果你真的尝试过，看起来你可以。
【讨论】：
这也是一种看待这个问题的好方法，直到现在我还没有考虑过。感谢您的意见。【参考方案7】：如果我能控制这个应用程序，我可能会想出一组通用权限（查看、添加、编辑、删除、上传/导入）和一组资源（用户、角色、规则等） .在网页上找到与该页面关联的资源类型，然后检查权限。可能是这样的：
Permissions perms = agent.GetPermissions(ResourceType.User);
if((perms & Permissions.View) == Permissions.View) /* do work */
或
Permissions perms = agent.Permissions[ResourceType.User];
if((perms & Permissions.View) == Permissions.View) /* do work */
甚至
if(agent.IsAuthorized(ResourceType.User, Permissions.View)) /* do work */
您拥有一些对其他所有内容都没有意义的权限（将权限分配给用户，举个例子）。根据我对问题的了解程度，我不确定如何处理。
【讨论】：
+1 为您在上面的评论，如果没有别的，感谢您的时间。【参考方案8】：我没有遇到过这种情况。
这是我的想法，为每个类别创建单独的枚举并接受它们作为参数。
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)
...
编辑：看看 messagebox.show 是如何做到的。 OK，OKCancel 与 Question、Information、Exclamation 分开。
【讨论】：
以上是关于当位掩码（标志）枚举变得太大时该怎么办的主要内容，如果未能解决你的问题，请参考以下文章