public RoleUserController(IRoleUser repoRoleUser
     , IRole repoRole, IPermission repoPer)
 {
     dalRoleUser = repoRoleUser;
     dalRole = repoRole;
     dalPermission = repoPer;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="roleAccessor">Role Property Accessor this instance will be returned by</param>
        /// <param name="memberships">Other roles to participate in</param>
        /// <param name="exclusions">Roles of which this role is excluded</param>
        public RoleExpression(Expression<Func<IRole>> roleAccessor, IRole[] memberships, IRole[] exclusions)
        {
            Name = BindingHelper.Name(roleAccessor);

            RoleMemberships = memberships.ToDictionary(r => r.Name);
            RoleExclusions = exclusions.ToDictionary(r => r.Name);
        }

        private void RemoveExclusions(IRole role, Dictionary<string, IRole> roles, HashSet<IRole> parsedMemberships, HashSet<IRole> parsedExclusions)
        {
            foreach (var exclusion in role.RoleExclusions.Values)
            {
                if (parsedExclusions.Contains(exclusion))
                {
                    continue;
                }
                if (roles.ContainsKey(exclusion.Name))
                {
                    roles.Remove(exclusion.Name);
                    parsedExclusions.Add(exclusion);
                }
                RemoveExclusions(exclusion, roles, parsedMemberships, parsedExclusions);
            }

            foreach (var membership in role.RoleMemberships.Values)
            {
                if (parsedMemberships.Contains(membership))
                {
                    continue;
                }
                parsedMemberships.Add(membership);
                RemoveExclusions(membership, roles, parsedMemberships, parsedExclusions);
            }
        }

        /// <summary>
        /// Assign a set of abilities to a role.
        /// </summary>
        /// <param name="role">The role that is to be inspected and if nescessary configured</param>
        /// <param name="abilities">The abilities to assign the role if nescessary</param>
        public static void RegisterAbilities(IRole role, IEnumerable<IAbility> abilities)
        {
            // This method is intended to be used from the Global.asax.cs or
            // similar. It should only be done from there to encourage a centralized
            // place to assign abilities.
            //
            // You could additionally add the roles and abilities into this file
            // but it was designed to be general enough to support most use cases
            //
            // The method is designed with dependency injection in mind which should allow
            // any method of configuring roles and abilities (i.e. pulling roles from the database,
            // or abilities through refection)

            if (role == null)
                throw new ArgumentNullException("role");
            if (abilities == null)
                throw new ArgumentNullException("abilities");
            if (role.Abilities == null)
                role.Abilities = new List<IAbility>();

            foreach (IAbility ability in abilities)
                role.Abilities.Add(ability);

            AuthorizationService.AddRole(role);
        }

 public AccountController(IUser userRepository, ISettings settingsRepository, IRole roleRepository)
     : base(settingsRepository)
 {
     _userRepository = userRepository;
     _roleRepository = roleRepository;
     ExpectedMasterName = string.Empty;
 }

 /// <summary>
 /// Adds the role.
 /// </summary>
 /// <param name="role">The role.</param>
 public void AddRole(IRole role)
 {
     using (Logger.Assembly.Scope())
     {
         RoleIds.Add(role.Id);
     }
 }

 public Task<int> UpdateAsync(IRole role)
 {
     if (String.IsNullOrEmpty(role.Id))
     {
         throw new ArgumentNullException("Id");
     }
     return roleRepository.UpdateAsync(role);
 }

        public TaskContext(IRole role)
        {
            Role = role;

               Settings = new ExpandoObject();
               StepIndex = 0;
               TaskSteps = new List<TaskStep>();
        }

        /// <summary>
        /// 根据流程和角色创建SOARoleContext
        /// </summary>
        /// <param name="role"></param>
        /// <param name="process"></param>
        /// <returns></returns>
        public static SOARoleContext CreateContext(IRole role, IWfProcess process)
        {
            role.NullCheck("role");

            SOARole soaRole = (SOARole)SOARole.CreateWrapperObject(role);

            return CreateContext(soaRole.PropertyDefinitions, process);
        }

        public IRole AddRole(IRole role)
        {
            foreach (IAbility ability in role.Abilities)
                AddAbility(ability);

            _roleRepository.Create(role);
            return GetRole(role.Name);
        }

 public Character(string name, char gender, int age, IRole role, string race)
 {
     this.name = name;
     this.gender = gender;
     this.age = age;
     this.role = role;
     this.race = race;
     // give random hair type , eye colour , hair colour
 }

 public void Initial()
 {
     if(PlayerGO != null)		Player		= PlayerGO.GetComponent<IRole>();
     if(EnemyGO != null)			Enemy		= EnemyGO.GetComponent<IRole> ();
     if(PlayerCameraGO != null)	PlayerCam	= PlayerCameraGO.GetComponent<ICamera> ();
     if(EnemyCameraGO != null)	EnemyCam    = EnemyCameraGO.GetComponent<ICamera> ();
     if(BulletCameraGO != null)	BulletCam	= BulletCameraGO.GetComponent<ICamera> ();
     if(MainCameraGO != null)	MainCam		= MainCameraGO.GetComponent<ICamera> ();
 }

        public void remove_role(IRole role)
        {
            roles.RemoveAll(r => r.GetType() == role.GetType());

            Contract.Ensures(
                roles.Count > 0,
                "Personnel must have at least one role"
            );
        }

        public new static IRole CreateWrapperObject(IRole role)
        {
            IRole result = role;

            if (role is SOARole == false)
                result = new SOARole(role);

            return result;
        }

 public Boolean HasRole(IRole role)
 {
     foreach (IRole personnel_role in this.roles)
     {
         if (role.GetType() == personnel_role.GetType()){
             return true;
         }
     }
     return false;
 }

        public TaskContext(IRole role)
        {
            if (role == null)
                throw new Exception("角色不能为null");
               Role = role;

               Settings = new ExpandoObject();
               StepIndex = 0;
               TaskSteps = new List<TaskStep>();
        }

        public IRole RenameRole(IRole role, String newRoleName)
        {
            if (role == null) throw new ArgumentNullException("role");
            if (String.IsNullOrEmpty(newRoleName)) throw new ArgumentNullException("newRoleName");

            role.Name = newRoleName;
            this.RoleRepository.Update(role);
            
            return role;
        }

 private static void bindCheckBoxList( SecurityTool tool, IBlock sblock, IRole role ) {
     IBlock cbBlock = sblock.GetBlock( "checkboxs" );
     IList checkValues = tool.GetCheckBoxList( role );
     foreach (ActionVo av in checkValues) {
         cbBlock.Set( "a.Name", av.Name );
         cbBlock.Set( "a.Value", av.Value );
         cbBlock.Set( "a.Checked", av.Checked );
         cbBlock.Next();
     }
 }

        public static void Add(IContext context, IRole role)
        {
            Context ctx = context as Context;
            if (ctx == null)
                throw new Exception(typeof(Context).FullName + " expected.");

            SqlCommand command = new SqlCommand("insert into Role (title) values (@Title)");
            command.Parameters.Add(new SqlParameter("Title", role.Title));

            command.ExecuteNonQuery();
        }

 public Task<int> DeleteAsync(IRole entity)
 {
     try
     {
         return Repository.DeleteAsync(entity);
     }
     catch (Exception e)
     {
         throw new Exception(e.ToString());
     }
 }