private static ICondition GenerateCondition(IModel conditional, ConditionalPropertyDescripor property)
{
//如果当前属性值为默认值，则忽略它
if (property == null)
{
return(null);
}
//获取当前属性对应的条件命列表
var names = GetConditionNames(property);
//创建转换器上下文
var context = new ConditionalConverterContext(conditional,
property.Attribute == null ? ConditionalBehaviors.None : property.Attribute.Behaviors,
names,
property.PropertyType,
property.GetValue(conditional),
property.Operator);
//如果当前属性指定了特定的转换器，则使用该转换器来处理
if (property.Converter != null)
{
return(property.Converter.Convert(context));
}
//使用默认转换器进行转换处理
return(ConditionalConverter.Default.Convert(context));
}
public virtual ICondition Convert(ConditionalConverterContext context)
{
//如果当前属性值为默认值，则忽略它
if (this.IsDefaultValue(context))
{
return(null);
}
var opt = context.Operator;
var isRange = Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(ConditionalRange), context.Type);
//只有当属性没有指定运算符并且不是区间属性，才需要生成运算符
if (opt == null && (!isRange))
{
opt = ConditionOperator.Equal;
if (context.Type == typeof(string) && context.Value != null)
{
opt = ConditionOperator.Like;
}
else if (typeof(IEnumerable).IsAssignableFrom(context.Type) || Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(IEnumerable <>), context.Type))
{
opt = ConditionOperator.In;
}
}
//如果当前属性只对应一个条件
if (context.Names.Length == 1)
{
if (isRange)
{
return(((ConditionalRange)context.Value).ToCondition(context.Names[0]));
}
else
{
return(new Condition(context.Names[0], (opt == ConditionOperator.Like && _wildcard != '\0' ? _wildcard + context.Value.ToString().Trim(_wildcard) + _wildcard : context.Value), opt.Value));
}
}
//当一个属性对应多个条件，则这些条件之间以“或”关系进行组合
var conditions = new ConditionCollection(ConditionCombination.Or);
foreach (var name in context.Names)
{
if (isRange)
{
conditions.Add(((ConditionalRange)context.Value).ToCondition(name));
}
else
{
conditions.Add(new Condition(name, (opt == ConditionOperator.Like && _wildcard != '\0' ? _wildcard + context.Value.ToString().Trim(_wildcard) + _wildcard : context.Value), opt.Value));
}
}
return(conditions);
}
protected bool IsIgnorable(ConditionalConverterContext context)
{
if ((context.Behaviors & ConditionalBehaviors.IgnoreNull) == ConditionalBehaviors.IgnoreNull && context.Value == null)
{
return(true);
}
if ((context.Behaviors & ConditionalBehaviors.IgnoreEmpty) == ConditionalBehaviors.IgnoreEmpty && context.Type == typeof(string) && string.IsNullOrWhiteSpace((string)context.Value))
{
return(true);
}
if (IsRange(context.Type))
{
return(Range.IsEmpty(context.Value));
}
return(false);
}
protected bool IsIgnorable(ConditionalConverterContext context)
{
if ((context.Behaviors & ConditionalBehaviors.IgnoreNull) == ConditionalBehaviors.IgnoreNull && context.Value == null)
{
return(true);
}
if ((context.Behaviors & ConditionalBehaviors.IgnoreEmpty) == ConditionalBehaviors.IgnoreEmpty && context.Type == typeof(string) && string.IsNullOrWhiteSpace((string)context.Value))
{
return(true);
}
if (typeof(IConditionalRange).IsAssignableFrom(context.Type))
{
return(context.Value == null || ((IConditionalRange)context.Value).HasValue == false);
}
return(false);
}
public virtual ICondition Convert(ConditionalConverterContext context)
{
//如果当前属性值为默认值，则忽略它
if(this.IsDefaultValue(context))
return null;
var opt = context.Operator;
var isRange = Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(ConditionalRange), context.Type);
//只有当属性没有指定运算符并且不是区间属性，才需要生成运算符
if(opt == null && (!isRange))
{
opt = ConditionOperator.Equal;
if(context.Type == typeof(string) && context.Value != null)
opt = ConditionOperator.Like;
else if(typeof(IEnumerable).IsAssignableFrom(context.Type) || Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(IEnumerable<>), context.Type))
opt = ConditionOperator.In;
}
//如果当前属性只对应一个条件
if(context.Names.Length == 1)
{
if(isRange)
return ((ConditionalRange)context.Value).ToCondition(context.Names[0]);
else
return new Condition(context.Names[0], (opt == ConditionOperator.Like && _wildcard != '\0' ? _wildcard + context.Value.ToString().Trim(_wildcard) + _wildcard : context.Value), opt.Value);
}
//当一个属性对应多个条件，则这些条件之间以“或”关系进行组合
var conditions = new ConditionCollection(ConditionCombination.Or);
foreach(var name in context.Names)
{
if(isRange)
conditions.Add(((ConditionalRange)context.Value).ToCondition(name));
else
conditions.Add(new Condition(name, (opt == ConditionOperator.Like && _wildcard != '\0' ? _wildcard + context.Value.ToString().Trim(_wildcard) + _wildcard : context.Value), opt.Value));
}
return conditions;
}
protected bool IsDefaultValue(ConditionalConverterContext context)
{
if (Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(ConditionalRange), context.Type))
{
return(ConditionalRange.IsEmpty(context.Value as ConditionalRange));
}
if (context.Value == null || System.Convert.IsDBNull(context.Value))
{
return(context.DefaultValue == null || System.Convert.IsDBNull(context.DefaultValue));
}
if (context.DefaultValue == null)
{
return(false);
}
object defaultValue;
return(Zongsoft.Common.Convert.TryConvertValue(context.DefaultValue, context.Value.GetType(), out defaultValue) &&
object.Equals(context.Value, defaultValue));
}
private ICondition GenerateCondition(ConditionalPropertyDescripor property)
{
//如果当前属性值为默认值，则忽略它
if (property == null)
{
return(null);
}
//获取当前属性对应的条件命列表
var names = this.GetConditionNames(property);
//创建转换器上下文
var context = new ConditionalConverterContext(this, names, property.PropertyType, property.GetValue(this), property.Operator, property.DefaultValue);
//如果当前属性指定了特定的转换器，则使用该转换器来处理
if (property.Converter != null)
{
return(property.Converter.Convert(context));
}
//使用默认转换器进行转换处理
return(ConditionalConverter.Default.Convert(context));
}
public virtual ICondition Convert(ConditionalConverterContext context)
{
//判断当前属性是否可以忽略
if (this.IsIgnorable(context))
{
return(null);
}
ICondition result = null;
void Fallback(Func <string, Condition> factory)
{
if (context.Names.Length == 1)
{
result = factory(context.Names[0]);
return;
}
var criteria = ConditionCollection.Or();
foreach (var name in context.Names)
{
criteria.Add(factory(name));
}
result = criteria;
}
//确定是否为区间值，如果是则返回区间条件
if (IsRange(context.Type) && Range.HasValue(context.Value, Fallback))
{
return(result);
}
var optor = context.Operator;
//只有当属性没有指定运算符需要确定运算符
if (optor == null)
{
optor = ConditionOperator.Equal;
if (context.Type == typeof(string) && context.Value != null)
{
optor = ConditionOperator.Like;
}
else if (typeof(IEnumerable).IsAssignableFrom(context.Type) || Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(IEnumerable <>), context.Type))
{
optor = ConditionOperator.In;
}
}
//如果当前属性只对应一个条件
if (context.Names.Length == 1)
{
return(new Condition(context.Names[0], this.GetValue(optor, context.Value), optor.Value));
}
//当一个属性对应多个条件，则这些条件之间以“或”关系进行组合
var conditions = ConditionCollection.Or();
foreach (var name in context.Names)
{
conditions.Add(new Condition(name, this.GetValue(optor, context.Value), optor.Value));
}
return(conditions);
}
private ICondition GenerateCondition(ConditionalPropertyDescripor property)
{
//如果当前属性值为默认值，则忽略它
if(property == null)
return null;
//获取当前属性对应的条件命列表
var names = this.GetConditionNames(property);
//创建转换器上下文
var context = new ConditionalConverterContext(this, names, property.PropertyType, property.GetValue(this), property.Operator, property.DefaultValue);
//如果当前属性指定了特定的转换器，则使用该转换器来处理
if(property.Converter != null)
return property.Converter.Convert(context);
//使用默认转换器进行转换处理
return ConditionalConverter.Default.Convert(context);
}
protected bool IsDefaultValue(ConditionalConverterContext context)
{
if(Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(ConditionalRange), context.Type))
return ConditionalRange.IsEmpty(context.Value as ConditionalRange);
if(context.Value == null || System.Convert.IsDBNull(context.Value))
return context.DefaultValue == null || System.Convert.IsDBNull(context.DefaultValue);
if(context.DefaultValue == null)
return false;
object defaultValue;
return Zongsoft.Common.Convert.TryConvertValue(context.DefaultValue, context.Value.GetType(), out defaultValue) &&
object.Equals(context.Value, defaultValue);
}
