Come utilizzare int.TryParse con int nullo?

Question

Sto cercando di utilizzare TryParse per trovare se il valore stringa è un numero intero. Se il valore è un numero intero, salta il ciclo foreach. Ecco il mio codice.

string strValue = "42 " 

if (int.TryParse(trim(strValue) , intVal)) == false 
{ 
    break; 
} 

intVal è una variabile di tipo int? (Nullable INT). Come posso usare Tryparse con nullable int?

Answer 1

Purtroppo non è possibile farlo senza utilizzare un'altra variabile, perché il tipo di argomenti out deve corrispondere esattamente al parametro.

Come il codice di Daniel, ma fissa in termini di secondo argomento, rifilatura, ed evitando il confronto con costanti booleane:

int tmp; 
if (!int.TryParse(strValue.Trim(), out tmp)) 
{ 
    break; 
} 
intVal = tmp; 

Answer 2

è possibile creare un metodo di supporto per analizzare un valore nullable.

Esempio di utilizzo:

int? intVal; 
if(!NullableInt.TryParse("42", out intVal)) 
{ 
    break; 
} 

Helper Metodo:

public static class NullableInt 
{ 
    public static bool TryParse(string text, out int? outValue) 
    { 
     int parsedValue; 
     bool success = int.TryParse(text, out parsedValue); 
     outValue = success ? (int?)parsedValue : null; 
     return success; 
    } 
} 

Answer 3

Ecco un'opzione per un int nullable con TryParse

public int? TryParseNullable(string val) 
{ 
    int outValue; 
    return int.TryParse(val, out outValue) ? (int?)outValue : null; 
} 

Answer 4

non poteva impedire a me stesso di produrre una versione generica. Uso di seguito.

public class NullableHelper 
    { 
     public delegate bool TryDelegate<T>(string s, out T result); 

     public static bool TryParseNullable<T>(string s, out T? result, TryDelegate<T> tryDelegate) where T : struct 
     { 
      if (s == null) 
      { 
       result = null; 
       return true; 
      } 

      T temp; 
      bool success = tryDelegate(s, out temp); 
      result = temp; 
      return success; 
     } 

     public static T? ParseNullable<T>(string s, TryDelegate<T> tryDelegate) where T : struct 
     { 
      if (s == null) 
      { 
       return null; 
      } 

      T temp; 
      return tryDelegate(s, out temp) 
         ? (T?)temp 
         : null; 
     } 
    } 


bool? answer = NullableHelper.ParseNullable<bool>(answerAsString, Boolean.TryParse); 

Answer 5

È anche possibile creare un metodo di estensione per questo scopo;

public static bool TryParse(this object value, out int? parsed) 
{ 
    parsed = null; 
    try 
    { 
     if (value == null) 
      return true; 

     int parsedValue; 
     parsed = int.TryParse(value.ToString(), out parsedValue) ? (int?)parsedValue : null; 
     return true; 
    } 
    catch (Exception) 
    { 
     return false; 
    } 
} 

Ho fatto questo un'estensione del tipo object, ma si potrebbe anche su string. Personalmente mi piace che queste estensioni parser siano disponibili su qualsiasi oggetto, quindi l'estensione su object anziché string.

Esempio di utilizzo:

[TestCase("1", 1)] 
[TestCase("0", 0)] 
[TestCase("-1", -1)] 
[TestCase("2147483647", int.MaxValue)] 
[TestCase("2147483648", null)] 
[TestCase("-2147483648", int.MinValue)] 
[TestCase("-2147483649", null)] 
[TestCase("1.2", null)] 
[TestCase("1 1", null)] 
[TestCase("", null)] 
[TestCase(null, null)] 
[TestCase("not an int value", null)] 
public void Should_parse_input_as_nullable_int(object input, int? expectedResult) 
{ 
    int? parsedValue; 

    bool parsingWasSuccessfull = input.TryParse(out parsedValue); 

    Assert.That(parsingWasSuccessfull); 
    Assert.That(parsedValue, Is.EqualTo(expectedResult)); 
} 

Lo svantaggio è che questo rompe con la sintassi quadri per l'analisi dei valori;

int.TryParse(input, out output)) 

ma mi piace la versione più corta di esso (se è più leggibile o non potrebbe essere oggetto di discussione);

input.TryParse(out output)