public class DynamicQuery<T> where T : class, new
()
{
private ExpressionStarter<T> _predicate;
private DynamicQuery
()
{
_predicate = PredicateBuilder
.New<T>
(true
); // 初始为 true，用于 AND 连接
}
/// <summary>
/// 创建新查询实例
/// </summary>
public static DynamicQuery<T> New
() => new DynamicQuery<T>
();
/// <summary>
/// 等值查询：WHERE Field = value
/// </summary>
public DynamicQuery<T> Where<U>
(Expression<Func<T, U>> field, U value
)
{
if
(value == null
) return this;
if
(value is
string str &&
string.IsNullOrWhiteSpace
(str)) return this;
_predicate = _predicate
.And
(field
.Compose
(f => f
.Equals
(value
)));
return this;
}
/// <summary>
/// IN 查询：WHERE Field IN
(values
)
/// </summary>
public DynamicQuery<T> WhereIn<U>
(Expression<Func<T, U>> field,
string values, char separator = ','
)
{
if
(string.IsNullOrWhiteSpace
(values
)) return this;
//var items = values
.Split(separator
).Select
(v => v
.Trim
()).Where
(v => !
string.IsNullOrEmpty
(v
)).ToArray
();
//if
(!items
.Any
()) return this;
//// 使用 SqlSugar 的 In 方法更高效（直接生成 IN SQL）
//// 但我们这里仍用表达式树方式保持一致性
var inner = PredicateBuilder
.New<T>
(false
); // OR 组合起点
//foreach
(var item in items
)
//{
// //var temp = ConvertValue<U>
(item
);
// inner = inner
.Or
(field
.Compose
(f => f
.Equals
(item
)));
//}
//_predicate = _predicate
.And
(inner
);
var hasValidCondition = false;
var rawValues = values
.Split(separator
).Select
(v => v
.Trim
()).Where
(v => !
string.IsNullOrEmpty
(v
));
foreach
(var val in rawValues
)
{
if
(TryConvertValue<U>
(val,
out var parsed
))
{
inner = inner
.Or
(field
.Compose
(f => f
.Equals
(parsed
)));
hasValidCondition = true;
}
else
{
Console
.WriteLine
($"[Filter Warning] 无法将 '{val}' 转换为 {typeof
(U
).Name}，已忽略。"
);
}
}
if
(hasValidCondition
)
{
_predicate = _predicate
.And
(inner
);
}
return this;
}
/// <summary>
/// 范围查询：BETWEEN min AND max
/// </summary>
public DynamicQuery<T> WhereRange<U>
(Expression<Func<T, U>> field, U? min = null, U? max = null
)
where U :
struct, IComparable<U>
{
if
(min
.HasValue
)
{
_predicate = _predicate
.And
(field
.Compose
(f => f
.CompareTo
(min
.Value
) >= 0
));
}
if
(max
.HasValue
)
{
_predicate = _predicate
.And
(field
.Compose
(f => f
.CompareTo
(max
.Value
) <= 0
));
}
return this;
}
/// <summary>
/// 模糊查询：LIKE '%keyword%'
/// </summary>
public DynamicQuery<T> WhereLike
(Expression<Func<T,
string>> field,
string keyword
)
{
if
(string.IsNullOrWhiteSpace
(keyword
)) return this;
_predicate = _predicate
.And
(field
.Compose
(s => s
.Contains
(keyword
)));
return this;
}
/// <summary>
/// 自定义表达式条件
/// </summary>
public DynamicQuery<T> Where
(Expression<Func<T, bool>> condition
)
{
_predicate = _predicate
.And
(condition
);
return this;
}
/// <summary>
/// 异步获取全部结果
/// </summary>
public async Task<List<T>> ToListAsync
(SqlSugarClient db
)
{
var lambda = _predicate as Expression<Func<T, bool>>;
return await db
.Queryable<T>
().Where
(lambda
.Expand
()).ToListAsync
();
}
/// <summary>
/// 分页查询（返回数据 + 总数）
/// </summary>
public async Task<List<T>> ToPageAsync
(SqlSugarClient db, int pageIndex, int pageSize
)
{
var lambda = _predicate as Expression<Func<T, bool>>;
var data = await db
.Queryable<T>
().Where
(lambda
.Expand
()).ToPageListAsync
(pageIndex, pageSize
);
return data;
}
/// <summary>
/// 获取总数
/// </summary>
public async Task<int> CountAsync
(SqlSugarClient db
)
{
var lambda = _predicate as Expression<Func<T, bool>>;
return await db
.Queryable<T>
().Where
(lambda
.Expand
()).CountAsync
();
}
#region 辅助方法
/// <summary>
/// 安全转换字符串为指定类型
/// </summary>
private static U ConvertValue<U>
(string value
)
{
try
{
if
(typeof
(U
) == typeof
(string))
return
(U
)(object
)value;
return
(U
)Convert
.ChangeType
(value, typeof
(U
));
}
catch
{
return default!;
}
}
/// <summary>
/// 安全地将字符串转换为指定类型 U
/// </summary>
/// <param name="value">输入字符串</param>
/// <param name="result">输出结果</param>
/// <returns>是否成功</returns>
private static bool TryConvertValue<U>
(string value,
out U result
)
{
result = default!;
if
(string.IsNullOrWhiteSpace
(value
))
{
// 对于可空类型，null 是合法值
var type = Nullable
.GetUnderlyingType
(typeof
(U
)) ?? typeof
(U
);
if
(!type
.IsValueType ||
(Nullable
.GetUnderlyingType
(type
) != null
))
{
return true; // 允许 null 赋值给引用类型或 nullable
}
return false;
}
value = value
.Trim
();
try
{
var targetType = typeof
(U
);
// 处理
string 特殊情况
if
(targetType == typeof
(string))
{
result =
(U
)(object
)value;
return true;
}
// 获取真实类型（处理 Nullable<T>）
var underlyingType = Nullable
.GetUnderlyingType
(targetType
) ?? targetType;
// 常见类型特殊处理（更安全）
if
(underlyingType == typeof
(int
))
{
if
(int
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(long
))
{
if
(long
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(short
))
{
if
(short
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(decimal
))
{
if
(decimal
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(double
))
{
if
(double
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(float
))
{
if
(float
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(bool
) || underlyingType == typeof
(bool?
))
{
if
(bool
.TryParse(value,
out var parsed
) ||
value
.Equals
("1",
StringComparison
.OrdinalIgnoreCase
) ||
value
.Equals
("0",
StringComparison
.OrdinalIgnoreCase
))
{
var boolVal = value switch
{
"1" or "true" or "yes" => true,
"0" or "false" or "no" => false,
_ => bool
.Parse
(value
)
};
result =
(U
)(object
)boolVal;
return true;
}
}
else if
(underlyingType == typeof
(Guid
) || underlyingType == typeof
(Guid?
))
{
if
(Guid
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType == typeof
(DateTime
) || underlyingType == typeof
(DateTime?
))
{
if
(DateTime
.TryParse(value,
out var parsed
)) { result =
(U
)(object
)parsed; return true; }
}
else if
(underlyingType
.Is
Enum)
{
if
(Enum.TryParse(underlyingType, value, true,
out var parsed
))
{
result =
(U
)parsed!;
return true;
}
}
// 最后兜底：使用 Convert
.ChangeType（谨慎）
var converted = Convert
.ChangeType
(value, underlyingType
);
result =
(U
)converted;
return true;
}
catch
{
return false;
}
}
#endregion
} LinqKit SqlSugar 实现 动态参数 var query = DynamicQuery<文物登记表>
.New
().Where
(o => o
.回收站, "否"
); query
.WhereIn
(x => x
.库房名,
string.Join
(",", vals
)); vals=“A,123” var totalNumber = await query
.CountAsync
(_db
.CopyNew
()); 时报错 sql 输出 SELECT COUNT
(1
) FROM [文物登记表] WHERE
(({0}
))
本文探讨了C#中枚举类型的应用，包括颜色枚举的解析与转换，以及如何使用List进行元素查找和过滤操作。通过示例代码展示了如何创建枚举，将其成员转换为字符串，并判断字符串是否能被正确解析回枚举值。此外，还介绍了如何从一个整数数组中筛选出不在另一个数组中的元素，最后展示了文件路径获取的方法。
扫一扫
928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
