asp.net mvc+web api+easyui

Posted 2020-06-23

前奏：第一次写博客，记录一下学习和开发的过程。

现在写的是一个后台管理系统，有基本的权限功能，其他功能都可以扩展。用到的技术是 asp.net mvc5,web api 2,entityframework,autofac,easyui等。

先来上个解决方案的图： 

01-ZY.Web.MVC：是页面的展示，由于用了web api 所以在mvc里面没有做数据的操作。mvc里面主要有权限的判断，controller里面也没有太多的逻辑处理。

02-ZY.Web.Api：这里用到了web api。web api的好处是可以多平台调用，前后端可以分别开发，很好的分离了前后端的开发工作。

03-ZY.Identity：这里面主要是权限的判断，用到了asp.net identity。

04-ZY.Core：这个是项目的核心类库，包含了autofac,缓存，仓储接口，实体基类，扩展方法等，后续会详细的讲讲。

05-ZY.Repositories.EntityFramework：这个就是EntityFramework仓储的实现。

06-ZY.Model：这个就是实体类库。

在看一下运行的效果图片：

1：账号管理界面

2：编辑管理员  角色是多角色。

3：管理员选中角色，多角色选择，查找带回控件

4.设置菜单权限界面

5.角色管理  角色管理是在行内编辑

6.设置角色权限

7.菜单管理

8.设置菜单需要的按钮权限

再贴一些代码吧：

 

仓储接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;

using ZY.Core.Entities;

namespace ZY.Core.Repositories
{
    /// <summary>
    /// 仓储接口
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TKey"></typeparam>
    public interface IRepository<TEntity, TKey> : IDependency where TEntity : IEntity<TKey>
    {
        IQueryable<TEntity> Entities { get; }

        #region 同步添加方法
        /// <summary>
        /// 添加实体对象
        /// </summary>
        /// <param name="entity"></param>
        void Insert(TEntity entity);
        /// <summary>
        /// 批量添加实体对象
        /// </summary>
        /// <param name="entitys"></param>
        void Insert(IEnumerable<TEntity> entitys);
        #endregion

        #region 同步删除方法
        /// <summary>
        /// 删除对象
        /// </summary>
        /// <param name="entity"></param>
        void Remove(TEntity entity);
        /// <summary>
        /// 根据主键删除
        /// </summary>
        /// <param name="key"></param>
        void Remove(TKey key);
        /// <summary>
        /// 根据条件删除
        /// </summary>
        /// <param name="predicate"></param>
        void Remove(Expression<Func<TEntity, bool>> predicate);
        /// <summary>
        /// 批量删除对象
        /// </summary>
        /// <param name="entitys"></param>
        void Remove(IEnumerable<TEntity> entitys);
        /// <summary>
        /// 根据主键批量删除
        /// </summary>
        /// <param name="keys"></param>
        void Remove(IEnumerable<TKey> keys);
        #endregion

        #region 同步修改方法
        /// <summary>
        /// 修改对象实体
        /// </summary>
        /// <param name="entity"></param>
        void Update(TEntity entity);
        #endregion

        #region 同步判断方法
        /// <summary>
        /// 根据主键判断实体是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        bool Exists(TKey key);
        /// <summary>
        /// 根据添加判断是否存在
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        bool Exists(Expression<Func<TEntity, bool>> predicate);
        #endregion

        #region 同步查询单条
        /// <summary>
        /// 根据主键查询
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        TEntity GetByKey(TKey key);
        /// <summary>
        /// 根据条件获取单条记录
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        TEntity FirstOfDefault(Expression<Func<TEntity, bool>> predicate);
        #endregion

        #region 同步查询列表
        /// <summary>
        /// 根据条件获取数据列表
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        IQueryable<TEntity> Query(Expression<Func<TEntity, bool>> predicate);

        #endregion

        #region 异步添加方法
        /// <summary>
        /// 添加实体对象
        /// </summary>
        /// <param name="entity"></param>
        Task<TEntity> InsertAsync(TEntity entity);
        /// <summary>
        /// 批量添加实体对象
        /// </summary>
        /// <param name="entitys"></param>
        Task<IEnumerable<TEntity>> InsertAsync(IEnumerable<TEntity> entitys);
        #endregion

