我想将字符串解析为C＃中的可为null的int。 IE。我想找回字符串的int值，如果无法解析，则返回null。

我有点希望这能奏效

int? val = stringVal as int?;

但这是行不通的，所以我现在的方式是编写此扩展方法

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

有更好的方法吗？

编辑：感谢TryParse的建议，我确实知道这一点，但效果差不多。我更想知道是否有内置的框架方法可以直接解析为可为null的int？

解决方案

回答

int.TryParse可能更容易一些：

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

编辑@Glennint.TryParse是"内置到框架中"。它和int.Parse是将字符串解析为int的方法。

回答

试试这个：

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

回答

我们可以使用条件运算符，并且可以将null强制转换为可为null的类型(两行，如果我们没有预先存在的int，则可以将其重用为TryParse的输出) `)：

C＃7之前的版本：

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

使用C＃7更新的语法，该语法允许我们在方法调用中声明输出变量，这变得更加简单。

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

回答

如果不必让开销太可怕，则永远不要使用异常。

如果我们想发挥创造力(使代码看起来更优雅)，TryParse上的变体解决了该问题，我们可以使用3.5中的扩展方法来做一些事情，但是代码或者多或者少是相同的。

回答

抱歉，无法抗拒遇到了这个问题，Google将我带到了这里，但是我最终想到了这一点(毕竟，if和2的回报太长了！)：

int? ParseNInt (string val)
{
    int i;
    return int.TryParse (val, out i) ? (int?) i : null;
}

更严重的是，请尝试不要将int(它是一个Ckeyword)与Int32(这是一个.NET Framework BCL类型)混合使用，尽管它可以工作，但只会使代码看起来混乱。

回答

I'm more interested in knowing if there is a built-in framework method that will parse directly into a nullable int?

没有。

回答

使用委托，如果发现自己需要多个结构类型的可空分析，则以下代码可以提供可重用性。我在这里显示了.Parse()和.TryParse()版本。

这是一个示例用法：

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

这是让我们到达那里的代码...

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

回答

我为Generic NullableParser类找到并改编了一些代码。完整的代码在我的博客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;
        }
    }
}

回答

我意识到这是一个古老的话题，但是我们不能简单地：

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

？

回答

以下内容适用于任何结构类型。它基于MSDN论坛中Matt Manela的代码。正如Murph所指出的，与使用Types专用的TryParse方法相比，异常处理可能会很昂贵。

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

这些是我使用的基本测试用例。

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