web-dev-qa-db-fra.com

sucre syntaxique int.TryParse

int.TryPrase est génial et tout, mais il n'y a qu'un seul problème ... il faut au moins deux lignes de code pour utiliser:

int intValue;
string stringValue = "123";
int.TryParse(stringValue, out intValue);
....

Bien sûr, je peux faire quelque chose comme:

string stringValue = "123";
int intValue = Convert.ToInt32(string.IsNullOrWhiteSpace(stringValue) ? 0 : stringValue);

sur une seule ligne de code.

Comment puis-je effectuer un peu de magie pour obtenir int.TryParse d'utiliser un one liner, ou est-il encore une troisième alternative?

Merci!

Bezden a mieux répondu à la question, mais en réalité, je prévois d’utiliser la solution Reddogs.

c#asp.net.net-4.0
39
O.O
int intValue = int.TryParse(stringValue, out intValue) ? intValue : 0;
61
Vlad Bezden

Peut-être utiliser une méthode d'extension:

public static class StringExtensions
{
    public static int TryParse(this string input, int valueIfNotConverted)
    {
        int value;
        if (Int32.TryParse(input, out value))
        {
            return value;
        }
        return valueIfNotConverted;
    }
}

Et utilisation:

string x = "1234";
int value = x.TryParse(0);

Edit : Et bien sûr, vous pouvez ajouter la surcharge évidente qui définit déjà la valeur par défaut à zéro si tel est votre souhait.

38
Reddog

Cette réponse s’adresse uniquement à ceux qui utilisent au moins C # 7 .

Vous pouvez maintenant déclarer le paramètre out inline. 

int.TryParse("123", out var result);

Pour prouver que cela fonctionne, vous pouvez exécuter après dotnetfiddle.

int.TryParse("123", out var result);
Console.WriteLine(result);
Console.WriteLine(result.GetType());

https://dotnetfiddle.net/nn9955

7
Daniel Ziegler

Je créerais une méthode d'extension à partir de cela.

    public static int? AsInt32(this string s)
    {
        int value;
        if (int.TryParse(s, out value))
            return value;

        return null;
    }
3
andleer

Je ne pense pas qu'il y ait quoi que ce soit de vraiment beau, mais si vous aimez ça, réduisez-le à une rangée:

string stringValue = "123"
int intValue = int.TryParse(stringValue, out intValue) ? intValue : 0;
1
Tomas Jansson

Découvrez la StringExtensions class. Il contient une méthode AsInt (String, Int32) extension qui tentera de convertir une chaîne et, en cas d'échec, la remplira avec la valeur Int32 fournie par défaut.

Exemple:

var intValue = "123".AsInt(-1);
1
CheckRaise
int val2 = "asd".AsInt(-1); 
//Output : -1
 int val3 = "123".AsInt(-1); 
//Output : 123

Vous devez disposer d'un espace de noms System.Web.WebPages.

0
CodePunk

Vous NE VOULEZ PAS faire int.TryParse () une ligne. Pourquoi? Parce que vous ne pouvez pas affecter intValue si la chaîne d'entrée n'est pas un entier valide. TryParse () a pour objectif essentiel de vous permettre de tester une bonne entrée et de la dégrader avec élégance, plutôt que de devoir intercepter une exception. 

Int.TryParse () est déjà un raccourci, vous n'avez donc pas besoin de rechercher un int valide ni de faire l'affectation en deux étapes ... c'est ce que vous voulez.

0
James King

Comme il renvoie essentiellement deux valeurs (success et value), nous avons vraiment besoin des deux lignes.

Vous pouvez essayer une classe de wrapper, à savoir:

void Main()
{
    var result = simpleIntParser.TryParse("1");
    if(result)
    {
        Console.WriteLine((int)result);
    } else {
        Console.WriteLine("Failed");
    }

    result = simpleIntParser.TryParse("a");
    if(result)
    {
        Console.WriteLine((int)result);
    } else {
        Console.WriteLine("Failed");
    }


}

public class simpleIntParser
{
    public bool result {get; private set;}
    public int value {get; private set;}

    private simpleIntParser(bool result, int value)
    {
        this.result = result;
        this.value = value;
    }

    public static simpleIntParser TryParse(String strValue)
    {
        int value;
        var result = int.TryParse(strValue, out value);
        return new simpleIntParser(result, value);
    }

    public static implicit operator int(simpleIntParser m)
    {
        return m.value;
    }

    public static implicit operator bool(simpleIntParser m)
    {
        return m.result;
    }
}

Elle nécessite un transtypage si le type est ambigu (c'est-à-dire pour Console.WriteLine ()), mais si vous le transmettez sous la forme d'un paramètre entier par exemple, aucun transtypage n'est requis.

0
Rob