Auth model

ef code first

        public static void Main()
        {
            Database.SetInitializer(new DropCreateDatabaseAlways<AuthDbContext>());

            var carrotRead = new CarrotAuth(12, Permissions.Read);
            var user = new User();
            user.Authorizations.Add(carrotRead);

            using (var context = new AuthDbContext())
            {
                context.Set<User>().Add(user);
                context.SaveChanges();
            }

            User match;
            var id = user.Id;
            using (var context = new AuthDbContext())
            {
                match = context.Users.Where(x => x.Id == id).Include(u => u.Authorizations).Single();
            }

            if (match.IsAuthorized<CarrotAuth>(12, Permissions.Read))
                "Yeah!".Dump();
            else
                "Boooh!".Dump();
        }

    [Flags] // values must be powers of two
    public enum Permissions
    {
        Create = 1,
        Read = 2,
        Update = 4,
        Delete = 8
    }

    public class Auth
    {
        public int Id { get; set; }
        public int ObjectId { get; set; }
        public Permissions Permissions { get; set; }
        public Auth() { }
        public Auth(int id, Permissions permissions)
        {
            this.Permissions = permissions; 
            this.ObjectId = id;
        }
    }

    public class Carrot
    {
        public int Id { get; set; }
    }

    public class User
    {
        public int Id { get; set; }
        public User() { Authorizations = new List<Auth>(); }
        
        public List<Auth> Authorizations { get; set; }
        public bool IsAuthorized<T>(int id, Permissions permission) where T : Auth
        {
            foreach (var auth in Authorizations)
                if (auth is T)
                {
                    var a = auth as T;
                    if (a.Permissions == permission && a.ObjectId == id)
                        return true;
                }

            return false;
        }
    }

    public class CarrotAuth : Auth
    {
        public CarrotAuth() { }
        public CarrotAuth(int id, Permissions permissions)
            : base(id, permissions)
        {

        }
    }

    public class AuthDbContext : DbContext
    {
        public DbSet<CarrotAuth> CarrotAuths { get; set; }
        public DbSet<User> Users { get; set; }
    }

linq2sql

        public static void Main()
        {
            var carrotRead = new CarrotAuth(12, Permissions.Read);
            var user = new User();
            user.Authorizations.Add(carrotRead);

            using (var context = new AuthDbContext())
            {
                context.Users.Add(user);
                context.SubmitChanges();
            }

            User match;
            var id = user.Id;
            using (var context = new AuthDbContext())
            {
                match = context.Users.Where(x => x.Id == id).Single();
            }

            if (match.IsAuthorized<CarrotAuth>(12, Permissions.Read))
                "Yeah!".Dump();
            else
                "Boooh!".Dump();
        }

    [Flags] // values must be powers of two
    public enum Permissions
    {
        Create = 1,
        Read = 2,
        Update = 4,
        Delete = 8
    }

    public class Auth
    {
        [Column(IsPrimaryKey=true)]
        public int Id { get; set; }
        
        [Column]        
        public int ObjectId { get; set; }

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

        private EntityRef<User> _User;
        [Association(Storage = "_User", ThisKey = "UserId")]
        public User User
            {
                get { return this._User.Entity; }
                set { this._User.Entity = value; }
            }

        public Permissions Permissions { get; set; }
        public Auth() { }
        public Auth(int id, Permissions permissions)
        {
            this.Permissions = permissions; 
            this.ObjectId = id;
        }
    }
    [Table(Name="Carrots")]
    public class Carrot
    {
        [Column(IsPrimaryKey=true)]
        public int Id { get; set; }
    }

    [Table(Name="Users")]
    public class User
    {
        [Column(IsPrimaryKey=true)]
        public int Id { get; set; }
        public User() { Authorizations = new List<Auth>(); }
        
        private EntitySet<Auth> _Authorizations;
        [Association(Storage="_Authorizations", OtherKey="UserID")]
        public EntitySet<Auth> Authorizations {
            get { return this._Authorizations; }
            set { this._Authorizations.Assign(value); }
        }
        public bool IsAuthorized<T>(int id, Permissions permission) where T : Auth
        {
            foreach (var auth in Authorizations)
                if (auth is T)
                {
                    var a = auth as T;
                    if (a.Permissions == permission && a.ObjectId == id)
                        return true;
                }

            return false;
        }
    }

    [Table(Name="CarrotAuth")]
    public class CarrotAuth : Auth
    {
        public CarrotAuth() { }
        public CarrotAuth(int id, Permissions permissions)
            : base(id, permissions)
        {

        }
    }

    public class AuthDbContext : DataContext
    {
        public AuthDbContext() : base("connectionString.mdf"){}
        public Table<CarrotAuth> CarrotAuths { get; set; }
        public Table<User> Users { get; set; }
    }