        #region 异步修改方法
        /// <summary>
        /// 修改对象实体
        /// </summary>
        /// <param name="entity"></param>
        Task<TEntity> UpdateAsync(TEntity entity);
        #endregion

        #region 异步判断方法
        /// <summary>
        /// 根据主键判断实体是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<bool> ExistsAsync(TKey key);
        /// <summary>
        /// 根据添加判断是否存在
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        Task<bool> ExistsAsync(Expression<Func<TEntity, bool>> predicate);
        #endregion

        #region 异步查询单条
        /// <summary>
        /// 根据主键查询
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<TEntity> GetByKeyAsync(TKey key);
        /// <summary>
        /// 根据条件获取单条记录
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        Task<TEntity> FirstOfDefaultAsync(Expression<Func<TEntity, bool>> predicate);
        #endregion

        #region 异步查询列表
        /// <summary>
        /// 查询全部数据
        /// </summary>
        /// <returns></returns>
        Task<List<TEntity>> GetAllAsync();
        /// <summary>
        /// 根据条件获取数据列表
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        Task<List<TEntity>> QueryAsync(Expression<Func<TEntity, bool>> predicate);
        
        #endregion

        #region 同步sql查询
        /// <summary>
        /// 根据sql查询
        /// </summary>
        /// <param name="query"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        IEnumerable<TEntity> SqlQuery(string sql, params object[] parameters);
        #endregion
    }
}

仓储的具体实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Data.Entity;

using ZY.Core.Repositories;
using ZY.Core.Entities;
using System.Linq.Expressions;

