public T ReflectionToEntity(SqlDataReader sdr)
{
var entity = new T();
foreach (var property in _master.Properties)
{
property.PropertyInfo.SetValue(entity, sdr[property.Name]);
}
foreach (var include in _include)
{
var prop = _master.Properties.Single(p => p.Name == include);
if (prop == null)
{
continue;
}
var subType = prop.PropertyInfo.PropertyType;
var subEntityInfo = MyEntityContainer.Get(subType);
var subEntity = Activator.CreateInstance(subType);
foreach (var subProperty in subEntityInfo.Properties)
{
if (subProperty.IsMap)
{
subProperty.PropertyInfo.SetValue(subEntity, sdr[$"{include}__{subProperty.Name}"]);
}
}
prop.PropertyInfo.SetValue(entity, subEntity);
}
return(entity);
}
/// <summary>
/// 创建一个实体，新的记录Id将绑定到entity的Id属性
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity">要创建的实体</param>
/// <returns>新生成记录的ID，若失败返回0</returns>
public int Insert <T>(T entity) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerSqlBuilder();
var sql = sqlBuilder.Insert(entityInfo);
var parameterList = entityInfo
.Properties
.Where(p => !p.InsertIgnore)
.Select(p => new SqlParameter($"{_prefix}{p.Name}", ResolveParameterValue(p.PropertyInfo.GetValue(entity))));
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameterList.ToArray());
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
var result = command.ExecuteScalar().ToString();
entity.Id = Convert.ToInt32(string.IsNullOrWhiteSpace(result) ? "0" : result);
return(entity.Id);
}
}
public async Task <int> UpdateIgnoreAsync <T>(T entity, IEnumerable <string> ignore, bool ignoreAttribute = true) where T : IEntity
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var includeProperties = entityInfo.Properties.Where(p => !ignore.Contains(p.Name) && p.Name != "Id").ToList();
if (!ignoreAttribute)
{
includeProperties = includeProperties.Where(p => !p.UpdateIgnore).ToList();
}
if (!includeProperties.Any())
{
return(0);
}
var sql =
$"UPDATE [{entityInfo.TableName}] SET {string.Join(",", includeProperties.Select(p => $"{p.FieldName}=@{p.Name}"))} WHERE Id=@Id";
var parameters = new List <SqlParameter> {
new SqlParameter("@Id", entity.Id)
};
foreach (var property in includeProperties)
{
parameters.Add(new SqlParameter($"@{property.Name}", ResolveParameterValue(property.PropertyInfo.GetValue(entity))));
}
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddRange(parameters.ToArray());
return(await command.ExecuteNonQueryAsync());
}
}
/// <summary>
/// 根据ID批量删除记录，如果支持软删除并且非强制删除，则更新IsDel字段为true，否则，删除记录
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="idList">要删除的ID列表</param>
/// <param name="isForce">是否强制删除，默认为false</param>
/// <returns>受影响的记录数</returns>
public int Delete <T>(IEnumerable <int> idList, bool isForce = false) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
if (isForce || !entityInfo.IsSoftDelete)
{
var sql =
$"EXEC('DELETE [{entityInfo.TableName}] WHERE [{entityInfo.KeyColumn}] in ('+{_prefix}Ids+')')";
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddWithValue($"{_prefix}Ids", string.Join(",", idList));
return(command.ExecuteNonQuery());
}
}
else
{
var sql = $"EXEC('UPDATE [{entityInfo.TableName}] SET IsDel=1 WHERE [{entityInfo.KeyColumn}] in ('+{_prefix}Ids+')')";
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddWithValue($"{_prefix}Id", idList);
return(command.ExecuteNonQuery());
}
}
}
protected override string ResolveStackToField(Stack <string> parameterStack)
{
switch (parameterStack.Count)
{
case 2:
{
// 调用了导航属性
var propertyName = parameterStack.Pop();
var propertyFieldName = parameterStack.Pop();
MyEntity propertyEntity = Result.NavPropertyList.SingleOrDefault(p => p.Name == propertyName);
if (propertyEntity == null)
{
var prop = Entity.Properties.Single(p => p.Name == propertyName);
propertyEntity = MyEntityContainer.Get(prop.PropertyInfo.PropertyType);
Result.NavPropertyList.Add(propertyEntity);
}
var propertyProperty = propertyEntity.Properties.Single(p => p.Name == propertyFieldName);
return($"[{propertyName}].[{propertyProperty.FieldName}]");
}
case 1:
{
var propertyName = parameterStack.Pop();
var propInfo = Entity.Properties.Single(p => p.Name == propertyName);
return($"[{Entity.TableName}].[{propInfo.FieldName}]");
}
default:
throw new ArgumentException("尚未支持大于2层属性调用。如 student.Clazz.School.Id>10，请使用类似 student.Clazz.SchoolId > 0 替代");
}
}
public async Task <int> UpdateIfNotExitsAsync <T>(T entity, Expression <Func <T, bool> > where)
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var resolver = new EditConditionResolver <T>(entityInfo);
var result = resolver.Resolve(where.Body);
var condition = result.Condition;
var parameters = result.Parameters;
parameters.Add(entity);
condition = string.IsNullOrWhiteSpace(condition) ? "1=1" : condition;
var sqlBuilder = new SqlServerBuilder();
var sql = sqlBuilder.Update(entityInfo, "");
sql += $" AND NOT EXISTS (SELECT 1 FROM [{entityInfo.TableName}] WHERE {condition})";
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameters.Parameters);
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
return(await command.ExecuteNonQueryAsync());
}
}
public async Task <int> DeleteAsync <T>(Expression <Func <T, bool> > expression, bool isForce) where T : IEntity
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var resolver = new EditConditionResolver <T>(entityInfo);
var result = resolver.Resolve(expression.Body);
var condition = result.Condition;
var parameters = result.Parameters;
condition = string.IsNullOrWhiteSpace(condition) ? "1=1" : condition;
string sql;
if (isForce || !entityInfo.IsSoftDelete)
{
sql =
$"DELETE [{entityInfo.TableName}] WHERE {condition}";
}
else
{
sql =
$"UPDATE [{entityInfo.TableName}] SET IsDel=1 WHERE {condition}";
}
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddRange(parameters.Parameters);
return(await command.ExecuteNonQueryAsync());
}
}
public async Task <int> DeleteAsync <T>(int id, bool isForce = false) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
if (isForce || !entityInfo.IsSoftDelete)
{
var sql = $"DELETE [{entityInfo.TableName}] WHERE [{entityInfo.KeyColumn}]={_prefix}Id";
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddWithValue($"{_prefix}Id", id);
return(await command.ExecuteNonQueryAsync());
}
}
else
{
var sql = $"UPDATE [{entityInfo.TableName}] SET IsDel=1 WHERE [{entityInfo.KeyColumn}]={_prefix}Id";
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddWithValue($"{_prefix}Id", id);
return(await command.ExecuteNonQueryAsync());
}
}
}
private string ResolveStackToField(Stack <string> parameterStack)
{
switch (parameterStack.Count)
{
case 2:
{
// 调用了导航属性
var propertyName = parameterStack.Pop();
var propertyFieldName = parameterStack.Pop();
_joinProperties.Add(propertyName);
if (!_joinProperties.Contains(propertyName))
{
_joinProperties.Add(propertyName);
}
var prop = _master.Properties.Single(p => p.Name == propertyName);
var propertyEntity = MyEntityContainer.Get(prop.PropertyInfo.PropertyType);
var propertyProperty = propertyEntity.Properties.Single(p => p.Name == propertyFieldName);
return($"[{propertyName}].[{propertyProperty.FieldName}]");
}
case 1:
{
var propertyName = parameterStack.Pop();
var propInfo = _master.Properties.Single(p => p.Name == propertyName);
return($"[{_master.TableName}].[{propInfo.FieldName}]");
}
default:
throw new ArgumentException("尚未支持大于2层属性调用。如 student.Clazz.School.Id>10，请使用类似 student.Clazz.SchoolId > 0 替代");
}
}
/// <summary>
/// 如果不满足条件则创建一个实体，
/// 如限制用户名不能重复 InsertIfNotExist(user, u => u.Name == user.Name)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity">要创建的实体</param>
/// <param name="where">条件</param>
/// <returns>新生成记录的ID，若失败返回0</returns>
public int InsertIfNotExists <T>(T entity, Expression <Func <T, bool> > where) where T : class, IEntity, new()
{
if (where == null)
{
return(Insert(entity));
}
var entityInfo = MyEntityContainer.Get(typeof(T));
var resolver = new EditConditionResolver <T>(entityInfo);
var result = resolver.Resolve(@where.Body);
var condition = result.Condition;
var parameters = result.Parameters;
parameters.Add(entity);
condition = string.IsNullOrWhiteSpace(condition) ? "1=1" : condition;
var sqlBuilder = new SqlServerBuilder();
var sql = sqlBuilder.InsertIfNotExists(entityInfo, condition);
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameters.Parameters);
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
var obj = command.ExecuteScalar();
if (obj != DBNull.Value)
{
entity.Id = Convert.ToInt32(obj);
}
return(entity.Id);
}
}
public async Task <int> InsertAsync <T>(T entity) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerBuilder();
var sql = sqlBuilder.Insert(entityInfo);
var parameters = new MyDbParameters();
parameters.Add(entity);
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameters.Parameters);
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
var obj = await command.ExecuteScalarAsync();
if (obj != DBNull.Value)
{
entity.Id = Convert.ToInt32(obj);
}
return(entity.Id);
}
}
public T ConvertToObject(SqlDataReader sdr, List <KeyValuePair <string, string> > keyValuePairs)
{
var entity = new T();
foreach (var property in Master.Properties.Where(p => p.IsMap))
{
property.PropertyInfo.SetValue(entity, sdr[property.Name]);
}
foreach (var include in Includes)
{
var prop = Master.Properties.SingleOrDefault(p => p.Name == include);
if (prop != null)
{
var subType = prop.PropertyInfo.PropertyType;
var subEntityInfo = MyEntityContainer.Get(subType);
var subEntity = Activator.CreateInstance(subType);
foreach (var subProperty in subEntityInfo.Properties.Where(p => p.IsMap))
{
subProperty.PropertyInfo.SetValue(subEntity, sdr[$"{include}_{subProperty.Name}"]);
}
prop.PropertyInfo.SetValue(entity, subEntity);
}
}
return(entity);
}
private void ResolveStackToField(Stack <string> parameterStack)
{
if (parameterStack.Count == 2)
{
// 调用了导航属性
var propertyName = parameterStack.Pop();
var propertyFieldName = parameterStack.Pop();
_joinProperties.Add(propertyName);
var prop = _master.Properties.Single(p => p.Name == propertyName);
var propertyEntity = MyEntityContainer.Get(prop.PropertyInfo.PropertyType);
var propertyProperty = propertyEntity.Properties.Single(p => p.Name == propertyFieldName);
_stringStack.Push($"[{propertyName}].[{propertyProperty.FieldName}]");
}
else if (parameterStack.Count == 1)
{
var propertyName = parameterStack.Pop();
var propInfo = _master.Properties.Single(p => p.Name == propertyName);
_stringStack.Push($"[{_master.TableName}].[{propInfo.FieldName}]");
}
else
{
throw new ArgumentException("尚未支持大于2层属性调用。如 student.Clazz.School.Id>10，请使用类似 student.Clazz.SchoolId > 0 替代");
}
}
public MyUpdateable()
{
_entity = MyEntityContainer.Get(typeof(T));
_entityList = new List <T>();
_ignorePropertyList = new List <string>();
_includePropertyList = new List <string>();
_includeOrIgnore = 0;
_ignoreAttribute = true;
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity">要修改的实体</param>
/// <param name="expression">要修改的属性，注意不支持导航属性及其子属性</param>
/// <param name="ignoreAttribute">是否忽略实体的UpdateIgnore描述。默认为true，既includes中包含的所有属性都会被修改</param>
/// <returns>受影响的记录数</returns>
public int UpdateIgnore <T>(T entity, Expression <Func <T, object> > expression, bool ignoreAttribute = true) where T : IEntity
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var visitor = new ObjectExpressionVisitor(entityInfo);
visitor.Visit(expression);
var include = visitor.GetPropertyList().Select(kv => kv.Key);
return(UpdateIgnore(entity, include, ignoreAttribute));
}
public async Task <int> UpdateIgnoreAsync <T>(T entity, Expression <Func <T, object> > expression, bool ignoreAttribute = true) where T : IEntity
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var visitor = new ObjectMemberVisitor();
visitor.Visit(expression);
var include = visitor.GetPropertyList();
return(await UpdateIgnoreAsync(entity, include, ignoreAttribute));
}
/// 把要用到的导航属性的MyEntity缓存到一个List里，不需要每次都要到字典中获取
private MyEntity GetIncludePropertyEntityInfo(Type type)
{
var entity = _entityCache.FirstOrDefault(e => e.FullName == type.FullName);
if (entity != null)
{
return(entity);
}
entity = MyEntityContainer.Get(type);
_entityCache.Add(entity);
return(entity);
}
public SqlDataReaderConverter(IEnumerable <string> props = null)
{
_master = MyEntityContainer.Get(typeof(T));
_include = props?.ToList() ?? new List <string>();
_key = typeof(T).FullName;
if (_include.Count <= 0)
{
return;
}
_include.Sort();
_key += string.Join("-", _include.Distinct());
}
/// <summary>
/// 通过查询条件修改指定列
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="kvs">属性和值的键值对。用法 DbKvs.New().Add("属性名", 值)</param>
/// <param name="expression">查询条件，注意：不支持导航属性，如 "student => student.School.Id > 0" 将无法解析</param>
/// <returns>受影响的记录数</returns>
public int Update <T>(DbKvs kvs, Expression <Func <T, bool> > expression = null)
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var setProperties = kvs.Where(kv => kv.Key != "Id").Select(kv => kv.Key);
var includeProperties = entityInfo.Properties.Where(p => setProperties.Contains(p.Name)).ToList();
if (includeProperties.Count == 0)
{
return(0);
}
string sql;
List <SqlParameter> parameters;
if (expression == null)
{
sql =
$"UPDATE [{entityInfo.TableName}] SET {string.Join(",", includeProperties.Select(p => $"{p.FieldName}=@{p.Name}"))} WHERE Id=@Id";
parameters = kvs.ToSqlParameters();
}
else
{
//var whereExpressionVisitor = new WhereExpressionVisitor<T>();
//whereExpressionVisitor.Visit(expression);
//var where = whereExpressionVisitor.GetCondition();
//var whereParameters = whereExpressionVisitor.GetParameters().ToSqlParameters();
var resolver = new ConditionResolver(entityInfo);
resolver.Resolve(expression.Body);
var where = resolver.GetCondition();
var whereParameters = resolver.GetParameters().ToSqlParameters();
parameters = kvs.ToSqlParameters();
parameters.AddRange(whereParameters);
where = string.IsNullOrWhiteSpace(where) ? "1=1" : where;
sql =
$"UPDATE [{entityInfo.TableName}] SET {string.Join(",", includeProperties.Select(p => $"{p.FieldName}=@{p.Name}"))} WHERE {where}";
}
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddRange(parameters.ToArray());
return(command.ExecuteNonQuery());
}
}
public SqlDataReaderConverter(string[] props = null)
{
Master = MyEntityContainer.Get(typeof(T));
if (props == null || props.Length == 0)
{
Includes = new List <string>();
Key = typeof(T).FullName;
}
else
{
Includes = props.ToList();
Key = typeof(T).FullName + "-" + string.Join("-", props.OrderBy(p => p).Distinct());
}
}
public async Task <int> InsertAsync <T>(List <T> entityList) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerBuilder();
var sql = sqlBuilder.Insert(entityInfo);
var count = 0;
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
foreach (var entity in entityList)
{
using (var command = new SqlCommand(sql, conn, trans))
{
var parameters = new MyDbParameters();
parameters.Add(entity);
command.Parameters.AddRange(parameters.Parameters);
var obj = await command.ExecuteScalarAsync();
if (obj != DBNull.Value)
{
entity.Id = Convert.ToInt32(obj);
count++;
}
}
}
trans.Commit();
}
catch
{
trans.Rollback();
count = 0;
}
}
}
return(count);
}
public void ResolveMemberAccessExpression(MemberExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var rootType = expression.RootExpressionType(out var parameterStack);
if (rootType == ExpressionType.Parameter)
{
if (parameterStack.Count == 2)
{
// 调用了导航属性
var propertyName = parameterStack.Pop();
var propertyFieldName = parameterStack.Pop();
JoinPropertyList.Add(propertyName);
var prop = _master.Properties.Single(p => p.Name == propertyName);
var propertyEntity = MyEntityContainer.Get(prop.PropertyInfo.PropertyType);
var propertyProperty = propertyEntity.Properties.Single(p => p.Name == propertyFieldName);
_stringStack.Push($"[{propertyName}].[{propertyProperty.FieldName}]");
}
else if (parameterStack.Count == 1)
{
var propertyName = parameterStack.Pop();
var propInfo = _master.Properties.Single(p => p.Name == propertyName);
_stringStack.Push($"[{_master.TableName}].[{propInfo.FieldName}]");
}
else
{
throw new ArgumentException("尚未支持大于2层属性调用。如 student.Clazz.School.Id>10，请使用类似 student.Clazz.SchoolId > 0 替代");
}
}
else
{
var obj = ResolveValue(expression.GetValue());
var parameterName = $"{_prefix}__p_{_parameterIndex++}";
_parameters.Add(new KeyValuePair <string, object>(parameterName, obj));
_stringStack.Push($" {parameterName} ");
}
}
/// <summary>
/// 如果不满足条件则创建一个实体，
/// 如限制用户名不能重复 InsertIfNotExist(user, u => u.Name == user.Name)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity">要创建的实体</param>
/// <param name="where">条件</param>
/// <returns>新生成记录的ID，若失败返回0</returns>
public int InsertIfNotExists <T>(T entity, Expression <Func <T, bool> > where) where T : class, IEntity, new()
{
if (where == null)
{
return(Insert(entity));
}
else
{
var entityInfo = MyEntityContainer.Get(typeof(T));
//var whereExpressionVisitor = new WhereExpressionVisitor<T>(entityInfo);
//whereExpressionVisitor.Visit(where);
//var condition = whereExpressionVisitor.GetCondition();
//var parameters = whereExpressionVisitor.GetParameters().ToSqlParameters();
var resolver = new ConditionResolver(entityInfo);
resolver.Resolve(where.Body);
var condition = resolver.GetCondition();
var parameters = resolver.GetParameters().ToSqlParameters();
condition = string.IsNullOrWhiteSpace(condition) ? "1=1" : condition;
var sqlBuilder = new SqlServerSqlBuilder();
var sql = sqlBuilder.InsertIfNotExists(entityInfo, condition);
parameters.AddRange(
entityInfo
.Properties
.Where(p => !p.InsertIgnore)
.Select(p => new SqlParameter($"{_prefix}{p.Name}",
ResolveParameterValue(p.PropertyInfo.GetValue(entity)))));
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameters.ToArray());
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
var result = command.ExecuteScalar().ToString();
entity.Id = Convert.ToInt32(string.IsNullOrWhiteSpace(result) ? "0" : result);
return(entity.Id);
}
}
}
/// <summary>
/// 批量创建实体，注意此方法效率不高
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entityList">实体列表</param>
/// <returns>受影响的记录数</returns>
public int Insert <T>(List <T> entityList) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerSqlBuilder();
var sql = sqlBuilder.Insert(entityInfo);
var count = 0;
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
foreach (var entity in entityList)
{
using (var command = new SqlCommand(sql, conn, trans))
{
command.Parameters.AddRange(entityInfo
.Properties
.Where(p => !p.InsertIgnore)
.Select(p => new SqlParameter($"{_prefix}{p.Name}",
ResolveParameterValue(p.PropertyInfo.GetValue(entity))))
.ToArray());
var result = command.ExecuteScalar().ToString();
entity.Id = Convert.ToInt32(string.IsNullOrWhiteSpace(result) ? "0" : result);
count++;
}
}
trans.Commit();
}
catch
{
trans.Rollback();
count = 0;
}
}
}
return(count);
}
/// <summary>
/// 更新多个实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entityList">要更新的实体列表</param>
/// <returns>受影响的记录数</returns>
public int Update <T>(List <T> entityList) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerSqlBuilder();
var sql = sqlBuilder.Update(entityInfo, "");
var count = 0;
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
foreach (var entity in entityList)
{
using (var command = new SqlCommand(sql, conn, trans))
{
command.Parameters.AddRange(entityInfo
.Properties
.Where(p => !p.UpdateIgnore || p.IsKey)
.Select(p => new SqlParameter($"{_prefix}{p.Name}",
ResolveParameterValue(p.PropertyInfo.GetValue(entity))))
.ToArray());
count += command.ExecuteNonQuery();
}
}
trans.Commit();
}
catch (Exception)
{
trans.Rollback();
count = 0;
}
}
}
return(count);
}
public string GetFieldFullName(Stack <string> stack)
{
if (stack.Count == 1)
{
var fieldName = stack.Pop();
var property = _master.Properties.Single(p => p.Name == fieldName);
return($"[{_master.TableName}].[{property.FieldName}]");
}
else if (stack.Count == 2)
{
var propertyName = stack.Pop();
var fieldName = stack.Pop();
var property = _master.Properties.Single(p => p.Name == propertyName);
var propertyEntity = MyEntityContainer.Get(property.PropertyInfo.PropertyType);
var field = propertyEntity.Properties.Single(p => p.Name == fieldName);
return($"[{propertyName}].[{field.FieldName}]");
}
return(string.Empty);
}
public async Task <int> GetCountAsync <T>(Expression <Func <T, bool> > expression = null) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
if (expression == null)
{
var sql = $"SELECT COUNT(0) FROM [{entityInfo.TableName}]";
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
return((int)command.ExecuteScalar());
}
}
else
{
var resolver = new EditConditionResolver <T>(entityInfo);
var result = resolver.Resolve(expression.Body);
var condition = result.Condition;
var parameters = result.Parameters;
condition = string.IsNullOrWhiteSpace(condition) ? "1=1" : condition;
var sql = $"SELECT COUNT(0) FROM [{entityInfo.TableName}] WHERE [{condition}]";
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
var command = new SqlCommand(sql, conn);
command.Parameters.AddRange(parameters.Parameters);
var obj = await command.ExecuteScalarAsync();
if (obj == null)
{
return(0);
}
return((int)obj);
}
}
}
/// <summary>
/// 如果不存在，则更新
/// 如：UpdateIfNotExists(user, u=>u.Name == user.Name && u.Id != user.Id)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="where"></param>
/// <returns>受影响的记录数</returns>
public int UpdateIfNotExits <T>(T entity, Expression <Func <T, bool> > where)
{
var entityInfo = MyEntityContainer.Get(typeof(T));
//var whereExpressionVisitor = new WhereExpressionVisitor<T>(entityInfo);
//whereExpressionVisitor.Visit(where);
//var condition = whereExpressionVisitor.GetCondition();
//var parameters = whereExpressionVisitor.GetParameters().ToSqlParameters();
var resolver = new ConditionResolver(entityInfo);
resolver.Resolve(where.Body);
var condition = resolver.GetCondition();
var parameters = resolver.GetParameters().ToSqlParameters();
condition = string.IsNullOrWhiteSpace(condition) ? "1=1" : condition;
var sqlBuilder = new SqlServerSqlBuilder();
var sql = sqlBuilder.Update(entityInfo, "");
sql += $" AND NOT EXISTS (SELECT 1 FROM [{entityInfo.TableName}] WHERE {condition})";
parameters.AddRange(
entityInfo
.Properties
.Where(p => !p.UpdateIgnore || p.IsKey)
.Select(p => new SqlParameter($"{_prefix}{p.Name}",
ResolveParameterValue(p.PropertyInfo.GetValue(entity)))));
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameters.ToArray());
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
return(command.ExecuteNonQuery());
}
}
public async Task <int> UpdateAsync <T>(T entity) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerBuilder();
var sql = sqlBuilder.Update(entityInfo, "");
var parameters = new MyDbParameters();
parameters.Add(entity);
var command = new SqlCommand(sql);
command.Parameters.AddRange(parameters.Parameters);
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
command.Connection = conn;
return(await command.ExecuteNonQueryAsync());
}
}
/// <summary>
/// 更新多个实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entityList">要更新的实体列表</param>
/// <returns>受影响的记录数</returns>
public int Update <T>(List <T> entityList) where T : class, IEntity, new()
{
var entityInfo = MyEntityContainer.Get(typeof(T));
var sqlBuilder = new SqlServerBuilder();
var sql = sqlBuilder.Update(entityInfo, "");
var count = 0;
using (var conn = new SqlConnection(_connectionString))
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
foreach (var entity in entityList)
{
using (var command = new SqlCommand(sql, conn, trans))
{
var param = new MyDbParameters();
param.Add(entity);
command.Parameters.AddRange(param.Parameters);
count += command.ExecuteNonQuery();
}
}
trans.Commit();
}
catch (Exception)
{
trans.Rollback();
count = 0;
}
}
}
return(count);
}
