C# 具有通用工作单元C的模拟通用存储库#
我有这样一个通用存储库：C# 具有通用工作单元C的模拟通用存储库#,c#,entity-framework,asp.net-core,moq,C#,Entity Framework,Asp.net Core,Moq,我有这样一个通用存储库： public class GenericRepository<TEntity> : IRepository<TEntity> where TEntity : class { private readonly DbContext _context; private DbSet<TEntity> _dbSet; public GenericRepository(DbContext context) {
public class GenericRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
private readonly DbContext _context;
private DbSet<TEntity> _dbSet;
public GenericRepository(DbContext context)
{
_context = context;
_dbSet = context.Set<TEntity>();
}
public virtual async Task<IEnumerable<TEntity>> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "")
{
IQueryable<TEntity> query = _dbSet;
if (filter != null)
{
query = query.Where(filter);
}
foreach (var includeProperty in includeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}
if (orderBy != null)
{
return await orderBy(query).ToListAsync<TEntity>();
}
return await query.ToListAsync<TEntity>();
}
}
public class GenericUnitOfWork<TContext> : IUnitOfWork<TContext>, IDisposable where TContext : DbContext
{
#region Private Member Variables
private TContext _context = null;
private Dictionary<Type, object> _repositories = new Dictionary<Type, object>();
#endregion
#region Constructors
public GenericUnitOfWork(TContext context)
{
_context = context;
}
#endregion
#region Public Properties
public TContext Context
{
get
{
return _context;
}
}
#endregion
#region Public Methods
public IRepository<TEntity> Repository<TEntity>() where TEntity : class
{
if (_repositories.Keys.Contains(typeof(TEntity)))
{
return _repositories[typeof(TEntity)] as GenericRepository<TEntity>;
}
GenericRepository<TEntity> repo = new GenericRepository<TEntity>(_context);
_repositories.Add(typeof(TEntity), repo);
return repo;
}
}
公共类GenericRepository:i存储，其中tenty:class
{
私有只读DbContext\u context；
私有数据库集_DbSet；
公共GenericRepository（DbContext上下文）
{
_上下文=上下文；
_dbSet=context.Set（）；
}
公共虚拟异步任务Get（表达式filter=null，Func orderBy=null，
字符串includeProperties=“”）
{
IQueryable查询=_dbSet；
if（过滤器！=null）
{
query=query.Where（过滤器）；
}
foreach（includeProperty.Split中的var includeProperty
（新字符[]{'，}，StringSplitOptions.RemoveEmptyEntries）
{
query=query.Include（includeProperty）；
}
if（orderBy！=null）
{
return wait orderBy（query.ToListAsync（）；
}
return wait query.ToListAsync（）；
}
}
public class GenericRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
private readonly DbContext _context;
private DbSet<TEntity> _dbSet;
public GenericRepository(DbContext context)
{
_context = context;
_dbSet = context.Set<TEntity>();
}
public virtual async Task<IEnumerable<TEntity>> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "")
{
IQueryable<TEntity> query = _dbSet;
if (filter != null)
{
query = query.Where(filter);
}
foreach (var includeProperty in includeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}
if (orderBy != null)
{
return await orderBy(query).ToListAsync<TEntity>();
}
return await query.ToListAsync<TEntity>();
}
}
public class GenericUnitOfWork<TContext> : IUnitOfWork<TContext>, IDisposable where TContext : DbContext
{
#region Private Member Variables
private TContext _context = null;
private Dictionary<Type, object> _repositories = new Dictionary<Type, object>();
#endregion
#region Constructors
public GenericUnitOfWork(TContext context)
{
_context = context;
}
#endregion
#region Public Properties
public TContext Context
{
get
{
return _context;
}
}
#endregion
#region Public Methods
public IRepository<TEntity> Repository<TEntity>() where TEntity : class
{
if (_repositories.Keys.Contains(typeof(TEntity)))
{
return _repositories[typeof(TEntity)] as GenericRepository<TEntity>;
}
GenericRepository<TEntity> repo = new GenericRepository<TEntity>(_context);
_repositories.Add(typeof(TEntity), repo);
return repo;
}
}
公共类GenericUnitOfWork:IUnitOfWork，IDisposable其中TContext:DbContext
{
#区域私有成员变量
私有TContext_context=null；
私有词典_repositories=新词典（）；
#端区
#区域构造函数
公共GenericUnitOfWork（TContext上下文）
{
_上下文=上下文；
}
#端区
#区域公共财产
公共上下文
{
得到
{
返回上下文；
}
}
#端区
#区域公共方法
公共IRepository存储库（），其中tenty:class
{
if（_repositories.Keys.Contains（typeof（tenty）））
{
将(类型(tenty))存储库返回为一般存储库;；
}
一般保存回购=新的一般保存（_上下文）；
_添加（类型（TEntity），回购）；
回购回报；
}
}
public class UserService : IUserService
{
private readonly IUnitOfWork<TASConfigDBContext> _unitOfWork;
private readonly IJwtFactory _jwFactory;
private readonly ITokenFactory _tokenFactory;
public UserService(IUnitOfWork<TASConfigDBContext> unitOfWork, IJwtFactory jwtFactory, ITokenFactory tokenfactory)
{
_unitOfWork = unitOfWork;
_jwFactory = jwtFactory;
_tokenFactory = tokenfactory;
}
public bool IsUserAuthenticated(string userName, string password)
{
var user = _unitOfWork.Repository<Users>().GetQuery().Where(x => string.Equals(x.Name, userName.Trim(), StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
// ensure we have a user with the given user name
if (user != null && user.Password == password)
{
return true;
}
return false;
}
}
public类用户服务：IUserService
{
私人只读i工作单元(unitof工作单元);；
私人只读IJwtFactory_jwFactory；
私有只读ITokenFactory\u tokenFactory；
公共用户服务（IUnitOfWork、IJwtFactory、jwtFactory、ITokenFactory、tokenfactory）
{
_unitOfWork=unitOfWork；
_JWFFactory=jwtFactory；
_令牌工厂=令牌工厂；
}
public bool IsUserAuthenticated（字符串用户名、字符串密码）
{
var user=_unitOfWork.Repository（）.GetQuery（）.Where（x=>string.Equals（x.Name，userName.Trim（），StringComparison.CurrentCultureIgnoreCase））.FirstOrDefault（）；
//确保我们有一个具有给定用户名的用户
if（user！=null&&user.Password==Password）
{
返回true；
}
返回false；
}
}
public class AuthController : ControllerBase
{
#region Private Member Variables
private readonly IUserService _userService;
private readonly ILogger<AuthController> _logger;
#endregion
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="AuthController"/> class.
/// </summary>
/// <param name="userService">userService DAL layer.</param>
/// <param name="logger">nlog logger.</param>
public AuthController(IUserService userService, ILogger<AuthController> logger)
{
_userService = userService;
_logger = logger;
}
#endregion
#region Public Methods
/// <summary>
/// Returns true if login is successful.
/// </summary>
/// <remarks>
/// Sample login:
///
/// POST /auth/login
/// {
/// "Username": "administrator",
/// "Password": ""
/// }.
///
/// </remarks>
/// <param name="login">The username and password.</param>
/// <returns>returns a token for validated user.</returns>
/// <response code="200">Success: Returns a token for a validated user.</response>
/// <response code="400">Bad request.</response>
/// <response code="401">Unauthorized: username and password doesn't match.</response>
[AllowAnonymous]
[HttpPost("login")]
[EnableCors("AllowOrigin")]
[Produces("application/json")]
[ProducesResponseType(typeof(ResponseMessage), 200)]
[ProducesResponseType(typeof(ResponseMessage), 400)]
[ProducesResponseType(typeof(ResponseMessage), 401)]
public async Task<ActionResult> Post([FromBody] LoginModel login)
{
HttpStatusCode statusCode;
ActionResult response;
ResponseMessage tokenResponseMessage;
ResponseToken responseToken;
if (login == null)
{
tokenResponseMessage = new ResponseMessage(false, null, new Message(HttpStatusCode.BadRequest));
_logger.LogError($"The Login model is null. {(LoginModel)null}");
response = BadRequest(tokenResponseMessage);
}
else if (!ModelState.IsValid)
{
var errors = new Hashtable();
foreach (var pair in ModelState)
{
if (pair.Value.Errors.Count > 0)
{
errors[pair.Key] = pair.Value.Errors.Select(error => error.ErrorMessage).ToList();
}
}
tokenResponseMessage = new ResponseMessage(false, errors, new Message(HttpStatusCode.BadRequest));
_logger.LogError($"The ModelState is invalid. {errors} ");
response = BadRequest(tokenResponseMessage);
}
else
{
if (_userService.IsUserAuthenticated(login.UserName, login.Password))
{
_logger.LogInformation($"Returned with valid username: {login.UserName}");
responseToken = await _userService.GetResponseToken(login.UserName);
_logger.LogInformation($"Response token generated for: {login.UserName}");
statusCode = HttpStatusCode.OK;
tokenResponseMessage = new ResponseMessage(true, responseToken, new Message(statusCode));
// generate access token
response = Ok(tokenResponseMessage);
}
else
{
_logger.LogWarning($"No username for userid : {login.UserName} found");
statusCode = HttpStatusCode.Unauthorized;
tokenResponseMessage = new ResponseMessage(false, null, new Message(statusCode, "Incorrect username or password"));
response = Unauthorized(tokenResponseMessage);
}
}
return response;
}
公共类AuthController:ControllerBase
{
#区域私有成员变量
专用只读IUserService\u userService；
专用只读ILogger\u记录器；
#端区
#区域构造函数
///
///初始化类的新实例。
///
///用户服务DAL层。
///nlog记录器。
公共AuthController（IUserService用户服务、ILogger记录器）
{
_userService=userService；
_记录器=记录器；
}
#端区
#区域公共方法
///
///如果登录成功，则返回true。
///
///
///登录示例：
///
///POST/auth/login
/// {
///“用户名”：“管理员”，
///“密码”：”
/// }.
///
///
///用户名和密码。
///返回已验证用户的令牌。
///成功：返回已验证用户的令牌。
///请求错误。
///未经授权：用户名和密码不匹配。
[异名]
[HttpPost（“登录”）]
[EnableCors（“AllowOrigin”）]
[产生（“应用程序/json”）]
[产品响应类型（类型（响应消息），200）]
[产品响应类型（类型（响应消息），400）]
[产品响应类型（类型（响应消息），401）]
公共异步任务发布（[FromBody]登录模型登录）
{
HttpStatusCode状态码；
行动结果反应；
响应消息令牌响应消息；
响应肯响应肯；
if（login==null）
{
tokenResponseMessage=新的ResponseMessage（false、null、新消息（HttpStatusCode.BadRequest））；
_logger.LogError（$“登录模型为空。{（LoginModel）null}”）；
响应=坏请求（令牌响应消息）；
}
如果（！ModelState.IsValid），则为else
{
var errors=新哈希表（）；
foreach（ModelState中的var对）
{
如果（pair.Value.Errors.Count>0）
{
errors[pair.Key]=pair.Value.errors.Select（error=>error.ErrorMessage.ToList（）；
}
}
tokenResponseMessage=new ResponseMessage（错误、错误、新消息（HttpStatusCode.BadRequest））；
_logger.LogError（$“ModelState无效。{errors}”）；
响应=坏请求（令牌响应消息）；
}
其他的
{
if（_userService.IsUserAuthenticated（login.UserName，login.Password））
{
_logger.LogInformation（$”返回了有效的用户名：{login.username}）；
responseToken=wait_userService.GetResponseToken（login.UserName）；
_logger.LogInformation（$“为：{login.UserName}生成的响应令牌”）；
statusCode=HttpStatusCode.OK；
tokenResponseMessage=新的ResponseMessage（true、responseToken、新消息（statusCode））；
//生成访问令牌
响应=Ok（令牌响应消息）；
}
其他的
{
_logger.LogWarning（$“找不到用户名：{login.username}”）；
statusCode=HttpStatusCode.未经授权；
tokenResponseMessage=new ResponseMessage（假、空、新消息（状态码，“不正确的用户名或密码”）；
响应=未授权（令牌响应消息）；
}
}
返回响应；
}