/// <summary>
/// ctor
/// </summary>
/// <param name="operation">A filter transforming operation.</param>
/// <param name="strategy">A filtering strategy.</param>
protected NotOperationBase(
Func <Expression <Func <TEntity, bool> >, Expression <Func <TEntity, bool> > > operation,
IOperationStrategy strategy)
{
Operation = operation;
Strategy = strategy;
}
/// <inheritdoc />
public ConditionAndOperation(
Func <Expression <Func <TEntity, bool> >, Expression <Func <TEntity, bool> > > baseOperation,
bool condition,
IOperationStrategy strategy)
: base(baseOperation, condition, strategy)
{
}
/// <summary>
/// ctor
/// </summary>
/// <param name="baseOperation">A filter transforming operation.</param>
/// <param name="condition">The condition.</param>
/// <param name="strategy">The filtering strategy.</param>
protected ConditionOperationBase(
Func <Expression <Func <TEntity, bool> >, Expression <Func <TEntity, bool> > > baseOperation,
bool condition,
IOperationStrategy strategy)
: base(strategy)
{
_condition = condition;
_baseOperation = baseOperation;
}
/// <summary>
/// Filters a sequence of entities based on a predicate builder.
/// </summary>
/// <typeparam name="T">Entity type.</typeparam>
/// <param name="source">An entity sequence.</param>
/// <param name="builder">A predicate builder.</param>
/// <param name="strategy">A filtering strategy.</param>
public static IQueryable <T> Build <T>(
[NotNull] this IQueryable <T> source,
[NotNull] Func <ILogicOperation <T>, IQueryBuilderResult <T> > builder,
[NotNull] IOperationStrategy strategy)
{
var expression = CreateExpression(builder, strategy);
return(expression == null
? source
: source.Where(expression));
}
/// <summary>
/// Filters a sequence of entities based on a predicate builder.
/// </summary>
/// <typeparam name="T">Entity type.</typeparam>
/// <param name="builder">A predicate builder.</param>
/// <param name="strategy">A filtering strategy.</param>
public static Expression <Func <T, bool> > CreateExpression <T>(
[NotNull] Func <ILogicOperation <T>, IQueryBuilderResult <T> > builder,
[NotNull] IOperationStrategy strategy)
{
_ = builder ?? throw new ArgumentException("Builder cannot be null", nameof(builder));
_ = strategy ?? throw new ArgumentException("Strategy cannot be null", nameof(strategy));
var init = new QueryBuilder <T>(strategy);
var expression = builder(init).GetExpression();
return(expression);
}
// 运用简单工厂产生策略
public OperationContext(string operate)
{
switch (operate)
{
case "+":
strategy = new AddStrtegy();
break;
case "-":
//strategy = new SubStrtegy();
break;
default: break;
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="strategy">A filtering strategy.</param>
public QueryBuilder(IOperationStrategy strategy)
: base(new QueryBuilderResult <TEntity>(strategy), strategy)
{
}
public ContextOperation(IOperationStrategy strategy)
{
this.strategy = strategy;
}
/// <inheritdoc/>
public OrOperation(QueryBuilderResult<TEntity> builderResult, IOperationStrategy strategy)
: base(builderResult, strategy)
{
}
/// <summary>
/// ctor.
/// </summary>
/// <param name="builderResult">An intermediate builder.</param>
/// <param name="strategy">A filtering strategy.</param>
protected LogicOperation(IAndOrQueryBuilderResult <TEntity> builderResult, IOperationStrategy strategy)
: this(strategy)
{
BuilderResult = builderResult;
}
/// <inheritdoc />
public NotOrOperation(
Func <Expression <Func <TEntity, bool> >, Expression <Func <TEntity, bool> > > operation,
IOperationStrategy strategy)
: base(operation, strategy)
{
}
/// <summary>
/// ctor.
/// </summary>
/// <param name="strategy">A filtering strategy.</param>
protected LogicOperation(IOperationStrategy strategy)
{
Strategy = strategy;
}
// Uses Strategy design pattern
public static double Calculate(IOperationStrategy operation, double value1, double value2)
{
return(operation.Calculate(value1, value2));
}
/// <summary>
/// ctor
/// </summary>
/// <param name="strategy">A filtering strategy.</param>
public QueryBuilderResult(IOperationStrategy strategy)
: this(null, strategy)
{
}
public OperationContext(IOperationStrategy strategy)
{
this.strategy = strategy;
}
public Calculator(IOperationStrategy <T> addition, IOperationStrategy <T> substraction, IOperationStrategy <T> division)
{
Addition = addition;
Substraction = substraction;
Division = division;
}
public MathOperation(IOperationStrategy strategy)
{
this.operationStrategy = strategy;
}
public void SetStrategy(IOperationStrategy strategy)
{
this.strategy = strategy;
}
/// <summary>
/// ctor
/// </summary>
/// <param name="predicate">The filtering expression.</param>
/// <param name="strategy">A filtering strategy.</param>
public QueryBuilderResult(Expression <Func <TEntity, bool> > predicate, IOperationStrategy strategy)
{
_predicate = predicate;
Strategy = strategy;
}
