Como analisar uma string em um int nulo

Eu estou querendo analisar uma seqüência de caracteres em um int anulável em c #. ie Eu quero voltar o valor int da string ou null se não puder ser analisado.

Eu meio que esperava que isso funcionasse

int? val = stringVal as int?;

Mas isso não vai funcionar, então o jeito que eu estou fazendo isso agora é que eu escrevi esse método de extensão

public static int? ParseNullableInt(this string value)
{
    if (value == null || value.Trim() == string.Empty)
    {
        return null;
    }
    else
    {
        try
        {
            return int.Parse(value);
        }
        catch
        {
            return null;
        }
    }
}   

Existe um jeito melhor de fazer isso?

Edição: Obrigado pelas sugestões TryParse, eu sabia sobre isso, mas funcionou sobre o mesmo. Estou mais interessado em saber se existe um método de estrutura interno que será analisado diretamente em um int nulo?

int.TryParse é provavelmente um pouco mais fácil:

public static int? ToNullableInt(this string s)
{
    int i;
    if (int.TryParse(s, out i)) return i;
    return null;
}

Editar @Glenn int.TryParseé "incorporado à estrutura". É e int.Parseé o caminho para analisar cadeias de caracteres para ints.

Você pode fazer isso em uma linha, usando o operador condicional e o fato de poder converter nullpara um tipo nulo (duas linhas, se você não tiver um int pré-existente, poderá reutilizar para a saída de TryParse):

Pré C # 7:

int tempVal;
int? val = Int32.TryParse(stringVal, out tempVal) ? Int32.Parse(stringVal) : (int?)null;

Com a sintaxe atualizada do C # 7 que permite declarar uma variável de saída na chamada de método, isso fica ainda mais simples.

int? val = Int32.TryParse(stringVal, out var tempVal) ? tempVal : (int?)null;

[ Atualizado para usar o C # moderno conforme a sugestão do @ sblom]

Eu tive esse problema e acabei com isso (afinal, an ife 2 returns são muito longos!):

int? ToNullableInt (string val)
    => int.TryParse (val, out var i) ? (int?) i : null;

Em uma observação mais séria, tente não misturar int, que é uma palavra-chave C #, com Int32, que é do tipo .NET Framework BCL - embora funcione, apenas torna o código confuso.

Glenn Slaven : Estou mais interessado em saber se existe um método de estrutura interno que será analisado diretamente em um int nulo?

Existe essa abordagem que analisará diretamente um int nulo (e não apenas int) se o valor for válido como uma seqüência nula ou vazia, mas lança uma exceção para valores inválidos, portanto você precisará capturar a exceção e retornar o valor padrão para essas situações:

public static T Parse<T>(object value)
{
    try { return (T)System.ComponentModel.TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value.ToString()); }
    catch { return default(T); }
}

Essa abordagem ainda pode ser usada para análises não anuláveis ​​e anuláveis:

enum Fruit { Orange, Apple }
var res1 = Parse<Fruit>("Apple");
var res2 = Parse<Fruit?>("Banana");
var res3 = Parse<int?>("100") ?? 5; //use this for non-zero default
var res4 = Parse<Unit>("45%");

Nota: existe um método IsValid no conversor que você pode usar em vez de capturar a exceção (exceções lançadas resultam em sobrecarga desnecessária, se esperado). Infelizmente, ele só funciona desde o .NET 4, mas ainda existe um problema em que ele não verifica seu código do idioma ao validar os formatos corretos de DateTime, veja o bug 93559 .

var result = int.TryParse(foo, out var f) ? f : default(int?);

Fontes:

• Var
• Int32.TryParse
• operador condicional
• operador padrão (explicado nesta postagem do stackoverflow).
• tipo de valor anulável

Tópico antigo, mas que tal:

public static int? ParseToNullableInt(this string value)
{
     return String.IsNullOrEmpty(value) ? null : (int.Parse(value) as int?);
}

Eu gosto mais disso como o requisito de analisar nulo, a versão TryParse não geraria um erro, por exemplo, em ToNullableInt32 (XXX). Isso pode introduzir erros silenciosos indesejados.

Tente o seguinte:

public static int? ParseNullableInt(this string value)
{
    int intValue;
    if (int.TryParse(value, out intValue))
        return intValue;
    return null;
}

Sinto que minha solução é uma solução muito limpa e agradável:

public static T? NullableParse<T>(string s) where T : struct
{
    try
    {
        return (T)typeof(T).GetMethod("Parse", new[] {typeof(string)}).Invoke(null, new[] { s });
    }
    catch (Exception)
    {
        return null;
    }
}

Obviamente, essa é uma solução genérica que exige apenas que o argumento genérico tenha um método estático "Parse (string)". Isso funciona para números, booleano, DateTime etc.

Você pode esquecer todas as outras respostas - existe uma ótima solução genérica: http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/

Isso permite que você escreva um código muito limpo como este:

string value = null;
int? x = value.ConvertOrDefault();

e também:

object obj = 1;  