namespace ZY.Repositories.EntityFramework
{
    /// <summary>
    /// EntityFramework 仓储
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TKey"></typeparam>
    public class Repository<TEntity, TKey> : IRepository<TEntity, TKey>
        where TEntity : class, IEntity<TKey>
    {
        protected DbContext _dbContext;
        protected IDbSet<TEntity> _dbSet;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dbContext"></param>
        public Repository(DbContext dbContext)
        {
            _dbContext = dbContext;
            _dbSet = dbContext.Set<TEntity>();
        }

        /// <summary>
        /// 全部实体对象
        /// </summary>
        public IQueryable<TEntity> Entities
        {
            get
            {
                return _dbSet.AsQueryable();
            }
        }

        #region 同步添加方法
        /// <summary>
        /// 添加实体对象
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Insert(TEntity entity)
        {
            _dbSet.Add(entity);
        }
        /// <summary>
        /// 批量添加实体对象
        /// </summary>
        /// <param name="entitys"></param>
        public virtual void Insert(IEnumerable<TEntity> entities)
        {
            _dbContext.Set<TEntity>().AddRange(entities);
        }
        #endregion

        #region 同步删除方法
        /// <summary>
        /// 删除对象实体
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Remove(TEntity entity)
        {
            _dbSet.Remove(entity);
        }
        /// <summary>
        /// 根据主键删除实体
        /// </summary>
        /// <param name="key"></param>
        public virtual void Remove(TKey key)
        {
            var entity = GetByKey(key);
            if (entity == null)
                return;
            Remove(entity);
        }
        /// <summary>
        /// 删除对象列表
        /// </summary>
        /// <param name="entities"></param>
        public virtual void Remove(IEnumerable<TEntity> entities)
        {
            if (entities == null)
                return;
            if (!entities.Any())
                return;
            _dbContext.Set<TEntity>().RemoveRange(entities);
        }
        /// <summary>
        /// 根据条件删除
        /// </summary>
        /// <param name="predicate"></param>
        public virtual void Remove(Expression<Func<TEntity, bool>> predicate)
        {
            var entities = _dbSet.Where(predicate);
            Remove(entities);
        }
        /// <summary>
        /// 根据主键列表删除
        /// </summary>
        /// <param name="keys"></param>
        public virtual void Remove(IEnumerable<TKey> keys)
        {
            if (keys == null)
                return;
            Remove(Query(t => keys.Contains(t.Id)));
        }
        #endregion

        #region 同步修改方法
        /// <summary>
        /// 修改对象实体
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Update(TEntity entity)
        {
            _dbContext.Entry(entity).State = EntityState.Modified;
        }
        #endregion

        #region 同步判断方法
        /// <summary>
        /// 判断主键是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual bool Exists(TKey key)
        {
            return GetByKey(key) == null ? false : true;
        }
        /// <summary>
        /// 根据条件判断对象是否存在
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public virtual bool Exists(Expression<Func<TEntity, bool>> predicate)
        {
            return Query(predicate).Any();
        }
        #endregion

        #region 同步查询单条
        /// <summary>
        /// 根据主键获取对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual TEntity GetByKey(TKey key)
        {
            return _dbContext.Set<TEntity>().Find(key);
        }
        /// <summary>
        /// 获取单个实体
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public virtual TEntity FirstOfDefault(Expression<Func<TEntity, bool>> predicate)
        {
            return Query(predicate).FirstOrDefault();
        }
        #endregion

        #region 同步查询列表
        /// <summary>
        /// 根据条件查询
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public virtual IQueryable<TEntity> Query(Expression<Func<TEntity, bool>> predicate)
        {
            return _dbSet.Where(predicate);
        }

        #endregion

        #region 异步添加方法
        /// <summary>
        /// 添加实体对象
        /// </summary>
        /// <param name="entity"></param>
        public virtual Task<TEntity> InsertAsync(TEntity entity)
        {
            return Task.FromResult(_dbSet.Add(entity));
        }
        /// <summary>
        /// 批量添加实体对象
        /// </summary>
        /// <param name="entitys"></param>
        public virtual Task<IEnumerable<TEntity>> InsertAsync(IEnumerable<TEntity> entities)
        {
            return Task.FromResult(_dbContext.Set<TEntity>().AddRange(entities));
        }
        #endregion

        #region 同步修改方法
        /// <summary>
        /// 修改对象实体
        /// </summary>
        /// <param name="entity"></param>
        public virtual Task<TEntity> UpdateAsync(TEntity entity)
        {
            _dbContext.Entry(entity).State = EntityState.Modified;
            return Task.FromResult(entity);
        }
        #endregion

        #region 异步判断方法
        /// <summary>
        /// 判断主键是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual async Task<bool> ExistsAsync(TKey key)
        {
            return await GetByKeyAsync(key) == null ? false : true;
        }
        /// <summary>
        /// 根据条件判断对象是否存在
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public virtual async Task<bool> ExistsAsync(Expression<Func<TEntity, bool>> predicate)
        {
            return await Query(predicate).AnyAsync();
        }
        #endregion

        #region 异步查询单条
        /// <summary>
        /// 根据主键获取对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual async Task<TEntity> GetByKeyAsync(TKey key)
        {
            return await _dbContext.Set<TEntity>().FindAsync(key);
        }
        /// <summary>
        /// 获取单个实体
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public virtual async Task<TEntity> FirstOfDefaultAsync(Expression<Func<TEntity, bool>> predicate)
        {
            return await Query(predicate).FirstOrDefaultAsync();
        }
        #endregion

        #region 异步查询列表
        /// <summary>
        /// 查询全部数据
        /// </summary>
        /// <returns></returns>
        public virtual async Task<List<TEntity>> GetAllAsync()
        {
            return await _dbSet.ToListAsync();
        }
        /// <summary>
        /// 根据条件查询
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public virtual async Task<List<TEntity>> QueryAsync(Expression<Func<TEntity, bool>> predicate)
        {
            return await _dbSet.Where(predicate).ToListAsync();
        }
        #endregion

        #region 同步sql方法
        /// <summary>
        /// 根据sql查询
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public IEnumerable<TEntity> SqlQuery(string sql, params object[] parameters)
        {
            return _dbContext.Database.SqlQuery<TEntity>(sql, parameters);
        }
        #endregion
    }
}

