public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
        {
            if (!entry.Expression.Contains(","))
              {
            throw new ArgumentException("Must include two numbers separated by a comma.");
              }
              else
              {
            // get two numbers
            string[] numbers = entry.Expression.Split(',');
            if (numbers.Length != 2)
            {
              throw new ArgumentException("Only include two numbers");
            }
            else
            {
              int lowerLimit, upperLimit;
              if (Int32.TryParse(numbers[0], out lowerLimit) && Int32.TryParse(numbers[1], out upperLimit))
              {
            CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType());
            CodeExpression[] methodParameters = new CodeExpression[2];
            methodParameters[0] = new CodePrimitiveExpression(lowerLimit);
            methodParameters[1] = new CodePrimitiveExpression(upperLimit);

            return new CodeMethodInvokeExpression(typeRef, "GetRandomNumber", methodParameters);
              }
              else
              {
            throw new ArgumentException("Use valid Integers");
              }
            }
              }
        }

 public override object EvaluateExpression(object target, BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     var fields = parsedData as ResourceExpressionFields;
     EnsureResourceProviderFactory();
     IResourceProvider provider = _resourceProviderFactory.CreateGlobalResourceProvider(fields.ClassKey);
     return provider.GetObject(fields.ResourceKey, null);
 }

 public override object EvaluateExpression(object target, BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     if (target is Control)
     {
         return GetRouteValue(context.TemplateControl.Page, entry.Expression.Trim(), entry.ControlType, entry.Name);
     }
     return null;
 }

 private void AddBoundProperty(BoundPropertyEntry entry)
 {
     this.AddEntry(this.BoundPropertyEntriesInternal, entry);
     if (entry.TwoWayBound)
     {
         this.flags[0x400] = true;
     }
 }

 public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     if ((entry.DeclaringType == null) || (entry.PropertyInfo == null))
     {
         return new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetAppSetting", new CodeExpression[] { new CodePrimitiveExpression(entry.Expression.Trim()) });
     }
     return new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetAppSetting", new CodeExpression[] { new CodePrimitiveExpression(entry.Expression.Trim()), new CodeTypeOfExpression(entry.DeclaringType), new CodePrimitiveExpression(entry.PropertyInfo.Name) });
 }

        /// <summary>
        /// Gets the code expression.
        /// </summary>
        /// <param name="entry">
        /// The entry.
        /// </param>
        /// <param name="parsedData">
        /// The parsed data.
        /// </param>
        /// <param name="context">
        /// The context.
        /// </param>
        /// <returns>
        /// A CodeExpression.
        /// </returns>
        public override CodeExpression GetCodeExpression(
            BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
        {
            var typeName = BeforeLast(entry.Expression, ".");
            var propertyName = AfterLast(entry.Expression, ".");

            return new CodePrimitiveExpression(PropertyLength(typeName, propertyName));
        }

 public override CodeExpression GetCodeExpression(
     BoundPropertyEntry entry,
     object parsedData,
     ExpressionBuilderContext context)
 {
     CodeMethodInvokeExpression ex = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(ResourceReader)),
     "GetVal", new CodePrimitiveExpression(entry.Expression.ToString().Trim()));
     return ex;
 }

        public override CodeExpression GetCodeExpression(BoundPropertyEntry entry,
            object parsedData, ExpressionBuilderContext context) {

            return new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression(this.GetType()),
                "GetRouteUrl",
                new CodeThisReferenceExpression(),
                new CodePrimitiveExpression(entry.Expression.Trim()));
        }

        public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
        {
            string property = (string) parsedData;

            CodePrimitiveExpression prim = new CodePrimitiveExpression(property);
            CodeExpression[] args = new[] {prim};
            CodeTypeReferenceExpression refType = new CodeTypeReferenceExpression(this.GetType());
            return new CodeMethodInvokeExpression(refType, "GetProperty", args);
        }

 public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     ResourceExpressionFields fields = (ResourceExpressionFields) parsedData;
     if (fields.ClassKey.Length == 0)
     {
         return this.GetPageResCodeExpression(fields.ResourceKey, entry);
     }
     return this.GetAppResCodeExpression(fields.ClassKey, fields.ResourceKey, entry);
 }

        public override object EvaluateExpression(object target, BoundPropertyEntry entry,
            object parsedData, ExpressionBuilderContext context) {

            // Target should always be a control
            Control control = target as Control;
            if (control == null) 
                return null;

            return GetRouteValue(context.TemplateControl.Page, entry.Expression.Trim(), entry.ControlType, entry.Name);
        }

 /// <summary>
 /// Returns a code expression to evaluate during page execution.
 /// </summary>
 /// <param name="entry">The property name of the object.</param>
 /// <param name="parsedData">The parsed value of the expression.</param>
 /// <param name="context">Properties for the control or page.</param>
 /// <returns>A CodeExpression that invokes a method.</returns>
 public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     var lsr = (LocaleStringResource)parsedData;
     var ex = new CodeMethodInvokeExpression(
         new CodeTypeReferenceExpression(base.GetType()),
         "GetVal",
         new CodePrimitiveExpression(lsr.ResourceName)
     );
     return ex;
 }

		public override CodeExpression GetCodeExpression (BoundPropertyEntry entry, object parsedData,
								  ExpressionBuilderContext context)
		{			
			Pair connString = parsedData as Pair;
			return new CodeMethodInvokeExpression (
				new CodeTypeReferenceExpression (typeof (ConnectionStringsExpressionBuilder)),
				(bool)connString.Second ? "GetConnectionStringProviderName" : "GetConnectionString",
				new CodeExpression [] {new CodePrimitiveExpression (connString.First)}
			);
		}

 public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     Pair pair = (Pair) parsedData;
     string first = (string) pair.First;
     if ((bool) pair.Second)
     {
         return new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetConnectionString", new CodeExpression[] { new CodePrimitiveExpression(first) });
     }
     return new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetConnectionStringProviderName", new CodeExpression[] { new CodePrimitiveExpression(first) });
 }

 public override object EvaluateExpression(object target, BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     ResourceExpressionFields fields = (ResourceExpressionFields) parsedData;
     IResourceProvider resourceProvider = GetResourceProvider(fields, context.VirtualPathObject);
     if (entry.Type == typeof(string))
     {
         return GetResourceObject(resourceProvider, fields.ResourceKey, null);
     }
     return GetResourceObject(resourceProvider, fields.ResourceKey, null, entry.DeclaringType, entry.PropertyInfo.Name);
 }

		// This method is used only from within pages that aren't compiled
		public override object EvaluateExpression (object target, BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
		{
			if (entry == null)
				throw new NullReferenceException (".NET emulation (entry == null)");

			if (context == null)
				throw new NullReferenceException (".NET emulation (context == null)");
			
			return GetRouteUrl (context.TemplateControl, entry.Expression);
		}

		public override CodeExpression GetCodeExpression (BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
		{
			Type type = entry.DeclaringType;
			PropertyDescriptor descriptor = TypeDescriptor.GetProperties(type)[entry.PropertyInfo.Name];
			CodeExpression[] expressionArray = new CodeExpression[3];
			expressionArray[0] = new CodePrimitiveExpression(entry.Expression.Trim());
			expressionArray[1] = new CodeTypeOfExpression(entry.Type);
			expressionArray[2] = new CodePrimitiveExpression(entry.Name);
			return new CodeCastExpression(descriptor.PropertyType, new CodeMethodInvokeExpression(new 
								       CodeTypeReferenceExpression(base.GetType()), "GetAppSetting", expressionArray));
		}

 /// <summary>
 /// When overridden in a derived class, returns code that is used during page execution to obtain the evaluated expression.
 /// </summary>
 /// <param name="entry">The object that represents information about the property bound to by the expression.</param>
 /// <param name="parsedData">The object containing parsed data as returned by <see cref="M:System.Web.Compilation.ExpressionBuilder.ParseExpression(System.String,System.Type,System.Web.Compilation.ExpressionBuilderContext)" />.</param>
 /// <param name="context">Contextual information for the evaluation of the expression.</param>
 /// <returns>
 /// A <see cref="T:System.CodeDom.CodeExpression" /> that is used for property assignment.
 /// </returns>
 public override CodeExpression GetCodeExpression( BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context )
 {
     // from http://msdn.microsoft.com/en-us/library/system.web.compilation.expressionbuilder.getcodeexpression.aspx
     Type type1 = entry.DeclaringType;
     PropertyDescriptor descriptor1 = TypeDescriptor.GetProperties( type1 )[entry.PropertyInfo.Name];
     CodeExpression[] expressionArray1 = new CodeExpression[3];
     expressionArray1[0] = new CodePrimitiveExpression( entry.Expression.Trim() );
     expressionArray1[1] = new CodeTypeOfExpression( type1 );
     expressionArray1[2] = new CodePrimitiveExpression( entry.Name );
     return new CodeCastExpression( descriptor1.PropertyType, new CodeMethodInvokeExpression( new CodeTypeReferenceExpression( base.GetType() ), "GetEvalData", expressionArray1 ) );
 }

		public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, Object parsedData, ExpressionBuilderContext context)
		{
			if (String.IsNullOrEmpty(entry.Expression) == true)
			{
				return (new CodePrimitiveExpression(String.Empty));
			}
			else
			{
				return (new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(this.GetType()), "IsInGroup"), new CodePrimitiveExpression(entry.Expression)));
			}
		}

        internal virtual void BuildExpression(BoundPropertyEntry bpe, ControlBuilder controlBuilder,
            CodeExpression controlReference, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, ref bool hasTempObject) {

            CodeExpression codeExpression = GetCodeExpression(bpe,
                bpe.ParsedExpressionData, new ExpressionBuilderContext(controlBuilder.VirtualPath));

            CodeDomUtility.CreatePropertySetStatements(methodStatements, statements,
                controlReference, bpe.Name, bpe.Type,
                codeExpression,
                linePragma);
        }