string value = null;
int x = 5;
if (value.TryConvert(out x))
    Console.WriteLine("TryConvert example: " + x); 

bool boolean = "false".ConvertOrDefault();
bool? nullableBoolean = "".ConvertOrDefault();
int integer = obj.ConvertOrDefault();
int negativeInteger = "-12123".ConvertOrDefault();
int? nullableInteger = value.ConvertOrDefault();
MyEnum enumValue = "SecondValue".ConvertOrDefault();

MyObjectBase myObject = new MyObjectClassA();
MyObjectClassA myObjectClassA = myObject.ConvertOrDefault();

O seguinte deve funcionar para qualquer tipo de estrutura. É baseado no código de Matt Manela nos fóruns do MSDN . Como Murph aponta, o tratamento de exceções pode ser caro comparado ao uso do método TryParse de Tipos dedicado.

        public static bool TryParseStruct<T>(this string value, out Nullable<T> result)
            where T: struct 
        {
            if (string.IsNullOrEmpty(value))
            {
                result = new Nullable<T>();

                return true;
            }

            result = default(T);
            try
            {
                IConvertible convertibleString = (IConvertible)value;
                result = new Nullable<T>((T)convertibleString.ToType(typeof(T), System.Globalization.CultureInfo.CurrentCulture));
            }
            catch(InvalidCastException)
            {
                return false;
            }
            catch (FormatException)
            {
                return false;
            }

           return true;
        }

Esses foram os casos de teste básicos que eu usei.

        string parseOne = "1";
        int? resultOne;
        bool successOne = parseOne.TryParseStruct<int>(out resultOne);
        Assert.IsTrue(successOne);
        Assert.AreEqual(1, resultOne);

        string parseEmpty = string.Empty;
        int? resultEmpty;
        bool successEmpty = parseEmpty.TryParseStruct<int>(out resultEmpty);
        Assert.IsTrue(successEmpty);
        Assert.IsFalse(resultEmpty.HasValue);

        string parseNull = null;
        int? resultNull;
        bool successNull = parseNull.TryParseStruct<int>(out resultNull);
        Assert.IsTrue(successNull);
        Assert.IsFalse(resultNull.HasValue);

        string parseInvalid = "FooBar";
        int? resultInvalid;
        bool successInvalid = parseInvalid.TryParseStruct<int>(out resultInvalid);
        Assert.IsFalse(successInvalid);

Eu sugeriria os seguintes métodos de extensão para análise de string no valor int com capacidade de definir o valor padrão, caso a análise não seja possível:

public static int ParseInt(this string value, int defaultIntValue = 0)
        {
            return int.TryParse(value, out var parsedInt) ? parsedInt : defaultIntValue;
        }

public static int? ParseNullableInt(this string value)
        {
            if (string.IsNullOrEmpty(value))
                return null;

            return value.ParseInt();
        }

Esta solução é genérica sem sobrecarga de reflexão.

public static Nullable<T> ParseNullable<T>(string s, Func<string, T> parser) where T : struct
{
    if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(s.Trim())) return null;
    else return parser(s);
}

static void Main(string[] args)
{
    Nullable<int> i = ParseNullable("-1", int.Parse);
    Nullable<float> dt = ParseNullable("3.14", float.Parse);
}

Estou mais interessado em saber se existe um método de estrutura interno que será analisado diretamente em um int nulo?

Não existe.

Eu senti que deveria compartilhar o meu, que é um pouco mais genérico.

Uso:

var result = "123".ParseBy(int.Parse);

var result2 = "123".ParseBy<int>(int.TryParse);

Solução:

public static class NullableParse
{
    public static Nullable<T> ParseBy<T>(this string input, Func<string, T> parser)
        where T : struct
    {
        try
        {
            return parser(input);
        }
        catch (Exception exc)
        {
            return null;
        }
    }

    public delegate bool TryParseDelegate<T>(string input, out T result);

    public static Nullable<T> ParseBy<T>(this string input, TryParseDelegate<T> parser)
        where T : struct
    {
        T t;
        if (parser(input, out t)) return t;
        return null;
    }
}

A primeira versão é mais lenta, pois requer uma tentativa de captura, mas parece mais limpa. Se não for chamado muitas vezes com cadeias inválidas, isso não é importante. Se o desempenho for um problema, observe que, ao usar os métodos TryParse, você precisa especificar o parâmetro type de ParseBy, pois não pode ser inferido pelo compilador. Também tive que definir um delegado como a palavra-chave out não pode ser usada no Func <>, mas pelo menos desta vez o compilador não requer uma instância explícita.

Finalmente, você pode usá-lo com outras estruturas, como decimal, DateTime, Guid, etc.

