Use "as" operator to test integer type in Page.RouteData.Values

Question

In my code I have registered route in global.asax like the following:

void RegisterRoutes(RouteCollection routes)
{
   routes.MapPageRoute(
    "product",
    "product/{id}",
    "~/index.aspx"
);

then in my index.aspx page, I want to test the {id} value whether it is integer:

if (Page.RouteData.Values["id"] as int? != null)   
//always evaluate as null even id is an integer in the URL, ex: /product/1

I understand I can use some other methods (such as int.TryParse or this ) to achieve the same goal, but would using a "as" make sense in this case?

Answer 1

The way to go depends on what is really stored in Values["id"]. If it is in fact an int, you can test for int with Values["id"] is int. The Values[] property is typed as object. Therefore it can be null. But this does NOT mean, that the stored int is a Nullable<int>. (see my update below.)

If you assign an int (and all other non-reference types) to an object variable or property, it will be boxed. I.e. it will be packed into an object of the corresponding type. int or System.Int32 exists as value type as well as a boxed and immutable System.Int32 reference type. Because of its immutability, you don't notice that it is a reference type. An int can be boxed with object obj = 5; and unboxed with int i = (int)obj;.

On the other hand, if the id was stored as string then you would have to convert it to a number

int id;
if (Int32.TryParse((string)Page.RouteData.Values["id"], out id)) {
    // use id here
}

---

UPDATE:

There seems to be some confusion with null and Nullable<T>.

int? i; // Same as Nullable<int> or Nullable<System.Int32> or System.Int32?
object obj;
bool test;

i = null;
test = i.HasValue; // ==> false
test = i == null;  // ==> true

// Now comes the strange part

obj = 5;           // The int is boxed here.
// Debugger shows type of obj as "object {int}"
test = obj is int;   // ==> true
test = obj is int?;   // ==> true
int x = (int)obj;  // ==> 5, the int is unboxed here.

// But

obj = null;
// Debugger shows type of obj as "object"
test = obj is int; // ==> false
test = obj is int?; // ==> false
test = obj == null; // ==> true

// And
i = 5;
obj = i; // i is a Nullable<int>
// Debugger shows type of obj as "object {int}"
test = obj is int; // ==> true
test = obj is int?; // ==> true
test = obj == null; // ==> false

i = null;
obj = i;
// Debugger shows type of obj as "object"
test = obj is int; // ==> false
test = obj is int?; // ==> false
test = obj == null; // ==> true

Both obj is int and obj is int? return true if obj contains an int number but both return false if obj contains null! A null Nullable<int> is converted to (object)null when asssigned to obj and is no more Nullable<int>.

The debugger shows the type of obj as object {int} when there is a number stored, no matter whether an int or an int? was assigned! The type of obj is object when null is stored.

So Chuong Le is in fact right!

Answer 2

I would recommend that you use Int.TryParse, because the value is most likely going to be a string. Don't use the Int.Parse because you will also have to handle the exception and you generally want to avoid coding things that could throw exceptions (even if you're handling them).

Using as is not really a good solution since it forces you to use nullable int; if you take the is route, then it's almost guaranteed not to work when the passed in value is a string type.

Regarding the is debate, I ran this in VS:

string value = "42";
object answerToUniverse = value;
if (answerToUniverse is int)
{
    Console.WriteLine("It's an integer!");
}
else
{
    Console.WriteLine("It's NOT an integer!");
}

The result was: It's NOT an integer!

Answer 3

Perhaps you actually want to do this,

var idString = Page.RouteData.Values["id"] as string;
int id;
if (int.TryParse(idString, out id))
{
   // id is now a valid number 
}
else
{
   // your types are confused
}

Answer 4

Looks like you want to check the value rather than the type meaning you don't really care what the type is.

In such case, this is the best approach I can recommend:

object idValue = Page.RouteData.Values["id"];
int dummy;
if (idValue != null && Int32.TryParse(idValue.ToString(), out dummy))
{
    //value is integer!
}

This way it doesn't matter what the type is; if it's integer, double, string or even complex type with proper ToString() override, it will work.

Answer 5

as is a safe cast. It will try and cast the provided value to the desired type, returning null instead of throwing an exception when a standard cast would.

Therefore unless Page.RouteData.Values["id"] was an integer object this would not work and you need to user the alternative methods you suggested.

One was could be to use an extension method

public static class IntExtensions {
   public static int? AsInt(this string source) {
     int result;
     return (int.TryParse(source,out result)) ? (int?)null : result;
   }

   public static bool IsInt(this string source) {
     return source.AsInt.HasValue;
   }
}

Allowing you to do

if (Page.RouteData.Values["id"].IsInt())