关于Repository的具体实现思路，博客园里面有很多文章了，这里就不详细说明了。

IUnitOfWork  考虑到可能会执行单独的存储过程，所以在UnitOfWork里面加了对存储过程的支持

using System;
using System.Data;
using System.Threading.Tasks;

namespace ZY.Core.Repositories
{
    /// <summary>
    /// 业务单元操作接口
    /// </summary>
    public interface IUnitOfWork: IDependency, IDisposable
    {
        /// <summary>
        /// 提交
        /// </summary>
        /// <returns></returns>
        void Commit();
        /// <summary>
        /// 异步提交
        /// </summary>
        /// <returns></returns>
        Task CommitAsync();
        /// <summary>
        /// 同步
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        int ExecuteSqlCommand(string sql, params object[] parameters);
        /// <summary>
        /// 异步执行SQL语句
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        Task<int> ExecuteSqlCommandAsync(string sql, params object[] parameters);
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <returns></returns>
        DataSet QueryProcedure(string storedProcName);
        /// <summary>
        /// 执行存储过程 带参数
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <param name="parameters">参数</param>
        /// <returns></returns>
        DataSet QueryProcedure(string storedProcName, IDataParameter[] parameters);
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <param name="parameters">参数</param>
        /// <returns>存储过程返回值</returns>
        int RunProcedure(string storedProcName, IDataParameter[] parameters);
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <param name="parameters">参数</param>
        /// <returns></returns>
        int RunProcedure(string storedProcName);
    }
}

　　

UnitOfWork的具体实现

using System;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Validation;
using System.Data.SqlClient;
using System.Text;
using System.Threading.Tasks;
using ZY.Core.Logging;
using ZY.Core.Repositories;

namespace ZY.Repositories.EntityFramework
{
    /// <summary>
    /// 工作单元
    /// </summary>
    public class UnitOfWork : IUnitOfWork
    {
        private DbContext _dbContext; //数据库上下文对象
        private readonly ILog log; //日志接口

        public UnitOfWork(DbContext dbContext)
        {
            _dbContext = dbContext;
            log = new Log();
        }

