C# ConditionType类代码示例

 public DoLoopStatement(Expression condition, Statement embeddedStatement, ConditionType conditionType, ConditionPosition conditionPosition)
 {
     this.condition = condition;
     this.embeddedStatement = embeddedStatement;
     this.conditionType = conditionType;
     this.conditionPosition = conditionPosition;
 }

 public IntBooleanCondition(string field, int condition, ConditionType conditionType = ConditionType.OR, bool negate = false)
 {
     Field = field;
     Condition = condition.ToString();
     ConditionType = conditionType;
     Negate = negate;
 }

 public Result(ConditionType Type, string Variable, string Op, int Value)
 {
     this.Type = Type;
     this.Variable = Variable;
     this.Op = Op;
     this.Value = Value;
 }

 public ConditionTreeLeaf(ConditionType type, string name, ConditionComparison comparison, PropertyUnion compareTo)
 {
     Type = type;
     VariableName = name;
     Comparison = comparison;
     CompareTo = compareTo;
 }

        public GroupedCondition(IBooleanCondition conditionA, ConditionType conditionType, IBooleanCondition conditionB)
        {
            condition = conditionType;

            this.conditionA = conditionA;
            this.conditionB = conditionB;
        }

        public ConditionModel Build(string expression, Type dataContextType, ConditionType conditionType)
        {
            if (String.IsNullOrWhiteSpace(expression))
            {
                return new ConditionModel();
            }

            _stack = new Stack<object>();
            _parameters = RuleParameterProviders.Providers.SelectMany(x => x.GetParameters(dataContextType).ToList())
                                                      .DistinctBy(x => x.Name)
                                                      .ToList();

            var exp = Expression.Parse(expression);
            Visit(exp);

            var top = _stack.Peek();
            if (top is ComparisonModel)
            {
                BuildComparisonGroup();
            }

            BuildConditionModel(conditionType);

            var model = (ConditionModel)_stack.Pop();
            model.Expression = expression;

            return model;
        }

        public Filters Or(string name, ConditionType conditionType, object value)
        {
            this.filters.Add(
                new Filter { Name = name, Value = value, FilterType = FilterType.Or, ConditionType = conditionType });

            return this;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Condition"/> class.
 /// </summary>
 /// <param name="label">The label.</param>
 public Condition(string label)
 {
     _label = label;
     _subconditions = new List<LeftHandSideCondition>();
     _conditionType = ConditionType.Positive;
     _fields = new Term[3];
     _evaluator = new Equals();
 }

 /// <summary>
 /// Creates a new Jump or Call instruction
 /// </summary>
 /// <param name="isCall">true if this is a call instruction</param>
 /// <param name="dest">destination address</param>
 /// <param name="condition">the condition to execute this instruction on</param>
 public JumpCall(bool isCall,
                 short dest,
                 ConditionType condition = ConditionType.Unconditional)
     : base(condition)
 {
     this.IsCall = isCall;
     this.Destination = dest;
 }

 public IcmpConstInstruction(ConditionType cond, VirtualRegister rd, VirtualRegister r1, int immed)
     : base("icmp")
 {
     this.cond = cond;
     this.r1 = r1;
     this.immed = immed;
     this.rd = rd;
 }

 // <summary>
 /// 添加一个筛选条件
 /// </summary>
 public void AddCondition(Conditionner condition, ConditionType AndOr) {
     if (gszConditionner != "") {
         gszConditionner += " " + (AndOr == ConditionType.And ? "and" : "or");
         gszConditionner += " (" + condition.ToString() + ")";
     } else {
         gszConditionner = "(" + condition.ToString() + ")";
     }
 }

        public CastCondition(int conditionGroup, ConditionType type, double[] values, ConditionValueName[] valuenames)
        {
            this.ConditionGroup = conditionGroup;
            this.Type = type;
            this.Values = values;
            this.ValueNames = valuenames;

        }

 public IcmpInstruction(ConditionType cond, VirtualRegister rd, VirtualRegister r1, VirtualRegister r2, string type)
     : base("icmp")
 {
     this.cond = cond;
     this.r1 = r1;
     this.r2 = r2;
     this.rd = rd;
     this.type = type;
 }

 public NetObject(string ip, string dns, string name, BaseType type, int position, ConditionType state, int threadId)
 {
     _ip = ip;
         _dns = dns;
         _name = name;
         _type = type;
         _position = position;
         _state = state;
         _threadId = threadId;
 }

		public ArgumentExcludeCondition(List<Token> toks)
		{
			Token tok = toks[0];
			if (tok.Type != TokenType.Identifier)
				throw new Exception("Unknown token for argument to exclude condition!");
			ArgToExclude = Utils.SingleDigitParse(tok.Value[3]) - 1;
			if (ArgToExclude != 0)
				throw new Exception("Cannot exclude anything but the first argument!");
			tok = toks[1];
			int nextTokIdx = 2;
			switch (tok.Type)
			{
				case TokenType.LThan:
					if (toks[2].Type == TokenType.Equal)
					{
						nextTokIdx++;
						Condition = ConditionType.LessOrEqual;
					}
					else
					{
						Condition = ConditionType.Less;
					}
					break;
				case TokenType.GThan:
					if (toks[2].Type == TokenType.Equal)
					{
						nextTokIdx++;
						Condition = ConditionType.GreaterOrEqual;
					}
					else
					{
						Condition = ConditionType.Greater;
					}
					break;
				case TokenType.Equal:
					if (toks[2].Type != TokenType.Equal)
						throw new Exception("Unknown condition for an argument exclude!");
					nextTokIdx++;
					Condition = ConditionType.Equal;
					break;
				case TokenType.Exclaim:
					if (toks[2].Type != TokenType.Equal)
						throw new Exception("Unknown condition for an argument exclude!");
					nextTokIdx++;
					Condition = ConditionType.NotEqual;
					break;

				default:
					throw new Exception("Unknown condition for an argument exclude!");
			}
			tok = toks[nextTokIdx];
			if (tok.Type != TokenType.Number)
				throw new Exception("The value being compared to in an argument exclude condition must be a decimal number!");
			ConditionArg = tok.NumberValue.Value;
		}