Comment mieux initialiser le type nullable de non-nullable?

Question

Mes objets ont souvent des propriétés de type nullable utilisées comme paramètres de commandes SQL.

J'initialisez façon suivante:

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; 

Comment puis-je réécrire ce code d'initialisation pour le rendre plus court ou plus ?

Answer 1

J'aime peu rewrite peu de Randolpho et le code de Marc:

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

Answer 2

1) Plus court! = Plus rapide. Important à noter.

2) Cela fonctionne aussi bien:

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

Answer 3

Tout d'abord, ne font pas cela; vous laissez tomber silencieusement le fait que vous ne pouvez pas analyser les données! Mieux vaut lancer une exception dans ce cas, ou gérer scénarios prévus (null, par exemple).

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

Answer 4

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

Performance ne va pas vraiment changer, mais si vous voulez vraiment optimiser, alors vous devez penser à ce qui est le plus courant, si les valeurs sont presque toujours ints valides, alors mon approche est probablement le meilleur, sinon votre approche est la meilleure.

Answer 5

À moins que votre interlocuteur exige une Nullable<T>, je suggère d'utiliser un type comme:

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

Cela permettrait:

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

Avec Int32, l'effort supplémentaire de typecasting probab Ce n'est pas trop un problème, mais avec des types plus grands, cela pourrait être plus important.