Encontrei e adaptei algum código para uma classe NullableParser genérica. O código completo está no meu blog Nullable TryParse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
namespace SomeNamespace
{
    /// <summary>
    /// A parser for nullable types. Will return null when parsing fails.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    ///
    public static class NullableParser<T> where T : struct
    {
        public delegate bool TryParseDelegate(string s, out T result);
        /// <summary>
        /// A generic Nullable Parser. Supports parsing of all types that implements the tryParse method;
        /// </summary>
        /// <param name="text">Text to be parsed</param>
        /// <param name="result">Value is true for parse succeeded</param>
        /// <returns>bool</returns>
        public static bool TryParse(string s, out Nullable<T> result)
        {
            bool success = false;
            try
            {
                if (string.IsNullOrEmpty(s))
                {
                    result = null;
                    success = true;
                }
                else
                {
                    IConvertible convertableString = s as IConvertible;
                    if (convertableString != null)
                    {
                        result = new Nullable<T>((T)convertableString.ToType(typeof(T),
                            CultureInfo.CurrentCulture));
                        success = true;
                    }
                    else
                    {
                        success = false;
                        result = null;
                    }
                }
            }
            catch
            {
                success = false;
                result = null;
            }
            return success;
        }
    }
}

    public static void Main(string[] args)
    {

        var myString = "abc";

        int? myInt = ParseOnlyInt(myString);
        // null

        myString = "1234";

        myInt = ParseOnlyInt(myString);
        // 1234
    }
    private static int? ParseOnlyInt(string s)
    {
        return int.TryParse(s, out var i) ? i : (int?)null;
    }

Você nunca deve usar uma exceção se não precisar - a sobrecarga é horrível.

As variações no TryParse resolvem o problema - se você quiser ser criativo (para tornar seu código mais elegante), provavelmente poderá fazer algo com um método de extensão na versão 3.5, mas o código será mais ou menos o mesmo.

Usando delegados, o código a seguir poderá fornecer reutilização se você precisar da análise anulável para mais de um tipo de estrutura. Eu mostrei as versões .Parse () e .TryParse () aqui.

Este é um exemplo de uso:

NullableParser.TryParseInt(ViewState["Id"] as string);

E aqui está o código que leva você até lá ...

public class NullableParser
  {
    public delegate T ParseDelegate<T>(string input) where T : struct;
    public delegate bool TryParseDelegate<T>(string input, out T outtie) where T : struct;
    private static T? Parse<T>(string input, ParseDelegate<T> DelegateTheParse) where T : struct
    {
      if (string.IsNullOrEmpty(input)) return null;
      return DelegateTheParse(input);
    }
    private static T? TryParse<T>(string input, TryParseDelegate<T> DelegateTheTryParse) where T : struct
    {
      T x;
      if (DelegateTheTryParse(input, out x)) return x;
      return null;
    }
    public static int? ParseInt(string input)
    {
      return Parse<int>(input, new ParseDelegate<int>(int.Parse));
    }
    public static int? TryParseInt(string input)
    {
      return TryParse<int>(input, new TryParseDelegate<int>(int.TryParse));
    }
    public static bool? TryParseBool(string input)
    {
      return TryParse<bool>(input, new TryParseDelegate<bool>(bool.TryParse));
    }
    public static DateTime? TryParseDateTime(string input)
    {
      return TryParse<DateTime>(input, new TryParseDelegate<DateTime>(DateTime.TryParse));
    }
  }

Sei que esse é um tópico antigo, mas você não pode simplesmente:

(Nullable<int>)int.Parse(stringVal);

?

Eu criei este, que atendeu aos meus requisitos (eu queria que meu método de extensão emulasse o mais próximo possível do retorno do TryParse da estrutura, mas sem os blocos try {} catch {} e sem o compilador reclamar tipo anulável dentro do método de estrutura)

private static bool TryParseNullableInt(this string s, out int? result)
{
    int i;
    result = int.TryParse(s, out i) ? (int?)i : null;
    return result != null;
}

Eu sugiro o código abaixo. Você pode trabalhar com exceção, quando ocorreu um erro de conversão.

public static class Utils {      
public static bool TryParse<Tin, Tout>(this Tin obj, Func<Tin, Tout> onConvert, Action<Tout> onFill, Action<Exception> onError) {
  Tout value = default(Tout);
  bool ret = true;
  try {
    value = onConvert(obj);
  }
  catch (Exception exc) {
    onError(exc);
    ret = false;
  }
  if (ret)
    onFill(value);
  return ret;
}

public static bool TryParse(this string str, Action<int?> onFill, Action<Exception> onError) {
  return Utils.TryParse(str
    , s => string.IsNullOrEmpty(s) ? null : (int?)int.Parse(s)
    , onFill
    , onError);
}
public static bool TryParse(this string str, Action<int> onFill, Action<Exception> onError) {
  return Utils.TryParse(str
    , s => int.Parse(s)
    , onFill
    , onError);
}
}

Use este método de extensão no código (fill int? Age propriedade de uma classe de pessoa):

string ageStr = AgeTextBox.Text;
Utils.TryParse(ageStr, i => person.Age = i, exc => { MessageBox.Show(exc.Message); });

OU

AgeTextBox.Text.TryParse(i => person.Age = i, exc => { MessageBox.Show(exc.Message); });