Comment utiliser int.TryParse avec un int nullable ?

Question

J'essaie d'utiliser TryParse pour déterminer si la valeur de la chaîne de caractères est un nombre entier. Si la valeur est un entier, il faut sauter la boucle foreach. Voici mon code.

string strValue = "42 "

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

intVal est une variable de type int ?(nullable INT). Comment puis-je utiliser Tryparse avec nullable int ?

Answer 1

Voici une option pour un int nullable avec TryParse

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

Answer 2

Vous ne pouvez pas le faire sans utiliser une autre variable, malheureusement - car le type de la variable out doit correspondre exactement au paramètre.

Comme le code de Daniel, mais corrigé en ce qui concerne le deuxième argument, le trimming, et l'évitement des comparaisons avec des constantes booléennes :

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

Answer 3

Je n'ai pas pu m'empêcher de produire une version générique. Utilisation ci-dessous.

    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 4

Vous pouvez créer une méthode d'aide pour analyser une valeur nullable.

Exemple d'utilisation :

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

Méthode d'aide :

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 5

Vous pouvez également fabriquer une méthode d'extension à cette fin ;

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;
    }
}

J'en ai fait une extension sur le object mais il pourrait tout aussi bien être sur string . Personnellement, j'aime que ces extensions d'analyseur soient disponibles sur n'importe quel objet, d'où l'extension sur object au lieu de string .

Exemple d'utilisation :

[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));
}

L'inconvénient est que cela rompt avec la syntaxe des frameworks pour l'analyse des valeurs ;

int.TryParse(input, out output))

Mais j'aime bien la version abrégée (que ce soit plus lisible ou non peut être sujet à discussion) ;

input.TryParse(out output)