        /// <summary>
        /// 提交
        /// </summary>
        /// <returns></returns>
        public void Commit()
        {
            try
            {
                try
                {
                    _dbContext.SaveChanges();
                }
                catch (DbEntityValidationException exception)
                {
                    throw new DataException("保存数据时,数据验证引发异常--", exception);
                }
            }
            catch (DbUpdateException ex)
            {
                throw new DataException("保存数据更改时引发异常--", ex);
            }
        }
        /// <summary>
        /// 异步提交
        /// </summary>
        /// <returns></returns>
        public async Task CommitAsync()
        {
            try
            {
                try
                {
                    await _dbContext.SaveChangesAsync();
                }
                catch (DbEntityValidationException exception)
                {
                    throw new DataException("保存数据时,数据验证引发异常--", exception);
                }
            }
            catch (DbUpdateException ex)
            {
                throw new DataException("保存数据更改时引发异常--",ex);
            }
        }
        /// <summary>
        /// 异步
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public async Task<int> ExecuteSqlCommandAsync(string sql, params object[] parameters)
        {
            return await _dbContext.Database.ExecuteSqlCommandAsync(sql, parameters);
        }
        /// <summary>
        /// 同步
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public int ExecuteSqlCommand(string sql, params object[] parameters)
        {
            return _dbContext.Database.ExecuteSqlCommand(sql, parameters);
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <param name="parameters">参数</param>
        /// <returns></returns>
        public DataSet QueryProcedure(string storedProcName, IDataParameter[] parameters)
        {
            using (SqlConnection connection = new SqlConnection(_dbContext.Database.Connection.ConnectionString))
            {
                try
                {
                    DataSet dataSet = new DataSet();
                    connection.Open();
                    SqlDataAdapter sqlDA = new SqlDataAdapter();
                    sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
                    sqlDA.Fill(dataSet);
                    connection.Close();
                    return dataSet;
                }
                catch (Exception exception)
                {
                    string error = string.Format("执行存储过程 名称：{0} 参数 {1}", storedProcName, GetParamterValue(parameters));
                    log.Error(error, exception);
                    throw new Exception(error, exception);
                }
            }
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <returns></returns>
        public DataSet QueryProcedure(string storedProcName)
        {
            using (SqlConnection connection = new SqlConnection(_dbContext.Database.Connection.ConnectionString))
            {
                try
                {
                    DataSet dataSet = new DataSet();
                    connection.Open();
                    SqlDataAdapter sqlDA = new SqlDataAdapter();
                    SqlCommand command = new SqlCommand(storedProcName, connection);
                    command.CommandType = CommandType.StoredProcedure;
                    sqlDA.SelectCommand = command;
                    sqlDA.Fill(dataSet);
                    connection.Close();
                    return dataSet;
                }
                catch (Exception exception)
                {
                    string error = string.Format("执行存储过程 名称：{0}", storedProcName);
                    log.Error(error, exception);
                    throw new Exception(error, exception);
                }
            }
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名称</param>
        /// <param name="parameters">参数</param>
        /// <returns>存储过程返回值</returns>
        public int RunProcedure(string storedProcName, IDataParameter[] parameters)
        {
            using (SqlConnection connection = new SqlConnection(_dbContext.Database.Connection.ConnectionString))
            {
                try
                {
                    connection.Open();
                    SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
                    SqlParameter resultParam = new SqlParameter(); //构建存储过程返回值
                    resultParam.Direction = ParameterDirection.ReturnValue;
                    command.Parameters.Add(resultParam);
                    command.ExecuteNonQuery();
                    connection.Close();
                    return (int)resultParam.Value;
                }
                catch (Exception exception)
                {
                    string error = string.Format("执行存储过程 名称：{0} 参数 {1}", storedProcName, GetParamterValue(parameters));
                    log.Error(error, exception);
                    throw new Exception(error, exception);
                }
            }
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程</param>
        /// <returns>返回值</returns>
        public int RunProcedure(string storedProcName)
        {
            using (SqlConnection connection = (SqlConnection)_dbContext.Database.Connection)
            {
                try
                {
                    connection.Open();
                    SqlCommand command = new SqlCommand(storedProcName, connection);
                    command.CommandType = CommandType.StoredProcedure;
                    SqlParameter resultParam = new SqlParameter(); //构建存储过程返回值
                    resultParam.Direction = ParameterDirection.ReturnValue;
                    command.Parameters.Add(resultParam);
                    command.ExecuteNonQuery();
                    connection.Close();
                    return (int)resultParam.Value;
                }
                catch (SqlException exception)
                {
                    string error = string.Format("执行存储过程 名称：{0}", storedProcName);
                    log.Error(error, exception);
                    throw new Exception(error, exception);
                }
            }
        }
        /// <summary>
        /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand</returns>
        private SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
        {
            SqlCommand command = new SqlCommand(storedProcName, connection);
            command.CommandType = CommandType.StoredProcedure;
            foreach (SqlParameter parameter in parameters)
            {
                if (parameter != null)
                {
                    // 检查未分配值的输出参数,将其分配以DBNull.Value.
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(parameter);
                }
            }
            return command;
        }
        /// <summary>
        /// 根据参数列表获取参数的名称和值，用于记录日志
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private string GetParamterValue(IDataParameter[] parameters)
        {
            StringBuilder paramStr = new StringBuilder();
            foreach (SqlParameter param in parameters)
            {
                paramStr.AppendFormat("{0} ：{1}", param.ParameterName, param.Value);
            }
            return paramStr.ToString();
        }
        //处理回收机制
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        //处理回收机制
        private void Dispose(bool isdispose)
        {
            if (isdispose)
            {
                if (_dbContext != null)
                {
                    _dbContext.Dispose();
                    _dbContext = null;
                }
            }
        }
    }
}

　　

　

 这篇文章就暂时到这里，下一篇会介绍ZY.Repositories.EntityFramework类库的实现。