C# 位掩码（标志）枚举超过64，带有逻辑分组的位数组存储在数据库中

这个问题的第一个答案是：这正是我想要做的，只是我不知道如何使用LINQ to SQL将其存储在数据库中，并将其绑定到用户，而不为每个事物/逻辑组创建两个表

这最好通过代码来解释（这些代码对LinqPad很友好，但不完整）：

//要求：
//1）使用LINQ到SQL
//2）跟踪用户在应用程序不同部分的CRUD权限（以下称为“内容”的部分）
//例如：ThingA.Create、ThingB.Read、ThingB.Update、ThingC.Delete
//所需用法：if（User.IsAllowed（ThingA.Create））{//allowed}else{//notallowed}
//3）允许64个以上的“事物”
//4）不希望使用User.IsAllowed（“Create ThingA”）等字符串引用权限；
//
//场景A：这是可行的，但您只能添加60个“东西”
//用法示例：
//用户Bob=新用户（）；
//var desiredPermissions=Permissions.Create | Permissions.ThingA；//权限=标志的唯一二进制值组合
//如果（（Bob.Permissions&desiredPermissions）=desiredPermissions）{//Bob有创建ThingA的权限
[旗帜]
公共枚举权限：ulong
{
Create=1不确定您是否完全了解标志的工作原理。使用左移位运算符的原因是，您的枚举将是以下值的指数

flag属性用于让.NET知道枚举的值可以是倍数

例如，如果你把你的东西A和B加起来（48）

Console.Write（（权限）48））；

返回的值是ThingA和ThingB。您只需将其保存为数据库中的单个
ulong
，您的代码就可以计算出其余的值。
我认为您不需要为每个逻辑组使用两个表。如果您对枚举使用位掩码，并且在其中创建/删除/更新，在中使用thing1/thing2/thing3另一种方法是，您可以迭代枚举并在数据库中为用户的每个逻辑对存储一行，您还可以只存储应用于用户的逻辑对，例如最多四行。一列用于创建/更新/删除/读取（每一行）第二列是thing1/thing2/thing3的位掩码。我不认为四列是多余的…-我可能遗漏了一些东西…：）
// Requirements:
// 1) Using LINQ to SQL
// 2) Track User's CRUD rights in different parts of an application (parts referred to below as 'Things')
// For example: ThingA.Create, ThingB.Read, ThingB.Update, ThingC.Delete
// Desired usage: if (User.IsAllowed(ThingA.Create)) { // allowed } else { // not allowed }
// 3) Allow for more than 64 'Things'
// 4) Do not want to refer to permissions using strings like User.IsAllowed("Create ThingA");

//
// Scenario A: This works, but you would be limited to adding only 60 'Things'
// Example usage:
// User Bob = new User();
// var desiredPermissions = Permissions.Create | Permissions.ThingA; // Permission = Unique binary value combination of flags
// if ((Bob.Permissions & desiredPermissions) == desiredPermissions) { // Bob has permission to Create ThingA
[Flags]
public enum Permissions : ulong
{
    Create = 1 << 0,
    Read = 1 << 1,
    Update = 1 << 2,
    Delete = 1 << 3,

    // Limited to 60 'Things'
    ThingA = 1 << 4,
    ThingB = 1 << 5 
}

// User Model
[Table(Name="Users")]
public class User
{
    [Column(IsPrimaryKey = true)]
    public string FName { get; set; }

    [Column]
    public Permissions Permissions { get; set; }

    public User()
    {
    }
}

//
// Scenario B: This would work too, but each new 'Thing' would need its own flag enum list stored in its own table (ThingXPermissions),
// with another table linking ThingXPermissions.X to Users.ID (UserThingXPermissions) (yuck!)
// Would like to avoid having to change database structure when adding more 'Things' in future.

// User Model
[Table(Name="Users")]
public class User
{
    [Column(IsPrimaryKey = true, IsDbGenerated = true)]
    public int ID { get; set; }

    private EntitySet<ThingAPermissions> userThingAPermissions = new EntitySet<ThingAPermissions>();
    [Association(Name = "FK_User_UserThingAPermissions", Storage = "userThingAPermissions", OtherKey = "FK_User_Id", ThisKey = "ID")]
    public IEnumerable<ThingAPermissions> UserThingAPermissions
    { get { return userThingAPermissions; } }

    public IEnumerable<ThingAPermissions> ThingAPermissions
    { get { return (from up in UserThingAPermissions select up.UserThingAPermissions).AsEnumerable(); } }

    public User()
    {
    }
}

[Table(Name="UserThingAPermissions")]
public class UserThingAPermissions
{
    [Column(IsPrimaryKey = true)]
    public int FK_User_Id;

    private EntityRef<User> user;
    [Association(IsForeignKey = true, ThisKey = "FK_User_Id")]
    public User User
    {
        get { return user.Entity; }
        set { user.Entity = value; }
    }

    [Column]
    public ThingAPermissions ThingAPermissions { get; set; }
}

// ThingAPermissions
[Flags]
public enum ThingAPermissions : ulong
{
    Create = 1 << 0,
    Read = 1 << 1,
    Update = 1 << 2,
    Delete = 1 << 3
}

//
// Desired Scenario: Psuedo code of what I'd like to be able to do:
// Single Permissions (CRUD) list
// Single||simple Things list
// Single||simple table associating UserX, ThingX, PermissionX
// Example usage:
// User Bob = new User();
// var desiredPermissions = Permissions.Create | Things.ThingZ; // Permission = Unique binary value combination of flags
// if ((Bob.Permissions & desiredPermissions) == desiredPermissions) { // Bob has permission to Create ThingZ
// Missing link: Combining enums and storing into database linked to user
// e.g.
// [Table = "UserPermissions"]
// (User, Thing, Permission)
// 1, ThingZ, Create
// 1, ThingZ, Delete
// 1, ThingX, Read
// 2, ThingZ, Read
// 2, ThingX, Delete
[Flags]
public enum Permissions : ulong
{
    Create = 1 << 0,
    Read = 1 << 1,
    Update = 1 << 2,
    Delete = 1 << 3
}

[Flags]
public enum Things : ulong
{
    ThingZ = 1 << 0,
    ThingY = 1 << 1,
    ThingX = 1 << 2,
    ThingW = 1 << 3
}

[Table(Name="UserPermissions")]
public class UserPermission
{
    [Column(IsPrimaryKey = true)]
    public int FK_User_Id;

    private EntityRef<User> user;
    [Association(IsForeignKey = true, ThisKey = "FK_User_Id")]
    public User User
    {
        get { return user.Entity; }
        set { user.Entity = value; }
    }

    [Column]
    public int FK_Thing_Thing { get; set; }

    private EntityRef<Things> thing;
    [Association(IsForeignKey = true, ThisKey = "FK_User_Id")]
    public User User
    {
        get { return user.Entity; }
        set { user.Entity = value; }
    }

    [Column]
    public Permissions Permission { get; set; }
}