How to better initialize nullable type from non-nullable?

Question

My objects often has nullable types properties that used as SQL commands parameters.

I initialize them next way:

public int? Amount
{
 get
 {
  int i;
  int? amount = null;
  if (Int32.TryParse(Request["amount"], out i))
  {
   amount = i;
  }
  return amount;
 }
}

command.Parameters.Add("@amount").Value = (object)this.Amount ?? DbNull.Value;

How can I rewrite such initialization code to make it shorter or faster?

Answer 1

1) Shorter != faster. Important to note.

2) This will work just as well:

public int? Amount
{
    get
    {
        int i;
        if (Int32.TryParse(Request["amount"], out i))
        {
            return i;
        }
        return null;
    }
}

Answer 2

Firstly, don't do that; you are silently dropping the fact that you can't parse the data! Better to throw an exception in this case, or handle expected scenarios (null, for example).

string val = Request["amount"];
return string.IsNullOrEmpty(val) ? (int?)null : (int?)int.Parse(val);

Answer 3

public int? Amount
{
    get
    {
         try 
         {
               return Int.Parse(Request["amount"]);
         }
          catch (exception e) 
         { 
               return null;
         }
     }
{

Performance is not really going to change, but if you really want to optimize, then you need to think about what is most common, if the values are almost always valid ints, then my approach is likely best, if not then your approach is best.

Answer 4

I like little bit rewrite of Randolpho's and Marc's code:

return Int32.TryParse(Request["amount"], out i)) ? (int?)i : (int?)null;