C# IOperand类代码示例

        private Bucket(IOperand operand)
        {
            if (operand == null)
                throw new ArgumentNullException("operand");

            _operand = operand;
        }

 protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
     IOperand fieldRefOperand, IOperand valueOperand)
     : base(operationResultBuilder)
 {
     this.fieldRefOperand = fieldRefOperand;
     this.valueOperand = valueOperand;
 }

 protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
     IOperand columnOperand, IOperand valueOperand)
     : base(operationResultBuilder)
 {
     this.ColumnOperand = columnOperand;
     this.ValueOperand = valueOperand;
 }

        public void ReplaceLastOperand(IOperand operand)
        {
            if (Operands.Count == 0)
            {
                throw new InvalidOperationException("There are no operands to replace.");
            }


            int stealIndex = Operands.Count - 1;
            
            NativeOperation op = Operands[stealIndex] as NativeOperation;

            // Check if the "steal" target is itself something that we can steal from, if so, 
            // recurse. This rule of checkiung association type is a bit confusing, this should
            // be a property?

            if (op !=null && op.Operands.Count > 1 && op.AssociationType == AssociationType.Multiplicaton)
            {
                IOperation func = (IOperation)op;
                func.ReplaceLastOperand(operand);
            }
            else
            {
                _Operands[Operands.Count - 1] = operand;
            }
        }

 public IOperand GreaterThan(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.> : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = ((long)this.Value > (long)((Operand)rhs).Value) ? true : false;
     return oprResult;
 }

 /// IComparisonOperators methods.  Return values are always BooleanOperands type
 public IOperand EqualTo(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.== : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = (long)this.Value == (long)((Operand)rhs).Value;
     return oprResult;
 }

 public IOperand Divide(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.Divide : rhs");
     LongOperand oprResult = new LongOperand("Result", Type.GetType("System.Int64"));
     oprResult.Value = (long)this.Value / (long)((Operand)rhs).Value;
     return oprResult;
 }

 public IOperand LessThanOrEqualTo(IOperand rhs)
 {
     if (!(rhs is LongOperand))
         throw new RPN_Exception("Argument invalid in LongOperand.<= : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = ((long)this.Value <= (long)((Operand)rhs).Value) ? true : false;
     return oprResult;
 }

 public IOperand OR(IOperand rhs)
 {
     if (!(rhs is BoolOperand))
         throw new RPN_Exception("Argument invalid in BoolOperand.|| : rhs");
     BoolOperand oprResult = new BoolOperand("Result");
     oprResult.Value = ((bool)this.Value || (bool)((Operand)rhs).Value) ? true : false;
     return oprResult;
 }

        internal static bool Match(PackageItem package, IOperand operand)
        {
            var expression = operand as Expression;

            if (expression != null)
                return MatchExpression(package, expression);
            return MatchPredicate(package, operand);
        }

        public void ReplaceLastOperand(IOperand operand)
        {
            if (Operands.Count == 0)
            {
                throw new InvalidOperationException("There are no operands to replace.");
            }

            _Operands[Operands.Count - 1] = operand;
        }

 protected override IOperand CopyTo(IOperand operand)
 {
     NativeOperation target = (NativeOperation)operand;
     foreach (var item in _Operators)
     {
         target._Operators.Add(item);
     }
     return base.CopyTo(target);
 }

 public DateRangesOverlapOperation(IOperationResultBuilder operationResultBuilder,
     IOperand startFieldRefOperand, IOperand stopFieldRefOperand, IOperand recurrenceFieldRefOperand, IOperand dateTimeOperand)
     : base(operationResultBuilder)
 {
     this.startFieldRefOperand = startFieldRefOperand;
     this.stopFieldRefOperand = stopFieldRefOperand;
     this.recurrenceFieldRefOperand = recurrenceFieldRefOperand;
     this.dateTimeOperand = dateTimeOperand;
 }

        private static bool MatchPredicate(PackageItem package, IOperand predicate)
        {
            var unaryPredicate = predicate as UnaryPredicate;
            if (unaryPredicate != null)
                return MatchPredicate(package, unaryPredicate);

            var binaryPredicate = predicate as BinaryPredicate;
            if (binaryPredicate != null)
                return MatchPredicate(package, binaryPredicate);

            return true;
        }

        private Range(IOperand min = null, IOperand max = null, bool minInclusive = false, bool maxInclusive = false)
        {
            if (min == null && max == null)
                throw new ArgumentException("Min and max cannot both be null.");

            // TODO check min < max?

            Min = min;
            Max = max;
            MinInclusive = minInclusive;
            MaxInclusive = maxInclusive;
        }