6、VS2010+ASP.NET MVC4+EF4+JqueryEasyUI+Oracle项目开发之——增删改查CRUD

这篇以用户角色为例，来实现CRUD。效果如下：

这里要用到角色表，角色权限表等。看Model SMROLETB，如下：

/* ==============================================================================
 * 功能描述：Rose  
 * 公司名称:
 * 创 建 者：Zouqj
 * 创建日期：2014-3-18 9:22:29
 * ==============================================================================*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.ComponentModel.DataAnnotations;

namespace YKT.Model
{
    [MetadataType(typeof(SMROLETBMetadata))] //这里是进行映射的
  public partial class SMROLETB
    {
        #region 自定义属性，即由数据实体扩展的实体

        [Display(Name = "人员")]
        [ScaffoldColumn(false)]
        public string SysPersonId { get; set; }

        [ScaffoldColumn(false)]
        [Display(Name = "人员")]
        public string SysPersonIdOld { get; set; }

        [ScaffoldColumn(false)]
        [Display(Name = "创建者")]
        public string CreateUserName { get; set; }

        [ScaffoldColumn(false)]
        [Display(Name = "修改者")]
        public string UpdateUserName { get; set; }

        [ScaffoldColumn(false)]
        [Display(Name = "状态")]
        public string StatusName { get; set; }

        #endregion
    }
  public class SMROLETBMetadata
  {
      [ScaffoldColumn(false)]
      [Display(Name = "主键", Order = 1)]
      public int ROLE_ID { get; set; }

      [ScaffoldColumn(true)]
      [Display(Name = "角色名称", Order = 5)]
      [StringLength(20, ErrorMessage = "长度不可超过20")]
      [Required(ErrorMessage = "不能为空")]
      public string ROLE_NAME { get; set; }

      [ScaffoldColumn(true)]
      [Display(Name = "创建时间", Order = 4)]
      [DataType(DataType.DateTime, ErrorMessage = "时间格式不正确")]
      public DateTime? CREATION_TIME { get; set; }

      [ScaffoldColumn(false)]
      [Display(Name = "创建人", Order = 7)]
      public int CREATION_USER { get; set; }

      [ScaffoldColumn(true)]
      [Display(Name = "说明", Order = 7)]
      [StringLength(100, ErrorMessage = "长度不可超过100")]
      public string REMARK { get; set; }

      [ScaffoldColumn(true)]
      [Display(Name = "角色状态", Order = 7)]
      [StringLength(2, ErrorMessage = "长度不可超过200")]
      [Required(ErrorMessage = "不能为空")]
      public string STATUS { get; set; }
  }

  public class RoleView : SMROLETB
  {
      public List<string> UserNames { get; set; }
  }
}

控制器SysRoleController：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

using YKT.Model;
using YKT.BLL;
using YKT.IBLL;
using YKT.Common;

namespace YKT.Controllers
{
    public class SysRoleController : BaseController
    {
        #region 初始化

        string ClassName = "SysRole"; //类名
        ISysRoleService _roleService;
        public SysRoleController()
        {
            if (_roleService == null)
            {
                _roleService = new SysRoleService();
            }
        }

        ValidationErrors validationErrors = new ValidationErrors();
        OMOPERATIONLOGTB OperLog = new OMOPERATIONLOGTB();

        #endregion

        #region 查询

        /// <summary>
        /// 列表
        /// </summary>
        /// <returns></returns>
        //[SupportFilter]
        public ActionResult Index(string view)
        {
            return View();
        }

        /// <summary>
        /// 异步加载数据
        /// </summary>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示的行数</param>
        /// <param name="order">排序字段</param>
        /// <param name="sort">升序asc（默认）还是降序desc</param>
        /// <param name="search">查询条件</param>
        /// <returns></returns>
        [HttpPost]
        //[SupportFilter]
        public JsonResult GetData(string id, int page, int rows, string order, string sort, string search)
        {
            int total = 0;
            var queryData = _roleService.GetByParam(id, page, rows, order, sort, search, ref total);

            var data = queryData.ToList().Select(m => new { ROLE_ID = m.ROLE_ID, ROLE_NAME = m.ROLE_NAME, CREATION_TIME = m.CREATION_TIME, 
REMARK = m.REMARK, STATUS = m.StatusName });

            //构造成Json的格式传递
            var result = new { total = total, rows = data };
            return Json(result, JsonRequestBehavior.AllowGet);
        }
       
        #endregion

        #region 分配权限

        /// <summary>
        /// 首次设置SysMenu
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns> 
        //[SupportFilter]
        public ActionResult SetSysMenu(string id)
        {
            var entity = _roleService.GetById(int.Parse(id));
            ViewData["myname"] = entity.ROLE_NAME;
            ViewData["myid"] = id;
            return View(entity);
        }

        /// <summary>
        /// 分配权限
        /// </summary>
        /// <param name="collection"></param>
        /// <returns></returns>   
        [HttpPost]
        //[SupportFilter]
        public ActionResult Save(FormCollection collection)
        {
            string returnValue = string.Empty;
            string[] ids = collection["ids"].GetString().Split(',');
            int id = collection["id"].GetInt();
            int userId = GetCurrentAccount().USER_ID;

            OperLog = new OMOPERATIONLOGTB { OPERATION_TYPE = "U", FUNC_CODE = "900009", USER_ID = userId, CLASSNAME = ClassName + ": Save" };

            try
            {
                if (_roleService.SaveCollection(ref validationErrors, ids, id))
                {
                    OperLog.REMARK = "信息的Id为" + string.Join(",", ids) + Suggestion.InsertSucceed;
                    LogClassService.WriteServiceLog(OperLog);

                    return Json("OK");
                }
                else
                {
                    if (validationErrors != null && validationErrors.Count > 0)
                    {
                        validationErrors.All(a =>
                        {
                            returnValue += a.ErrorMessage;
                            return true;
                        });
                    }
                    OperLog.REMARK = "信息的Id为" + string.Join(",", ids) + Suggestion.InsertFail;
                    LogClassService.WriteServiceLog(OperLog);
                }
            }
            catch (Exception ex)
            {
                ExceptionsHander.WriteExceptions(ex);
            }

            return Json(returnValue);
        }

        #endregion

        #region 增

        /// <summary>
        /// 首次创建
        /// </summary>
        /// <returns></returns>
        //[SupportFilter]
        public ActionResult Create(string id)
        {
            return View();
        }
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        //[SupportFilter]
        public ActionResult Create(SMROLETB entity)
        {
            if (entity != null && ModelState.IsValid)
            {
                if (IsOracle) // 如果使用oralce数据库 +此句 
                {
                    entity.ROLE_ID = (int)GetProblemXH("SMROLETB_SEQ"); 
                }
                entity.CREATION_TIME = DateTime.Now;
                entity.CREATION_USER = GetCurrentAccount().USER_ID;

                string returnValue = string.Empty;

                OperLog = new OMOPERATIONLOGTB { OPERATION_TYPE = "N", FUNC_CODE = "010701", USER_ID = GetCurrentAccount().USER_ID, 
CLASSNAME = ClassName + ": Create" };

                if (_roleService.Create(ref validationErrors, entity))
                {
                    OperLog.REMARK = "角色:" + entity.ROLE_NAME + Suggestion.InsertSucceed;
                    LogClassService.WriteServiceLog(OperLog);//写入日志 

                    return Json(Suggestion.InsertSucceed);
                }
                else
                {
                    if (validationErrors != null && validationErrors.Count > 0)
                    {
                        validationErrors.All(a =>
                        {
                            returnValue += a.ErrorMessage;
                            return true;
                        });
                    }
                    OperLog.REMARK = "角色:" + entity.ROLE_NAME + Suggestion.InsertFail;
                    LogClassService.WriteServiceLog(OperLog);//写入日志 

                    return Json(Suggestion.InsertFail + returnValue); //提示插入失败
                }
            }

            return Json(Suggestion.InsertFail + "，请核对输入的数据的格式"); //提示输入的数据的格式不对 
        }

        #endregion

        #region 删

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="collection"></param>
        /// <returns></returns>   
        [HttpPost]
        //[SupportFilter]
        public ActionResult Delete(FormCollection collection)
        {
            string returnValue = string.Empty;

            List<int> lists = collection["query"].GetString().ToIntList();
            int[] deleteId = lists.ToArray();

            if (deleteId != null && deleteId.Length > 0)
            {
                OperLog = new OMOPERATIONLOGTB { OPERATION_TYPE = "D", FUNC_CODE = "010701", USER_ID = Convert.ToInt32(GetCurrentAccount().USER_ID),
 CLASSNAME = ClassName + ": Delete" };

                if (deleteId.Length == 1)
                {
                    if (_roleService.Delete(ref validationErrors, deleteId[0]))
                    {
                        OperLog.REMARK = "角色Id：" + deleteId[0] + Suggestion.DeleteSucceed;
                        LogClassService.WriteServiceLog(OperLog);//写入日志 

                        return Json("OK");
                    }
                    else
                    {
                        OperLog.REMARK = "角色Id：" + deleteId[0] + Suggestion.DeleteSucceed;
                    }
                    LogClassService.WriteServiceLog(OperLog);//写入日志 
                }

                #region 批量删除

                //else if (_roleService.DeleteCollection(ref validationErrors, deleteId))
                //{
                //    OperLog.REMARK ="信息的Id为" + string.Join(",", deleteId)+ Suggestion.DeleteSucceed;
                //    LogClassService.WriteServiceLog(OperLog);//写入日志 

                //    return Json("OK");
                //}
                //else
                //{
                //    if (validationErrors != null && validationErrors.Count > 0)
                //    {
                //        validationErrors.All(a =>
                //        {
                //            returnValue += a.ErrorMessage;
                //            return true;
                //        });
                //    }
                //    OperLog.REMARK = "信息的Id为" + string.Join(",", deleteId) + Suggestion.DeleteFail;

                //    LogClassService.WriteServiceLog(OperLog);//删除失败 写入日志 
                //}

                #endregion
            }
            return Json(returnValue);
        }

        #endregion

        #region 改

        /// <summary>
        /// 首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns> 
        //[SupportFilter]
        public ActionResult Edit(int id)
        {
            SMROLETB item = _roleService.GetById(id);
            return View(item);
        }
        /// <summary>
        /// 提交编辑信息
        /// </summary>
        /// <param name="id">主键</param>
        /// <param name="collection">客户端传回的集合</param>
        /// <returns></returns>
        [HttpPost]
        //[SupportFilter]
        public ActionResult Edit(int id, SMROLETB entity)
        {
            if (entity != null && ModelState.IsValid)
            {   //数据校验

                entity.UPDATE_TIME = DateTime.Now;
                entity.UPDATE_USER = GetCurrentAccount().USER_ID;
                string returnValue = string.Empty;

                OperLog = new OMOPERATIONLOGTB { OPERATION_TYPE = "U", FUNC_CODE = "010701", USER_ID = Convert.ToInt32(GetCurrentAccount().USER_ID), 
CLASSNAME = ClassName + ": Edit" };

                if (_roleService.Edit(ref validationErrors, entity))
                {
                    OperLog.REMARK = "角色:" + entity.ROLE_NAME + Suggestion.UpdateSucceed;
                    LogClassService.WriteServiceLog(OperLog);//写入日志 

                    return Json(Suggestion.UpdateSucceed); //提示更新成功 
                }
                else
                {
                    if (validationErrors != null && validationErrors.Count > 0)
                    {
                        validationErrors.All(a =>
                        {
                            returnValue += a.ErrorMessage;
                            return true;
                        });
                    }
                    OperLog.REMARK = "角色:" + entity.ROLE_NAME + Suggestion.UpdateFail + returnValue;

                    return Json(Suggestion.UpdateFail + returnValue); //提示更新失败
                }
            }
            return Json(Suggestion.UpdateFail + "请核对输入的数据的格式"); //提示输入的数据的格式不对               

        }

        #endregion

        #region 详细

        /// <summary>
        /// 查看详细
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        //[SupportFilter]
        public JsonResult Details(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                return null;
            }
            var item = _roleService.GetViewById(int.Parse(id));
            foreach (var s in item.UserNames)
            {
                item.SysPersonId += s + "，";
            }

            string usernames = string.IsNullOrWhiteSpace(item.SysPersonId) ? string.Empty : item.SysPersonId.TrimEnd('，');
            item.SysPersonId = usernames;

            return Json(item, JsonRequestBehavior.AllowGet);

        }

        #endregion
    }
}

业务逻辑层接口ISysRoleService：

/* ==============================================================================
 * 功能描述：ISysRoleService  
 * 公司名称: 雄帝
 * 创 建 者：Zouqj
 * 创建日期：2014-3-18 10:10:02
 * ==============================================================================*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using YKT.Model;

namespace YKT.IBLL
{
    /// <summary>
    /// 角色 接口
    /// </summary>
    public interface ISysRoleService
    {
        /// <summary>
        /// 查询的数据
        /// </summary>
        /// <param name="id">额外的参数</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示的行数</param>
        /// <param name="order">排序字段</param>
        /// <param name="sort">升序asc（默认）还是降序desc</param>
        /// <param name="search">查询条件</param>
        /// <param name="total">结果集的总数</param>
        /// <returns>结果集</returns>
        IQueryable<SMROLETB> GetByParam(string id, int page, int rows, string order, string sort, string search, ref int total);

        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns></returns>
        List<SMROLETB> GetAll();

        /// <summary>
        /// 获取在该表中出现的所有外键实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        List<SMUSERTB> GetRefSysPerson();

        /// <summary>
        /// 根据主键，查看详细信息
        /// </summary>
        /// <param name="id">根据主键</param>
        /// <returns></returns>
        SMROLETB GetById(int id);

        /// <summary>
        /// 通过主键id，获取角色---查看详细，首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>角色</returns>
        RoleView GetViewById(int id);

        /// <summary>
        /// 创建一个对象
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个对象</param>
        /// <returns></returns>
        bool Create(ref Common.ValidationErrors validationErrors, SMROLETB entity);

        /// <summary>
        ///  创建对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">对象集合</param>
        /// <returns></returns>
        bool CreateCollection(ref Common.ValidationErrors validationErrors, IQueryable<SMROLETB> entitys);

        /// <summary>
        /// 删除一个对象
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="id">一条数据的主键</param>
        /// <returns></returns>  
        bool Delete(ref Common.ValidationErrors validationErrors, int id);

        /// <summary>
        /// 删除对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="deleteCollection">主键的集合</param>
        /// <returns></returns>       
        bool DeleteCollection(ref Common.ValidationErrors validationErrors, int[] deleteCollection);

        /// <summary>
        /// 编辑一个对象
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个对象</param>
        /// <returns></returns>
        bool Edit(ref Common.ValidationErrors validationErrors, SMROLETB entity);

        /// <summary>
        ///  创建对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">对象集合</param>
        /// <returns></returns>
        bool EditCollection(ref Common.ValidationErrors validationErrors, IQueryable<SMROLETB> entitys);

        /// <summary>
        /// 保存对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="deleteCollection">主键的集合</param>
        /// <returns></returns>       
        bool SaveCollection(ref Common.ValidationErrors validationErrors, string[] saveCollection, int id);

    }
}

业务逻辑层SysRoleService：

/* ==============================================================================
 * 功能描述：SysRoleService  
 * 公司名称: 雄帝
 * 创 建 者：Zouqj
 * 创建日期：2014-3-18 10:14:29
 * ==============================================================================*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using YKT.IBLL;
using YKT.Model;
using YKT.DAL;
using YKT.Common;
using System.Transactions;
using YKT.Common.Functions;

namespace YKT.BLL
{
    /// <summary>
    /// 角色 
    /// </summary>
    public class SysRoleService : ISysRoleService, IDisposable
    {
        #region 初始化

        /// <summary>
        /// 私有的数据访问上下文
        /// </summary>
        protected YKTEntities db;
        /// <summary>
        /// 角色的数据库访问对象
        /// </summary>
        SysRoleRepository repository = new SysRoleRepository();
        /// <summary>
        /// 构造函数，默认加载数据访问上下文
        /// </summary>
        public SysRoleService()
        {
            db = new YKTEntities();
        }
        /// <summary>
        /// 已有数据访问上下文的方法中调用
        /// </summary>
        /// <param name="entities">数据访问上下文</param>
        public SysRoleService(YKTEntities entities)
        {
            db = entities;
        }

        #endregion

        #region 查询

        /// <summary>
        /// 查询的数据
        /// </summary>
        /// <param name="id">额外的参数</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示的行数</param>
        /// <param name="order">排序字段</param>
        /// <param name="sort">升序asc（默认）还是降序desc</param>
        /// <param name="search">查询条件</param>
        /// <param name="total">结果集的总数</param>
        /// <returns>结果集</returns>
        public IQueryable<SMROLETB> GetByParam(string id, int page, int rows, string order, string sort, string search, ref int total)
        {
            IQueryable<SMROLETB> queryData = repository.DaoChuData(db, order, sort, search);
            total = queryData.Count();
            if (total > 0)
            {
                if (page <= 1)
                {
                    queryData = queryData.Take(rows);
                }
                else
                {
                    queryData = queryData.Skip((page - 1) * rows).Take(rows);
                }

                foreach (var item in queryData)
                {
                    if (item.SMUSERTB != null)
                    {
                        item.SysPersonId = string.Empty;
                        foreach (var it in item.SMUSERTB)
                        {
                            item.SysPersonId += it.USER_NAME + ' ';
                        }
                        item.StatusName = SelectListClass.GetStatusName(item.STATUS);
                    }

                }

            }
            return queryData;
        }

        /// <summary>
        /// 获取在该表一条数据中，出现的所有外键实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>外键实体集合</returns>
        public List<SMUSERTB> GetRefSysPerson(int id)
        {
            return repository.GetRefSysPerson(db, id).ToList();
        }
        /// <summary>
        /// 获取在该表中出现的所有外键实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>外键实体集合</returns>
        public List<SMUSERTB> GetRefSysPerson()
        {
            return repository.GetRefSysPerson(db).ToList();
        }

        #endregion

        #region 分配权限

        public bool SaveCollection(ref ValidationErrors validationErrors, string[] ids, int id)
        {
            char split = '^';
            var data = (
                from f in ids
                where f.Contains(split)
                select f.Substring(0, f.IndexOf(split))
                        ).Union(
                from f in ids
                where !string.IsNullOrWhiteSpace(f) && !f.Contains(split)
                select f);

            using (TransactionScope transactionScope = new TransactionScope())
            {
            List<int> lists = new List<int>();
            if (data != null && data.Count() > 0)
            {
                foreach (var v in data)
                {
                    lists.Add(int.Parse(v));
                }
            }
            if (db.Connection.State == System.Data.ConnectionState.Closed)
            {
                db.Connection.Open();
            }

            //利用编码机制，查询出所有的菜单
            var SysMenusIds = db.SMMENUTB.Where(w => lists.Contains(w.ID)).Select(s => s.ID).Distinct();

            StringBuilder builder = new StringBuilder();
            builder.AppendFormat("DELETE FROM  SMMENUROLEFUNCTB WHERE ROLEID = {0};", id);//删除该角色的所有的菜单和操作

            foreach (var item in SysMenusIds)
            {//插入菜单
                builder.AppendFormat("INSERT INTO SMMENUROLEFUNCTB(ROLEID,MENUID) VALUES({0},{1});"
                   , id, item);
            }

            foreach (var item in ids)
            {//插入操作
                if (item.Contains(split))
                {
                    builder.AppendFormat("INSERT INTO SMMENUROLEFUNCTB(ROLEID,MENUID,FUNC_ID) VALUES({0},{1},{2});"
                   , id, item.Substring(0, item.IndexOf(split)), item.Substring(item.IndexOf(split) + 1));
                }
            }
           
            db.ExecuteStoreCommand(builder.ToString());
            db.SaveChanges();
            transactionScope.Complete();
            return true;

            }
        }

        #endregion

        #region 增

        /// <summary>
        /// 创建一个角色
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="db">数据库上下文</param>
        /// <param name="entity">一个角色</param>
        /// <returns></returns>
        public bool Create(ref ValidationErrors validationErrors, YKTEntities db, SMROLETB entity)
        {
            int count = 1;

            foreach (int item in entity.SysPersonId.GetIdSort())
            {
                SMUSERTB sys = new SMUSERTB { USER_ID = item };
                db.SMUSERTB.Attach(sys);
                entity.SMUSERTB.Add(sys);
                count++;
            }

            repository.Create(db, entity);
            if (count == repository.Save(db))
            {
                return true;
            }
            else
            {
                validationErrors.Add("创建出错了");
            }
            return false;
        }
        /// <summary>
        /// 创建一个角色
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个角色</param>
        /// <returns></returns>
        public bool Create(ref ValidationErrors validationErrors, SMROLETB entity)
        {
            try
            {
                using (TransactionScope transactionScope = new TransactionScope())
                {
                    if (Create(ref validationErrors, db, entity))
                    {
                        transactionScope.Complete();
                        return true;
                    }
                    else
                    {
                        Transaction.Current.Rollback();
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        ///  创建角色集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">角色集合</param>
        /// <returns></returns>
        public bool CreateCollection(ref ValidationErrors validationErrors, IQueryable<SMROLETB> entitys)
        {
            try
            {
                if (entitys != null)
                {
                    int flag = 0, count = entitys.Count();
                    if (count > 0)
                    {
                        using (TransactionScope transactionScope = new TransactionScope())
                        {
                            foreach (var entity in entitys)
                            {
                                if (Create(ref validationErrors, db, entity))
                                {
                                    flag++;
                                }
                                else
                                {
                                    Transaction.Current.Rollback();
                                    return false;
                                }
                            }
                            if (count == flag)
                            {
                                transactionScope.Complete();
                                return true;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }


        public List<SMROLETB> GetAll()
        {
            return repository.GetAll(db).ToList();
        }

        #endregion

        #region 删

        /// <summary>
        /// 删除一个角色
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="id">一个角色的主键</param>
        /// <returns></returns>  
        public bool Delete(ref ValidationErrors validationErrors, int id)
        {
            try
            {
                return repository.Delete(id) == 1;
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        /// 删除角色集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="deleteCollection">主键的角色</param>
        /// <returns></returns>    
        public bool DeleteCollection(ref ValidationErrors validationErrors, int[] deleteCollection)
        {
            try
            {
                if (deleteCollection != null)
                {

                    using (TransactionScope transactionScope = new TransactionScope())
                    {
                        repository.Delete(db, deleteCollection);
                        if (deleteCollection.Length == repository.Save(db))
                        {
                            transactionScope.Complete();
                            return true;
                        }
                        else
                        {
                            Transaction.Current.Rollback();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }

        #endregion

        #region 改

        /// <summary>
        /// 编辑一个角色
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="db">数据上下文</param>
        /// <param name="entity">一个角色</param>
        /// <returns>是否编辑成功</returns>
        public bool Edit(ref ValidationErrors validationErrors, YKTEntities db, SMROLETB entity)
        {  /*                       
                           * 不操作 原有 现有
                           * 增加   原没 现有
                           * 删除   原有 现没
                           */
            if (entity == null)
            {
                return false;
            }
            int count = 1;
            SMROLETB editEntity = repository.Edit(db, entity);

            List<int> addSysPersonId = new List<int>();
            List<int> deleteSysPersonId = new List<int>();
            DataOfDiffrent.GetDiffrent(entity.SysPersonId.GetIdSort(), entity.SysPersonIdOld.GetIdSort(), ref addSysPersonId, ref deleteSysPersonId);
            if (addSysPersonId != null && addSysPersonId.Count() > 0)
            {
                foreach (var item in addSysPersonId)
                {
                    SMUSERTB sys = new SMUSERTB { USER_ID = item };
                    db.SMUSERTB.Attach(sys);
                    editEntity.SMUSERTB.Add(sys);
                    count++;
                }
            }
            if (deleteSysPersonId != null && deleteSysPersonId.Count() > 0)
            {
                List<SMUSERTB> listEntity = new List<SMUSERTB>();
                foreach (var item in deleteSysPersonId)
                {
                    SMUSERTB sys = new SMUSERTB { USER_ID = item };
                    listEntity.Add(sys);
                    db.SMUSERTB.Attach(sys);
                }
                foreach (SMUSERTB item in listEntity)
                {
                    editEntity.SMUSERTB.Remove(item);//查询数据库
                    count++;
                }
            }

            if (count == repository.Save(db))
            {
                return true;
            }
            else
            {
                validationErrors.Add("编辑角色出错了");
            }
            return false;
        }
        /// <summary>
        /// 编辑一个角色
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个角色</param>
        /// <returns>是否编辑成功</returns>
        public bool Edit(ref ValidationErrors validationErrors, SMROLETB entity)
        {
            try
            {
                using (TransactionScope transactionScope = new TransactionScope())
                {
                    if (db.Connection.State == System.Data.ConnectionState.Closed) 
                    {
                        db.Connection.Open();
                    }
                    if (Edit(ref validationErrors, db, entity))
                    {
                        transactionScope.Complete();
                        return true;
                    }
                    else
                    {
                        Transaction.Current.Rollback();
                    }
                }
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }

        /// <summary>
        ///  编辑角色集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">角色集合</param>
        /// <returns></returns>
        public bool EditCollection(ref ValidationErrors validationErrors, IQueryable<SMROLETB> entitys)
        {
            if (entitys != null)
            {
                try
                {
                    int flag = 0, count = entitys.Count();
                    if (count > 0)
                    {
                        using (TransactionScope transactionScope = new TransactionScope())
                        {
                            foreach (var entity in entitys)
                            {
                                if (Edit(ref validationErrors, db, entity))
                                {
                                    flag++;
                                }
                                else
                                {
                                    Transaction.Current.Rollback();
                                    return false;
                                }
                            }
                            if (count == flag)
                            {
                                transactionScope.Complete();
                                return true;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    validationErrors.Add(ex.Message);
                    ExceptionsHander.WriteExceptions(ex);
                }
            }
            return false;
        }

        #endregion

        #region 详细

        /// <summary>
        /// 根据主键获取一个角色
        /// </summary>
        /// <param name="id">角色的主键</param>
        /// <returns>一个角色</returns>
        public SMROLETB GetById(int id)
        {
            return repository.GetById(db, id);
        }

        /// <summary>
        /// 通过主键id，获取角色---查看详细，首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>角色</returns>
        public RoleView GetViewById(int id)
        {
            return repository.GetViewById(db, id);
        }

        #endregion

        public void Dispose()
        {

        }

    }
}

数据访问层SysRoleRepository：

/* ==============================================================================
 * 功能描述：SysRoleRepository  
 * 公司名称: 雄帝
 * 创 建 者：Zouqj
 * 创建日期：2014-3-18 10:15:39
 * ==============================================================================*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using YKT.Model;
using YKT.Common;

namespace YKT.DAL
{
    /// <summary>
    /// 角色
    /// </summary>
    public class SysRoleRepository : BaseRepository<SMROLETB>, IDisposable
    {

        #region  查询

        /// <summary>
        /// 查询的数据
        /// </summary>
        /// <param name="YKTEntities">数据访问的上下文</param>
        /// <param name="order">排序字段</param>
        /// <param name="sort">升序asc（默认）还是降序desc</param>
        /// <param name="search">查询条件</param> 
        /// <param name="listQuery">额外的参数</param>
        /// <returns></returns>      
        public IQueryable<SMROLETB> DaoChuData(YKTEntities db, string order, string sort, string search, params object[] listQuery)
        {
            string where = string.Empty;
            int flagWhere = 0;

            Dictionary<string, string> queryDic = ValueConvert.StringToDictionary(search.GetString());
            if (queryDic != null && queryDic.Count > 0)
            {
                foreach (var item in queryDic)
                {
                    if (flagWhere != 0)
                    {
                        where += " and ";
                    }
                    flagWhere++;

                    if (!string.IsNullOrWhiteSpace(item.Key) && !string.IsNullOrWhiteSpace(item.Value) && item.Key.Equals("STATUS")) //需要查询的列名
                    {
                        where += "it." + item.Key + " = '" + item.Value + "'";
                        continue;
                    }
                    where += "it." + item.Key + " like '%" + item.Value + "%'";
                }
            }
            return db.SMROLETB
                     .Where(string.IsNullOrEmpty(where) ? "true" : where)
                     .OrderBy("it." + sort.GetString() + " " + order.GetString())
                     .AsQueryable();
        }

        /// <summary>
        /// 获取在该表一条数据中，出现的所有外键实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>外键实体集合</returns>
        public IQueryable<SMUSERTB> GetRefSysPerson(int id)
        {
            using (YKTEntities db = new YKTEntities())
            {
                return GetRefSysPerson(db, id);
            }
        }
        /// <summary>
        /// 获取在该表一条数据中，出现的所有外键实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>外键实体集合</returns>
        public IQueryable<SMUSERTB> GetRefSysPerson(YKTEntities db, int id)
        {
            return from m in db.SMROLETB
                   from f in m.SMUSERTB
                   where m.ROLE_ID == id
                   select f;

        }
        /// <summary>
        /// 获取在该表中出现的所有外键实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>外键实体集合</returns>
        public IQueryable<SMUSERTB> GetRefSysPerson(YKTEntities db)
        {
            return from m in db.SMROLETB
                   from f in m.SMUSERTB
                   select f;
        }
        /// <summary>
        /// 获取在该表中出现的所有外键实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>外键实体集合</returns>
        public IQueryable<SMUSERTB> GetRefSysPerson()
        {
            using (YKTEntities db = new YKTEntities())
            {
                return GetRefSysPerson(db);
            }
        }

        #endregion

        #region 详细

        /// <summary>
        /// 通过主键id，获取角色---查看详细，首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>角色</returns>
        public SMROLETB GetById(int id)
        {
            using (YKTEntities db = new YKTEntities())
            {
                return GetById(db, id);
            }
        }
        /// <summary>
        /// 通过主键id，获取角色---查看详细，首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>角色</returns>
        public SMROLETB GetById(YKTEntities db, int id)
        {
            return db.SMROLETB.SingleOrDefault(s => s.ROLE_ID == id);
        }

        /// <summary>
        /// 通过主键id，获取角色---查看详细，首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>角色</returns>
        public RoleView GetViewById(int id)
        {
            using (YKTEntities db = new YKTEntities())
            {
                return GetViewById(db, id);
            }
        }
        /// <summary>
        /// 通过主键id，获取角色---查看详细，首次编辑
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>角色</returns>
        public RoleView GetViewById(YKTEntities db, int id)
        {
            var role = (from m in db.SMROLETB
                       where m.ROLE_ID == id select m).ToList().Select(m=>
                       new RoleView
                       {
                           ROLE_ID = m.ROLE_ID,
                           ROLE_NAME = m.ROLE_NAME,
                           CREATION_TIME = m.CREATION_TIME,
                           UPDATE_TIME = m.UPDATE_TIME,
                           CreateUserName = m.SMUSERTB.Where(x => x.USER_ID == m.CREATION_USER).Select(x=>x.USER_NAME).FirstOrDefault(),
                           REMARK = m.REMARK,
                           UpdateUserName = m.SMUSERTB.Where(x => x.USER_ID == m.UPDATE_USER).Select(x=>x.USER_NAME).FirstOrDefault(),
                           STATUS = m.STATUS,
                           StatusName = SelectListClass.GetStatusName(m.STATUS),
                           UserNames = m.SMUSERTB.Select(x=>x.USER_NAME).ToList()
                       });
            return role.FirstOrDefault();
        }

        #endregion

        #region 删

        /// <summary>
        /// 确定删除一个对象，调用Save方法
        /// </summary>
        /// <param name="id">一条数据的主键</param>
        /// <returns></returns>    
        public int Delete(int id)
        {
            using (YKTEntities db = new YKTEntities())
            {
                this.Delete(db, id);
                return Save(db);
            }
        }
        /// <summary>
        /// 删除一个角色
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <param name="id">一条角色的主键</param>
        public void Delete(YKTEntities db, int id)
        {
            SMROLETB deleteItem = GetById(db, id);
            if (deleteItem != null)
            {
                db.SMROLETB.DeleteObject(deleteItem);
            }
        }
        /// <summary>
        /// 删除对象集合
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <param name="deleteCollection">主键的集合</param>
        public void Delete(YKTEntities db, int[] deleteCollection)
        {
            //数据库设置级联关系，自动删除子表的内容   
            IQueryable<SMROLETB> collection = from f in db.SMROLETB
                                              where deleteCollection.Any(x => x == f.ROLE_ID)
                                              select f;
            foreach (var deleteItem in collection)
            {
                db.SMROLETB.DeleteObject(deleteItem);
            }
        }

        #endregion

        public void Dispose()
        {
        }
    }
}

数据库访问基类BaseRepository，这里使用仓储模式进行设计，如下：

/*Company:EMPEROR*/
/*Author:Zouqj*/
/*Date:2014-02-19*/
using System.Linq;
using System.Data;
using System;
using System.Data.Common;
using System.Data.Objects;
using YKT.Model;
using System.Linq.Expressions;

namespace YKT.DAL
{
    /// <summary>   
    /// 实现对数据库的操作(增删改查)的基类     
    /// </summary>
    /// <typeparam name="T">定义泛型，约束其是一个类</typeparam>
    public class BaseRepository<T> where T : class
    {
        public string Start_Time { get { return "Start_Time"; } }
        public string End_Time { get { return "End_Time"; } }
        public string Start_Int { get { return "Start_Int"; } }
        public string End_Int { get { return "End_Int"; } }

        public string End_String { get { return "End_String"; } }
        public string DDL_String { get { return "DDL_String"; } }

        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns>集合</returns>
        public virtual IQueryable<T> GetAll()
        {
            using (YKTEntities db = new YKTEntities())
            {
                return GetAll(db);
            }
        }
        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns>集合</returns>
        public virtual IQueryable<T> GetAll(YKTEntities db)
        {
            return db.CreateObjectSet<T>().AsQueryable();
        }
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <param name="entity">将要创建的对象</param>
        public virtual void Create(YKTEntities db, T entity)
        {
            if (entity != null)
            {
                //EF4.0的写法   添加实体
                db.CreateObjectSet<T>().AddObject(entity);
            }
        }
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="entity">一个对象</param>
        /// <returns></returns>
        public virtual int Create(T entity)
        {
            using (YKTEntities db = new YKTEntities())
            {
                Create(db, entity);
                return this.Save(db);
            }
        }
        /// <summary>
        /// 创建对象集合
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <param name="entitys">对象集合</param>
        public virtual void Create(YKTEntities db, IQueryable<T> entitys)
        {
            foreach (var entity in entitys)
            {
                this.Create(db, entity);
            }
        }
        /// <summary>
        /// 编辑一个对象
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <param name="entity">将要编辑的一个对象</param>
        public virtual T Edit(YKTEntities db, T entity)
        {
            db.CreateObjectSet<T>().Attach(entity);
            db.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
            return entity;
        }
        /// <summary>
        /// 编辑对象集合
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <param name="entitys">对象集合</param>
        public virtual void Edit(YKTEntities db, IQueryable<T> entitys)
        {
            foreach (T entity in entitys)
            {
                this.Edit(db, entity);
            }
        }
        /// <summary>
        /// 提交保存，持久化到数据库
        /// </summary>
        /// <param name="db">实体数据</param>
        /// <returns>受影响行数</returns>
        public int Save(YKTEntities db)
        {
            return db.SaveChanges();
        }
    }
}

视图层：

Index.cshtml：

@using YKT.BLL
@using YKT.Common;
@model YKT.Model.SMROLETB
@{
    ViewBag.Title = "角色管理";
    Layout = "~/Views/Shared/Base.cshtml";
}
<script type="text/javascript" language="javascript">
    //回车触发查询
    $(function () {
        document.onkeydown = function (e) {
            var ev = document.all ? window.event : e;
            if (ev.keyCode == 13) {
                flexiQuery();
            }
        }
    });
    $(function () {
        var flag = window.location.search;
        var isSingleSelect = true;
        if (flag == "?view=1") {
            isSingleSelect = false;
        }
        var searchH = $("#divQuery").height();
        var h = document.documentElement.clientHeight - searchH - 26;
        $('#flexigridData').datagrid({
            title: '角色', //列表的标题
            iconCls: 'icon-site',
            //                fit: true, //列表自动适应宽度
            width: 'auto',
            singleSelect: isSingleSelect, //是否单选行
            selectOnCheck: true, //选中行时复选框选中
            checkOnSelect: true, //选中复选框时选中行
            height: h,
            nowrap: false, //True 就会把数据显示在一行里。
            striped: true, //True 就把行条纹化。（即奇偶行使用不同背景色）
            collapsible: true, //可调节列宽
            remoteSort: true, //定义是否从服务器给数据排序。
            url: 'SysRole/GetData', //获取数据的url
            sortName: 'ROLE_ID', //定义可以排序的列
            sortOrder: 'desc', //定义列的排序顺序，只能用 'asc' 或 'desc'
            idField: 'ROLE_ID', //标识字段
            onDblClickRow: function (rowIndex, rowData) {
                getDetail(rowData["ROLE_ID"]);
            } //双击显示详情
           ,
            toolbar: [
                   {
                       text: '分配权限',
                       iconCls: 'icon-search',
                       handler: function () {
                           flexiSetSysMenu();
                       }
                   }],
            columns: [[
                    { field: 'ck', checkbox: true },//复选框
					{ field: 'ROLE_NAME', title: '@Html.LabelFor(model => model.ROLE_NAME)', width: 125, sortable: true }
					, { field: 'STATUS', title: '@Html.LabelFor(model => model.STATUS)', width: 80, sortable: true }
                    , { field: 'CREATION_TIME', title: '@Html.LabelFor(model => model.CREATION_TIME)', width: 130, sortable: true
                    , formatter: function (value, rec) {
                        if (value) {
                            return dateTimeConvert(value);
                        }
                    }
                    }
					, { field: 'REMARK', title: '@Html.LabelFor(model => model.REMARK)', sortable: true }

                ]],
            pagination: true, //在 datagrid 的底部显示分页栏。
            rownumbers: true //显示行号的列

        });

        //如果列表页出现在弹出框中，则只显示查询和选择按钮 
        var parent = window.dialogArguments; //获取父页面
        //异步获取按钮          
        if (parent == "undefined" || parent == null) {
            //首先获取iframe标签的id值

            var iframeid = window.parent.$('#tabs').tabs('getSelected').find('iframe').attr("id");

            //然后关闭AJAX相应的缓存
            $.ajaxSetup({
                cache: false
            });

            //获取按钮值
            $.getJSON("../Home/GetToolbar", { id: iframeid }, function (data) {
                if (data == null) {
                    return;
                }
                $('#flexigridData').datagrid("addToolbarItem", data);

            });

        } else {
            //添加选择按钮
            $('#flexigridData').datagrid("addToolbarItem", [{ "text": "选择", "iconCls": "icon-ok", handler: function () { flexiSelect(); } }]);
        }

    });

    //“查询”按钮，弹出查询框
    function flexiQuery() {
        //将查询条件按照分隔符拼接成字符串
        var search = "";
        $('#divQuery').find(":text,:selected,select,textarea,:hidden,:checked,:password").each(function () {
            search = search + this.id + "&" + this.value + "^";
        });
        //执行查询                        
        $('#flexigridData').datagrid('reload', { search: search });
    }
    function resetData() {
        $("#ROLE_NAME").val("");
        $('#STATUS')[0].selectedIndex = 0;
    }

    //“选择”按钮，在其他（与此页面有关联）的页面中，此页面以弹出框的形式出现，选择页面中的数据
    function flexiSelect() {

        var rows = $('#flexigridData').datagrid('getSelections');
        if (rows.length == 0) {
            $.messager.alert('操作提示', '请选择数据!', 'warning');
            return false;
        }
        var arr = [];
        for (var i = 0; i < rows.length; i++) {
            arr.push(rows[i].ROLE_ID);
        }
        arr.push("^");
        for (var f = 0; f < rows.length; f++) {
            arr.push(rows[f].ROLE_NAME);
        }
        //主键列和显示列之间用 ^ 分割   每一项用 , 分割
        if (arr.length > 0) {//一条数据和多于一条
            returnParent(arr.join("&")); //每一项用 & 分割
        }
    }
    //导航到查看详细的按钮
    function getView() {
        //首先取出来用户选择的数据的ID
        var rows = $("#flexigridData").datagrid("getSelections");
        //首先取出来值判断用户只能选择一个
        if (rows.length != 1) {
            $.messager.alert("友情提示", "每次只能修改/浏览一条，你已经选择了<font color='red'  size='6'>" + rows.length + "</font>条", "error");
            return;
        }
        var id = rows[0].ROLE_ID;
        getDetail(id);
    };

    function getDetail(id) {
        //处理浏览的信息，弹出浏览狂，然后显示浏览信息的相信信息
        $("#DivBrowerRole").dialog('open').dialog('setTitle', '角色浏览信息');
        //构造参数发送给后台
        $.get("/SysRole/Details", { "id": id }, function (roleInfo) {
            $("#v_Name").text(roleInfo.ROLE_NAME);
            $("#v_CreateTime").text(dateTimeConvert(roleInfo.CREATION_TIME));
            $("#v_CreateUser").text(roleInfo.CreateUserName);
            $("#v_UpdateTime").text(dateTimeConvert(roleInfo.UPDATE_TIME));

            $("#v_UpdateUser").text(roleInfo.UpdateUserName);
            $("#v_Remark").text(roleInfo.REMARK)

            $("#v_UserNames").text(roleInfo.SysPersonId);
            $("#v_Status").text(roleInfo.StatusName);

        });
    }

    //导航到创建的按钮
    function flexiCreate() {
        //window.location.href = "../SysRole/Create";
        showMyWindow("#myWin", "创建角色", "../SysRole/Create", 680, 316);
        return false;
    }
    //导航到修改的按钮
    function flexiModify() {

        var arr = $('#flexigridData').datagrid('getSelections');

        if (arr.length == 1) {
            showMyWindow("#myWin", "修改角色", "../SysRole/Edit/" + arr[0].ROLE_ID, 680, 316);
        } else {
            $.messager.alert('操作提示', '请选择一条数据!', 'warning');
        }
        return false;

    };
    //删除的按钮
    function flexiDelete() {

        var rows = $('#flexigridData').datagrid('getSelections');
        if (rows.length == 0) {
            $.messager.alert('操作提示', '请选择数据!', 'warning');
            return false;
        }

        var arr = [];
        for (var i = 0; i < rows.length; i++) {
            arr.push(rows[i].ROLE_ID);
        }

        $.messager.confirm('操作提示', "确认删除这 " + arr.length + " 项吗？", function (r) {
            if (r) {
                $.post("../SysRole/Delete", { query: arr.join(",") }, function (res) {
                    if (res == "OK") {
                        //移除删除的数据
                        $("#flexigridData").datagrid("reload");
                        $("#flexigridData").datagrid("clearSelections");
                        $.messager.alert('操作提示', '删除成功!', 'info');
                    }
                    else {
                        if (res == "") {
                            $.messager.alert('操作提示', '删除失败!请查看该数据与其他模块下的信息的关联，或联系管理员。', 'info');
                        }
                        else {
                            $.messager.alert('操作提示', res, 'info');
                        }
                    }
                });
            }
        });

    };
    //分配权限
    flexiSetSysMenu = function () {
        var arr = $('#flexigridData').datagrid('getSelections');

        if (arr.length == 1) {
            window.location.href = "../SysRole/SetSysMenu/" + arr[0].ROLE_ID;

        } else {
            $.messager.alert('操作提示', '请选择一条数据!', 'warning');
        }
        return false;


    };
</script>
<div id="content" region="center" fit="true">
<div id="divQuery" style="padding: 5px; font-size: 12px;" title="查询列表" class="easyui-toolbar">
    <span>@Html.LabelFor(model => model.ROLE_NAME)</span><input type='text' id='ROLE_NAME' class="easyui-validatebox" />
    <span>@Html.LabelFor(model => model.STATUS)</span> <span>@Html.DropDownListFor(model => model.STATUS, SelectListClass.GetStatus(true), false)</span>
    <a href="javascript:flexiQuery()" class="easyui-linkbutton" data-options="iconCls:'icon-search'">查询</a> 
    <a href="javascript:resetData()" class="easyui-linkbutton" data-options="iconCls:'icon-redo'"> 重置</a>
</div>

<table id="flexigridData">
</table>
</div>
<!------------------------弹出角色浏览信息的弹出层---------------------------------->
<div id="DivBrowerRole" class="easyui-dialog" style="width: 700px; height:260px;
    padding: 10px 20px" closed="true" resizable="true" modal="true" buttons="#dlg-buttons">
    <fieldset>
        <legend>角色浏览信息</legend>
        <table id="tblBrower" class="usertableborder2" cellspacing="1" cellpadding="3" width="98%"
            align="center" border="0">
            <tr class="usertablerow1">
                <td class="_width">
                    名称：
                </td>
                <td class="width4">
                    <span id="v_Name"></span>
                </td>
                <td class="width0">
                    创建时间：
                </td>
                <td class="time">
                    <span id="v_CreateTime"></span>
                </td>
                <td class="_width">
                    状态：
                </td>
                <td class="width1">
                    <span id="v_Status"></span>
                </td>
            </tr>
            <tr class="usertablerow2">
                <td>
                    创建人：
                </td>
                <td>
                    <span id="v_CreateUser"></span>
                </td>
                <td>
                    编辑时间：
                </td>
                <td>
                    <span id="v_UpdateTime"></span>
                </td>
                <td>
                    编辑人：
                </td>
                <td>
                    <span id="v_UpdateUser"></span>
                </td>
            </tr>
            <tr class="usertablerow1">
                <td nowrap="noWrap">
                    描述：
                </td>
                <td colspan="5" class="remark">
                    <div id="v_Remark" style="word-break: break-all">
                    </div>
                </td>
            </tr>
            <tr class="usertablerow2">
                <td>
                    人员：
                </td>
                <td colspan="5" class="remark">
                    <div id="v_UserNames" style="word-break: break-all">
                    </div>
                </td>
            </tr>
        </table>
    </fieldset>
</div>
<!-------------------------创建和修改层---------------------------------->
<div id="myWin"></div>

Create.cshtml：

@using YKT.BLL;
@using YKT.Common.HtmlHelpers;
@using YKT.Common;
@model YKT.Model.SMROLETB
@{
    ViewBag.SubTitle = "角色 创建";
    Layout = "~/Views/Shared/Save.cshtml";
}

@Html.ValidationSummary(true, "角色创建不成功. 请修改后重试")

@using (Html.BeginForm((string)ViewBag.FormAction, "SysRole",FormMethod.Post,new {id = "form1" }))
{                  <table id="tbCreate" class="usertableborder" align="center">
                    <tr class="usertablerow1">
                        <td class="_width">   @Html.LabelFor(model => model.ROLE_NAME)：</td>
                        <td>
                  <input type="text" name="ROLE_NAME" class="easyui-validatebox"  required="true" missingMessage="不能为空" validType="length[0,20]" 
invalidMessage="长度不可超过20"/>
                        </td>           
                        <td class="_width">   @Html.LabelFor(model => model.STATUS)：</td>
                        <td class="width2">
                              @Html.RadioButtonListFor(model => model.STATUS, SelectListClass.GetStatus(false), true)
                        </td>
                    </tr>
                    <tr>
                        <td>   @Html.LabelFor(model => model.REMARK)：</td>
                                  <td colspan="2" style="word-break: break-all; overflow-x:hidden;" class="remark">
                <textarea  cols="30" name="REMARK" rows="3" class="easyui-validatebox" validType="length[0,100]" invalidMessage="长度不可超过100">
</textarea>
            </td>
            <td></td>
                    </tr>
                    <tr class="usertablerow1">
                        <td>            <a class="anUnderLine" onclick="showModalMany('SysPersonId','../../SysUser?view=1');">
                @Html.LabelFor(model => model.SysPersonId)</a></td>
                        <td colspan="3">
                                  <div class="selectList">    
        <ul  id="checkSysPersonId">
                @if (Model != null && !string.IsNullOrWhiteSpace(Model.SysPersonId))
                {
                    foreach (var item8 in Model.SysPersonId.Split('^'))
                    {
                        string[] it = item8.Split('&');
                        if (it != null && it.Length == 2 && !string.IsNullOrWhiteSpace(it[0]) && !string.IsNullOrWhiteSpace(it[1]))
                        {                        
                <li id="@item8"> <img  alt="删除" title="点击删除" onclick="deleteTable('@item8 ','SysPersonId');" 
 src="../../../Images/deleteimge.png" /> @it[1]</li>
                        }
                    }
                }
                </ul>
               @Html.HiddenFor(model => model.SysPersonId)
            </div>
                 </td>
                    </tr>
                    <tr  class="usertablerow2"><td colspan="4" style="text-align:center; height:30px;"> 
                     <a href='#' onclick='$("form").submit()' class="easyui-linkbutton" data-options="iconCls:'icon-add'">添加</a> 
                                     <a href='#' onclick="javascript:resetData()" class="easyui-linkbutton" data-options="iconCls:'icon-redo'"> 重置</a> 
                <a href='#' onclick="javascript:formClose();" class="easyui-linkbutton" data-options="iconCls:'icon-undo'"> 取消</a>
                    </td></tr>
                </table>
}

Edit.cshtml：

@model YKT.Model.SMROLETB
@using YKT.BLL;
@using YKT.Common.HtmlHelpers;
@using YKT.Common;
@{
    ViewBag.SubTitle = "修改 角色";
    Layout = "~/Views/Shared/Save.cshtml";
}
@using (Html.BeginForm((string)ViewBag.FormAction, "SysRole",FormMethod.Post,new {id = "form1" }))
{ 
    @Html.HiddenFor(model => model.ROLE_ID)   
    @Html.HiddenFor(model => model.CREATION_TIME)@Html.HiddenFor(model => model.CREATION_USER) 
    <table id="tbEdit" class="usertableborder" align="center">
        <tr class="usertablerow1">
            <td class="_width">
                @Html.LabelFor(model => model.ROLE_NAME)：
            </td>
            <td>
            <input type="text" name="ROLE_NAME" value='@Html.ValueFor(model => model.ROLE_NAME)' class="easyui-validatebox"  
required="true" missingMessage="不能为空" validType="length[0,20]" invalidMessage="长度不可超过20"/>
            </td>
            <td class="_width">
                @Html.LabelFor(model => model.STATUS)：
            </td>
            <td class="width2">
                @Html.RadioButtonListFor(model => model.STATUS, SelectListClass.GetStatus(false), true)
            </td>
        </tr>
        <tr>
            <td>
                @Html.LabelFor(model => model.REMARK)：
            </td>
            <td colspan="2" style="word-break: break-all;overflow-x:hidden;" class="remark">
                <textarea rows="3" cols="30" name="REMARK" class="easyui-validatebox" validType="length[0,100]" 
invalidMessage="长度不可超过100">@Html.ValueFor(model => model.REMARK)</textarea>
            </td>
            <td></td>
        </tr>
        <tr class="usertablerow1">
            <td>
                     <a class="anUnderLine" onclick="showModalMany('SysPersonId','../../SysUser?view=1');">
            @Html.LabelFor(model => model.SysPersonId)
        </a>
            </td>
            <td colspan="3">
                  <div class="selectList">
            @if (Model != null)
            {
                string ids8 = string.Empty;
                <ul id="checkSysPersonId">
                    @foreach (var item8 in Model.SMUSERTB)
                    {
                        string item81 = string.Empty;
                        item81 += item8.USER_ID + "&" + item8.USER_NAME;
                        if (ids8.Length > 0)
                        {
                            ids8 += "^" + item81;
                        }
                        else
                        {
                            ids8 += item81;
                        }
                        <li id="@item81">
                            <img  alt="删除" title="点击删除" onclick="deleteTable('@item81','SysPersonId');"  src="../../../Images/deleteimge.png" />
                            @item8.USER_NAME</li>
                    }
                </ul>
                <input type="hidden" value="@ids8" name="SysPersonIdOld" id="SysPersonIdOld" />
                <input type="hidden" value="@ids8" name="SysPersonId" id="SysPersonId" />
            }
        </div>
            </td>
        </tr>
        <tr class="usertablerow2">
            <td colspan="4" style="text-align: center; height: 30px;">
                   <a href='#' onclick='$("form").submit()'  class="easyui-linkbutton" data-options="iconCls:'icon-edit'">修改</a> 
                                   <a href='#' onclick="javascript:resetData()" class="easyui-linkbutton" data-options="iconCls:'icon-redo'"> 重置</a> 
                <a href='#' onclick="javascript:formClose();" class="easyui-linkbutton" data-options="iconCls:'icon-undo'"> 取消</a>
            </td>
        </tr>
    </table>
}  

SetSysMenu.cshtml：

@{
    ViewBag.Title = "SetSysMenu";
    Layout = "~/Views/Shared/Base.cshtml";
}

 <script type="text/javascript">
     $(function () {
         var h = document.documentElement.clientHeight - 26;
         $('#flexigridData').treegrid({
             title: ' 当前角色是：@ViewData["myname"]',
             iconCls: 'icon-site',
             url: '../../SysMenu/GetAllMetadata2/' + $("#SysRoleId").val(),
             idField: 'ID',
             treeField: 'NAME',
             height:h,
             rownumbers: true,

             toolbar: [
                    {
                        text: '保存',
                        iconCls: 'icon-save',
                        handler: function () {
                            return getView();
                        }
                    }, {
                        text: '全选',
                        iconCls: 'icon-ok',
                        handler: function () {
                            return flexiCreate();
                        }
                    }, {
                        text: '全不选',
                        iconCls: 'icon-remove',
                        handler: function () {
                            return flexiDelete();
                        }
                    }, {
                        text: '取消',
                        iconCls: 'icon-undo',
                        handler: function () {
                            return flexiModify();
                        }
                    }],

             columns: [[

                    	{ field: 'NAME', title: '菜单', width: 205
                                        , formatter: function (value, rec) {
                                            if (value) {
                                                return '<input id="' + rec.ID + '" type="checkbox">' + (value);
                                            }
                                        }
                    	}
					, { field: 'isCheck', title: '操作', width: 599, formatter: function (value, rec) {
					    if (value) {
					        var index = value.split(","); //分割符 , 的位置
					        if (index[0] == null || index[0] == "undefined" || index[0].length < 1) {
					            return;
					        }
					        var content = ""; //需要添加到check中的内容 
					        for (var i = 0; i < index.length; i++) {
					            var view = index[i].split('^'); //显示值
					            if (view != null) {
					                content += '<input id="' + rec.ID + '^' + view[0] + '" type="checkbox">' + view[1];
					            }
					        }
					        return content;
					    }
					}
					}
				    ]],
             onLoadSuccess: function (row, data) {
                 if (data) {
                     $.ajaxSetup({
                         cache: false //关闭AJAX相应的缓存
                     });
                     $.getJSON('../../SysMenu/GetAllMetadata23/' + $("#SysRoleId").val(), function (checks) {
                         $.each(checks, function (i, item) {
                             var c = document.getElementById(item);
                             c.checked = true;
                         });
                     });

                 }
             }

         });


     });


     //保存
     function getView() {
         var datas = '';
         $("input[type='checkbox']").each(function () {
             if ($(this).is(":checked"))
                 datas += ',' + $(this).attr('id');
         });
         $.post("../../SysRole/Save", { id: $("#SysRoleId").val(), ids: datas }, function (res) {
             if (res == "OK") {
                 $.messager.alert('操作提示', '保存成功!', 'info');
             }
             else {
                 if (res == "") {
                     $.messager.alert('操作提示', '保存失败!请联系管理员。', 'info');
                 }
                 else {
                     $.messager.alert('操作提示', res, 'info');
                 }
             }
         });



         return false;
     }
     //全选
     function flexiCreate() {

         $("input[type='checkbox']").each(function () {
             $(this).attr("checked", true);
         });

         return false;
     }
     //全不选
     function flexiModify() {

         window.location.href = "../../SysRole";



         return false;
     };
     //取消
     function flexiDelete() {
         $("input[type='checkbox']").each(function () {
             $(this).attr("checked", false);
         });
         return false;
     };
 
    </script>
<table id="flexigridData">
</table>

    <input type="hidden" id="SysRoleId" value="@ViewData["myid"]" />