C# IConvertible类代码示例

 private void SetOperand(IConvertible operand)
 {
     switch (Instruction)
     {
         case BFInstruction.SetVariable:
         case BFInstruction.PushVariable:
         case BFInstruction.PushUInt16:
         case BFInstruction.JumpIfFalse:
         case BFInstruction.Jump:
         case BFInstruction.CallProcedure:
         case BFInstruction.CallNative:
         case BFInstruction.BeginProcedure:
         case BFInstruction.PushUInt32:
             if (operand == null)
                 throw new ArgumentException("You must specify 1 operand for this instruction.");
             _operand = new BFOperand(Convert.ToInt64(operand));
             break;
         case BFInstruction.PushFloat:
             if (operand == null)
                 throw new ArgumentException("You must specify 1 operand for this instruction.");
             _operand = new BFOperand(Convert.ToSingle(operand));
             break;
         default:
             if (operand != null)
                 _operand = new BFOperand(Convert.ToInt64(operand));
             break;
     }
 }

        protected override IConvertible DoBinOp(IConvertible left, IConvertible right)
        {
            Boolean left1 = Convert.ToBoolean(left);
            Boolean right1 = Convert.ToBoolean(right);

            return left1 && right1;
        }

 protected SpriteKernel(IConvertible initialVersion)
 {
     SourceList = new Dictionary<IConvertible, SpriteSource>();
     Animation = new PeriodicFunction<SpriteTransformation>(stage => new SpriteTransformation(0));
     RegisteredVersion = new Collection<IConvertible>();
     Version = initialVersion;
 }

        protected override IConvertible GetValue()
        {
           // if (!isGotValue)
           // {
                if (OnGetValue == null)
                {
                    throw new InvalidOperationException("This variable is not bound to a formula, so it's value cannot be read.");
                }
                VariableReadEventArgs args = new VariableReadEventArgs(Name);
                args.Type = Type;
                OnGetValue(this, args);

                if (Type != typeof(IConvertible))
                {
                    _Value = (IConvertible)Convert.ChangeType(args.Value, Type);
                }
                else
                {
                    _Value = args.Value;
                }
              //  isGotValue = true;
         //   }
            return _Value;
            
        }

 public ValueCell(StructField def, IConvertible value, string displayValue, int offset)
     : base(def)
 {
     _value = value;
     _displayValue = displayValue;
     _offset = offset;
 }

 public override string AddNumber(IConvertible number, IList<DbParameter> parameters)
 {
     if (number == null)
     {
         throw new ArgumentNullException("number");
     }
     return number.ToString();
 }

 public ProxyNumber( IConvertible value )
 {
     if (value is string)
     {
         this.value = Parse( value as string );
     }
     else
     {
         this.value = value;
     }
 }

        protected override IConvertible DoBinOp(IConvertible left, IConvertible right)
        {
            IComparable left1 = (IComparable)left;
            IComparable right1 = (IComparable)right;

            if (left1.CompareTo(right1) > 0)
            {
                return true;
            }
            return false;
        }

 public Tokenizer Ignore(int priority, IConvertible tokenName, String tokenRegex)
 {
     try {
         Regex.Replace("", tokenRegex, "");
         tokenPriorities[tokenName] = priority;
         tokens[tokenName] = new Regex("^" + tokenRegex + "$");
         ignore[tokenName] = true;
     } catch (Exception e) {
         throw (e);
     }
     return (this);
 }

 private static object AddDecimal(IConvertible Left, IConvertible Right)
 {
     decimal num = Left.ToDecimal(null);
     decimal num2 = Right.ToDecimal(null);
     try
     {
         return decimal.Add(num, num2);
     }
     catch (OverflowException)
     {
         return (Convert.ToDouble(num) + Convert.ToDouble(num2));
     }
 }

        /// <summary>
        /// Set one or more properties for the set of matched elements.
        /// </summary>
        ///
        /// <param name="name">
        /// The property to set
        /// </param>
        /// <param name="value">
        /// The value
        /// </param>
        ///
        /// <returns>
        /// The current CQ object
        /// </returns>

        public CQ Prop(string name, IConvertible value)
        {
            // Prop actually works on things other than boolean - e.g. SelectedIndex. For now though only use prop for booleans

            if (HtmlData.IsBoolean(name))
            {
                SetProp(name, value);
            }
            else
            {
                Attr(name, value);
            }
            return this;
        }

 public DateTimeFormatPartOptionTO(int length, Func<string, bool, bool> predicate, bool isNumeric,
     IConvertible actualValue, Action<IDateTimeResultTO, bool, IConvertible> assignAction, int resultLength = -1)
 {
     Length = length;
     Predicate = predicate;
     IsNumeric = isNumeric;
     ActualValue = actualValue;
     AssignAction = assignAction;
     if (resultLength == -1)
     {
         ResultLength = Length;
     }
     else
     {
         ResultLength = resultLength;
     }
 }

 private static object AddDecimal(IConvertible conv1, IConvertible conv2)
 {
     decimal num;
     if (conv1 != null)
     {
         num = conv1.ToDecimal(null);
     }
     decimal num2 = conv2.ToDecimal(null);
     try
     {
         return decimal.Add(num, num2);
     }
     catch (OverflowException)
     {
         return (Convert.ToDouble(num) + Convert.ToDouble(num2));
     }
 }

		public override object Eval (DataRow row)
		{
			//TODO: implement a better caching strategy and a mechanism for cache invalidation.
			//for now only aggregation over the table owning 'row' (e.g. 'sum(parts)'
			//in constrast to 'sum(parent.parts)' and 'sum(child.parts)') is cached.
			if (cacheResults && result != null && column.ReferencedTable == ReferencedTable.Self)
				return result;
				
			count = 0;
			result = null;
			
			object[] values;
			if (rows == null)
				values = column.GetValues (column.GetReferencedRows (row));
			else
				values = column.GetValues (rows);
			
			foreach (object val in values) {
				if (val == null)
					continue;
					
				count++;
				Aggregate ((IConvertible)val);
			}
			
			switch (function) {
			case AggregationFunction.StDev:
			case AggregationFunction.Var:
				result = CalcStatisticalFunction (values);
				break;
					
			case AggregationFunction.Avg:
				result = Numeric.Divide (result, count);
				break;
			
			case AggregationFunction.Count:
				result = count;
				break;
			}
			
			if (result == null)
				result = DBNull.Value;
				
			return result;
		}

        public void SetProperty(string property, IConvertible prop_val)
        {
            PropertyInfo prop_info = item.GetType ().GetProperty (property);

            if (prop_info == null)
                throw new ApplicationException (String.Format (
                    "Unable to set property {0}.{1} to \"{2}\"",
                    item.GetType (), property, prop_val));

            Type prop_type = prop_info.PropertyType;
            object param;

            try {
                param = prop_val.ToType (prop_type, NumberFormatInfo.InvariantInfo);
            } catch (FormatException e) {
                throw new ApplicationException (String.Format (
                    "prop_val cannot be converted to a {0}", prop_type), e);
            }

            prop_info.SetValue (item, param, null);
        }