public async Task <int> SaveAsync(ExpenseRecord entity)
{
string commandText = DapperExtensions.InsertQuery(typeof(ExpenseRecord).Name, entity);
using (var db = new MySqlConnection(_option.Value.ConnectionString))
{
db.Open();
return(await db.ExecuteScalarAsync <int>(commandText, entity, null));
}
}
public void MappingClass_ReturnsFromDifferentAssembly()
{
DapperExtensions.SetMappingAssemblies(new[] { typeof(ExternallyMappedMap).Assembly });
var mapper = DapperExtensions.GetMap <ExternallyMapped>();
Assert.AreEqual(typeof(ExternallyMappedMap.ExternallyMappedMapper), mapper.GetType());
DapperExtensions.SetMappingAssemblies(null);
mapper = DapperExtensions.GetMap <ExternallyMapped>();
Assert.AreEqual(typeof(AutoClassMapper <ExternallyMapped>), mapper.GetType());
}
public void GetMultiple_DoesNotDuplicate()
{
List <Guid> list = new List <Guid>();
for (int i = 0; i < 1000; i++)
{
Guid id = DapperExtensions.GetNextGuid();
Assert.IsFalse(list.Contains(id));
list.Add(id);
}
}
public IEnumerable <T> ExecuteProcedure <T, returnParamT>(string procedureName, DynamicParameters parameters, out returnParamT outParam1)
{
outParam1 = default(returnParamT);
try
{
DbType outParamDBType = DapperExtensions.ConvertType(typeof(returnParamT));
parameters.Add("@outp", dbType: outParamDBType, direction: ParameterDirection.Output);
using (IDbConnection connection = new SqlConnection(_connectionStr))
{
IEnumerable <T> entities = connection.Query <T>(procedureName, parameters, commandTimeout: _commandTimeout, commandType: CommandType.StoredProcedure);
outParam1 = parameters.Get <returnParamT>("@outp");
return(entities);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <PageData <T> > GetPageList(QueryModel queryModel)
{
return(await DapperExtensions.PageQuery <T>(_unitOfWork, queryModel));
}
public void ClassMapperDescendant_Returns_DefinedClass()
{
var mapper = DapperExtensions.GetMap <EntityWithMapper>();
Assert.AreEqual(typeof(EntityWithMapperMapper), mapper.GetType());
}
/// <summary>
/// 根据条件更新表
/// </summary>
/// <param name="record">更新对象</param>
/// <param name="condition">更新条件，支持等于操作（普通类型），IN查询（数组类型)</param>
public int UpdateByCondition(dynamic record, object condition = null)
{
return(DapperExtensions.UpdateSelective(Connection, record, TableName, condition, null, null));
}
public async Task <DataTable> GetDataTable(Expression <Func <T, bool> > whereLambda)
{
return(await DapperExtensions.QueryDataTable <T>(_unitOfWork, whereLambda));
}
public async Task <bool> Delete(object keyValues)
{
return(await DapperExtensions.DeleteById <T>(_unitOfWork, keyValues) > 0 ? true : false);
}
public async Task <bool> Delete(string ids)
{
return(await DapperExtensions.DeleteByIds <T>(_unitOfWork, ids) > 0 ? true : false);
}
public async Task <bool> Edit(T entity)
{
return(await DapperExtensions.Update(_unitOfWork, entity) > 0 ? true : false);
}
public async Task <int> AddList(List <T> list)
{
return(await DapperExtensions.SqlBulkCopy(_unitOfWork, list));
}
public async Task <bool> Add(T entity)
{
return(await DapperExtensions.Insert(_unitOfWork, entity) > 0 ? true : false);
}
public async Task <PageData <T> > GetPageMultList(Type[] types, Func <object[], T> map, string sql, string countSql = "", object param = null, string splitOn = "Id")
{
return(await DapperExtensions.PageQueryMult <T>(_unitOfWork, types, map, sql, countSql, param, splitOn));
}
public async Task <PageData <T> > GetPageList(string sql, string countSql = "", dynamic parms = null)
{
return(await DapperExtensions.PageQuery <T>(_unitOfWork, sql, countSql, parms));
}
public async Task <List <T> > GetList(string sql, dynamic parms = null)
{
return(await DapperExtensions.Query <T>(_unitOfWork, sql, parms));
}
public async Task <List <T> > GetList(string procName, dynamic parms = null, CommandType?commandType = null)
{
return(await DapperExtensions.Query <T>(_unitOfWork, procName, parms, commandType));
}
public async Task <bool> Delete(Expression <Func <T, bool> > whereLambda)
{
return(await DapperExtensions.Delete <T>(_unitOfWork, whereLambda) > 0 ? true : false);
}
public virtual Guid GetNextGuid()
{
return(DapperExtensions.GetNextGuid());
}
public async Task <bool> InsertUpdateOrDelete(string sql, dynamic parms = null, CommandType?commandType = null)
{
return(await DapperExtensions.InsertUpdateOrDelete(_unitOfWork, sql, parms, commandType) > 0 ? true : false);
}
public async Task <bool> Add(T entity)
{
return(await DapperExtensions.Insert(_unitOfWork, entity, _unitOfWork.DbTransaction));
}
public async Task <T> GetEntity(object keyValues)
{
return(await DapperExtensions.SingleOrDefault <T>(_unitOfWork, keyValues));
}
public TEntity FetchByKey(dynamic key)
{
return(DapperExtensions.Get <TEntity>(this.DbConnection, key));
}
public async Task <T> GetEntity(Expression <Func <T, bool> > whereLambda)
{
return(await DapperExtensions.SingleOrDefault(_unitOfWork, whereLambda));
}
public void NoMappingClass_ReturnsDefaultMapper()
{
var mapper = DapperExtensions.GetMap <EntityWithoutMapper>();
Assert.AreEqual(typeof(AutoClassMapper <EntityWithoutMapper>), mapper.GetType());
}
public async Task <T> GetEntity(string sql, dynamic parms = null)
{
return(await DapperExtensions.SingleOrDefault(_unitOfWork, sql, parms));
}
public void ClassMapperInterface_Returns_DefinedMapper()
{
var mapper = DapperExtensions.GetMap <EntityWithInterfaceMapper>();
Assert.AreEqual(typeof(EntityWithInterfaceMapperMapper), mapper.GetType());
}
public async Task <T> GetEntity(string procName, dynamic parms = null, CommandType?commandType = null)
{
return(await DapperExtensions.SingleOrDefault(_unitOfWork, procName, parms, commandType));
}
public async Task <List <T> > GetList(Expression <Func <T, bool> > whereLambda)
{
return(await DapperExtensions.Query(_unitOfWork, whereLambda));
}
public async Task <DataTable> GetDataTable(string sql, dynamic parms = null)
{
return(await DapperExtensions.QueryDataTable(_unitOfWork, sql, parms));
}
