Numeric Inputs
This is a nobrainer, right?
Not so. Well, that's a little unfair, it is as long as you appreciate the fact that although the RadNumericInput is based on the decimal datatype the input range for this input is limited to 2^46. This limitation comes from the limited range of the JaveScript functions parseFloat and parseInt. See if you can guess whether or not my app is happy with those limits.
So, what to do?
The only thing I
could do in this case was roll my own.
Being the lazy type, I started off with a RadTextbox and built around that.
First off I added a few properties based on the double datatype. These included the actual, numeric value of the input, and a min/max value pair.
The code for setting the (decimal) value is straightforward. I think that there are a number of ways to approach this issue; I took a nice easy one  I overrode the RadInput's Text property...
public override string Text { 
get { return base.Text; } 
set { 
try {} 
Value = Convert.ToDecimal(value); 
base.Text = Value.ToString(Format); 
} 
catch (ValueOutOfRangeException ex) { 
throw ex; 
} 
catch { 
throw new Exception(String.Format("Input has a value of '{0}' which cannot be converted to a valid decimal value", value)); 
} 
} 
} 


Here 'Value' is the decimal property that holds the true value of the input. Setting the Value property could generate an ValueOutOfRangeException exception if the value is not in the range MinValue <= value <= MaxValue and so we just pass it on if it does.
I wanted to validate the numeric values clientside wherever possible, so had to write a validation routine to test the userentered value against the upper and lower limits defined for the input. Now, as I've said, there a limit on the ranges for parseInt and parseFloat that prevents the use of these JavaScript functions for doing these comparisons. I came up with a range independant method for testing a number against a limit which can be tabulated like this ...
The validity of the value against the limit is calculated as:
In both the case of Minimum and Maximum values, if value (as a string) is equal to limit (as a string) the value is valid
Against MinimumValue Against MaximumValue
limit +ve  zero  ve limit +ve  zero  ve
value value
+ve len  true  true +ve len  false  false
zero false  true  true zero true  true  false
ve false  false  len ve true  true  len
Where "len" indicates that first the length of the value as a string is compared against the length of the limit as a string. Only If the 2 lengths are the same is a characterbycharacter comparison done, starting with the Most Significant Digit.
So, my EvaluateIsValid function for my NumericInput looks like this ...
function EvaluateIsValid(val) { 
// val is the validator object. 

var minValueIsGood = false; 
var maxValueIsGood = false; 

// I've taken a bit of a liberty with this example and removed all the guff 
// of getting the actual value of input; you can assume that sval holds the 
// entered value. 

var sval; 
var limit; 
var limitIsNegative; 
var limitIsZero; 
var valueIsNegative = sval.charAt(0) == ""; 
var valueIsZero = sval == "0"; 

// First we're going to test the Minimum value... 
limit = val.minvalue; 
limitIsNegative = limit.charAt(0) == ""; 
limitIsZero = limit == "0"; 

// If both the limit and value are equal as strings then the value is inside the limit 
if (limit == sval) { 
minValueIsGood = true; 
} else { 
if(limitIsNegative) { 
if (!valueIsNegative) minValueIsGood = true; 
else minValueIsGood = CompareByLength(sval, limit); 
} else if (limitIsZero) { 
minValueIsGood = !valueIsNegative 
} else { // Limit is +ve 
if (valueIsNegative  valueIsZero) minValueIsGood = false; 
else minValueIsGood = CompareByLength(sval, limit); 
} 
} 

// Now we're going to test the Maximum value... 
limit = val.maxvalue; 
limitIsNegative = limit.charAt(0) == ""; 
limitIsZero = limit == "0"; 

// If both the limit and value are equal as strings then the value is inside the limit 
if (limit == sval) { 
maxValueIsGood = true; 
} else { 
if(limitIsZero) { 
maxValueIsGood = (valueIsZero  valueIsNegative); 
} else if (limitIsNegative) { 
if (valueIsNegative) maxValueIsGood = CompareByLength(sval, limit); 
else maxValueIsGood = false; 
} else { // Limit is +ve 
if (valueIsZero  valueIsNegative) maxValueIsGood = true; 
else maxValueIsGood = CompareByLength(sval, limit); 
} 
} 
} 
if (!(minValueIsGood && maxValueIsGood)) { 
input.Invalid = true; 
input.UpdateCssClass(); 
return false; 
} 
return true; 
} 


Right at the end we set the Invalid property of the input and tell system to update the input's css class.
The function CompareByLength is simply this ...
function CompareByLength(value, limit) { 
// This function is only ever called for number of the same sign, so we 
// we only ever have to test to see if the ABSOLUTE value of the limit is > 
// the ABSOLUTE value of the number. 
for(var i=0; i<value.length; i++) { 
if(limit.substring(i, 0) > value.substring(i, 0)) return false; 
} 
return true; 
} 
So, there you go a numeric input that /isn't/ limited to the +/ 2^46 range that the standard control is.
Maybe this is useful to you. Maybe not.

Stuart