public static void Main()
{
    var carrotRead = new CarrotAuth(Permissions.Read);
    var carrotDelete = new CarrotAuth(Permissions.Delete);

    var user = new User();  
    user.Authorizations.Add(carrotRead);

    if (user.IsAuthorized<CarrotAuth>(Permissions.Read))
        "Can Read Carrots!".Dump();
    else
        "No Reading Carrots!".Dump();

    if (user.IsAuthorized<CarrotAuth>(Permissions.Delete))
        "Can Delete Carrots!".Dump();
    else
        "No Delete Carrots!".Dump();

    // Save user.Authorizations to DB ?
    user.Authorizations.Dump();




    user.Authorizations.Add(carrotDelete);

    if (user.IsAuthorized<CarrotAuth>(Permissions.Read))
        "Can Read Carrots!".Dump();
    else
        "No Reading Carrots!".Dump();

    if (user.IsAuthorized<CarrotAuth>(Permissions.Delete))
        "Can Delete Carrots!".Dump();
    else
        "No Delete Carrots!".Dump();

    // Save user.Authorizations to DB ?
    user.Authorizations.Dump();
}

[Flags] // values must be powers of two
public enum Permissions
{
Create = 1,
Read = 2,
Update = 4,
Delete = 8
}

public class Auth
{
[Column(IsPrimaryKey=true, IsDbGenerated=true)]
public int Id { get; set; }

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

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

private EntityRef<User> _User;
[Association(Storage = "_User", ThisKey = "UserId")]
public User User
    {
        get { return this._User.Entity; }
        set { this._User.Entity = value; }
    }

public Permissions Permissions { get; set; }
public Auth() { }
public Auth(Permissions permissions)
{
    this.Permissions = permissions;
}
public Auth(int id, Permissions permissions)
{
    this.Permissions = permissions; 
    this.ObjectId = id;
}
}
[Table(Name="Carrots")]
public class Carrot
{
[Column(IsPrimaryKey=true)]
public int Id { get; set; }
}

[Table(Name="Users")]
public class User
{
[Column(IsPrimaryKey=true)]
public int Id { get; set; }
public User() { } //Authorizations = new EntitySet<Auth>(); }

private EntitySet<Auth> _Authorizations = new EntitySet<Auth>();
[Association(Storage="_Authorizations", OtherKey="UserID")]
public EntitySet<Auth> Authorizations {
    get { return this._Authorizations; }
    set { this._Authorizations.Assign(value); }
}
public bool IsAuthorized<T>(Permissions permission) where T : Auth // no id
{
    foreach (var auth in Authorizations)
        if (auth is T)
        {
            var a = auth as T;
            if (a.Permissions == permission)
                return true;
        }

    return false;
}
public bool IsAuthorized<T>(int id, Permissions permission) where T : Auth
{
    foreach (var auth in Authorizations)
        if (auth is T)
        {
            var a = auth as T;
            if (a.Permissions == permission && a.ObjectId == id)
                return true;
        }

    return false;
}
}

[Table(Name="CarrotAuth")]
public class CarrotAuth : Auth
{
public CarrotAuth() { }
public CarrotAuth(Permissions permissions) : base(permissions) { }
public CarrotAuth(int id, Permissions permissions) : base(id, permissions) { }
}

[Database(Name = "DB")]
public class Database : DataContext, IDisposable
{
    public Database() : base("test.mdf") {}
    public Table<User> Users;
    public Table<CarrotAuth> CarrotAuths;
}