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

现在写的是一个后台管理系统,有基本的权限功能,其他功能都可以扩展。用到的技术是 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类库的实现。

asp.net mvc+web api+easyui的更多相关文章

  1. (转)第一次发博客-说说我的B/S开发框架(asp.net mvc + web api + easyui)

    原文地址:http://www.cnblogs.com/xqin/archive/2013/05/29/3105291.html 前言 这些年一直在.net下做企业web系统开发,前前后后经历的不同的 ...

  2. ASP.NET MVC Web API Post FromBody(Web API 如何正确 Post)

    问题场景: ASP.NET MVC Web API 定义 Post 方法,HttpClient 使用 JsonConvert.SerializeObject 传参进行调用,比如 Web Api 中定义 ...

  3. ASP.NET MVC Web API For APP

    近来很多大型的平台都公开了Web API.比如百度地图 Web API,做过地图相关的人都熟悉.公开服务这种方式可以使它易于与各种各样的设备和客户端平台集成功能,以及通过在浏览器中使用 JavaScr ...

  4. [译]ABP框架使用AngularJs,ASP.NET MVC,Web API和EntityFramework构建N层架构的SPA应用程序

    本文转自:http://www.skcode.cn/archives/281 本文演示ABP框架如何使用AngularJs,ASP.NET MVC,Web API 和EntityFramework构建 ...

  5. 【转载】ASP.NET MVC Web API 学习笔记---联系人增删改查

    本章节简单介绍一下使用ASP.NET MVC Web API 做增删改查.目前很多Http服务还是通过REST或者类似RESP的模型来进行数据操作的.下面我们通过创建一个简单的Web API来管理联系 ...

  6. Asp.net mvc web api 在项目中的实际应用

    Asp.net mvc web api 在项目中的实际应用 前言:以下只是记录本人在项目中的应用,而web api在数据传输方面有多种实现方式,具体可根据实际情况而定! 1:数据传输前的加密,以下用到 ...

  7. ASP.NET MVC Web API 学习笔记---第一个Web API程序

    http://www.cnblogs.com/qingyuan/archive/2012/10/12/2720824.html GetListAll /api/Contact GetListBySex ...

  8. 实战 ASP.NET MVC Web API

    实战 ASP.NET MVC Web API Web API 框架基于 ASP.NET MVC 框架开发,是一个面向 Http 协议的通信框架.相对于 WCF 而言,Web API 只面向于 Http ...

  9. ABP 教程文档 1-1 手把手引进门之 AngularJs, ASP.NET MVC, Web API 和 EntityFramework(官方教程翻译版 版本3.2.5)含学习资料

    本文是ABP官方文档翻译版,翻译基于 3.2.5 版本 转载请注明出处:http://www.cnblogs.com/yabu007/  谢谢 官方文档分四部分 一. 教程文档 二.ABP 框架 三. ...

随机推荐

  1. 【HDOJ】3560 Graph’s Cycle Component

    并查集的路径压缩. #include <stdio.h> #include <string.h> #define MAXNUM 100005 int deg[MAXNUM], ...

  2. android Permission 访问权限许可

    程序执行需要读取到安全敏感项必需在androidmanifest.xml中声明相关权限请求, 完整列表如下: android.permission.ACCESS_CHECKIN_PROPERTIES允 ...

  3. C# 防止同一个账号多次登录(cache方法)

    c#中防止同一账号重复登录的方法有不少,比如用数据库来记录用户登录情况.用Application来保存用户登录信息.用Cache来保存信息等. 本文为大家介绍如何利用缓存Cache方便地实现此功能. ...

  4. pdb文件部分解释

    pdb文件包含了编译后程序指向源代码的位置信息,用于调试的时候定位到源代码,主要是用来方便调试的. 在程序发布为release模式时,建议将 pdb文件删除, 同时,对外发布的时候,也把 pdb删除, ...

  5. 我记录综合系统学习研究之用户管理五(如何利用wojilu打造一个全新的SNS应用)

    wojilu框架特别适合快速开发多用户分享内容应用,比如知乎,digg这类应用. 对于博客等用户程序,要有4个入口:1)用户展示入口(展示自己的应用) 2)用户后台管理入口(管理自己的应用) 3)聚合 ...

  6. HDU 4714 Tree2cycle DP 2013杭电热身赛 1009

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4714 Tree2cycle Time Limit: 15000/8000 MS (Java/Other ...

  7. Lesson: Introduction to JAXP

    The Java API for XML Processing (JAXP) is for processing XML data using applications written in the ...

  8. 解决DATASNAP远程方法参数超过32个的问题

    群里有位同仁提出他有一个DATASNAP远程方法超过了32个参数,然后DELPHI编译通不过,提示方法参数不能超过32个,问怎么办?于是群内同仁纷纷出主意,我说用OLEVARINAT数组,有人说用RE ...

  9. .Net设计模式_适配器模式

    引言: 有一次我看到一个朋友拿出一个三角型的东西,好奇的上去一看你,我勒个去,传说中的万能插口转接器(插口适配器). 一面是插入口,集合了我认识的所有插口的形状,也有国内没看见过的:另一个是跟插座接触 ...

  10. Java和Tomcat类加载机制

    转自:http://blog.csdn.net/codolio/article/details/5027423 加载类是运行程序的基础,了解Java和Tomcat的类加载机制对更有效地开发.调试Web ...