如何更好地从非可空类型初始化可空类型？

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

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 2

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 3

Unless your caller demands a Nullable<T> , I'd suggest using a type like:

struct MaybeValid<T>
{
    public bool IsValid;
    public T Value;
}

That would allow:

Public MaybeValid<int> Amount
{
    Amount.Value = Int32.TryParse(out Amount.IsValid);
}

With Int32 , the extra typecasting effort probably isn't too much of an issue, but with larger types, it could be more significant.

Answer 4

我喜欢重写Randolpho和Marc的代码：

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

Answer 5

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.