如何将字符串解析为可空int

小开

最佳答案

int.TryParse可能更简单一点:

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

编辑 @Glenn int.TryParse“内置于框架中”。它和int.Parse是用的方法将字符串解析为int型。

小开

试试这个:

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

小开

你可以在一行中完成，使用条件操作符，并且你可以将null转换为可空类型(两行，如果你没有预先存在的int，你可以重用TryParse的输出):

前C # 7:

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

c# 7更新的语法允许你在方法调用中声明一个输出变量，这变得更加简单。

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

小开

你应该从来没有使用异常，如果你不需要-开销是可怕的。

TryParse的变体解决了这个问题——如果你想变得更有创意(让你的代码看起来更优雅)，你可以在3.5中使用扩展方法做一些事情，但代码或多或少是一样的。

小开

[更新使用现代c#根据@sblom的建议]

我遇到了这个问题，最后得到了这个(毕竟，一个if和2个returns太啰嗦了!):

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

更严肃的一点是，尽量不要把int (c#关键字)和Int32 (. net框架BCL类型)混在一起——尽管它可以工作，但它只会让代码看起来很乱。

小开

我更感兴趣的是知道是否有一个内置的框架方法，将直接解析成一个可空的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);

小开

老话题了，但下面这个话题怎么样:

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

我更喜欢这个作为解析null的需求，TryParse版本不会在例如ToNullableInt32(XXX)上抛出错误。这可能会引入不必要的静默错误。

小开

我觉得我应该分享一下我的，更普通的。

用法:

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


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

解决方案:

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

第一个版本较慢，因为它需要一个try-catch，但它看起来更干净。如果它不会被多次调用无效字符串，那么它就不那么重要了。如果性能是一个问题，请注意，当使用TryParse方法时，您需要指定ParseBy的类型参数，因为编译器不能推断它。我还必须定义一个委托，因为out关键字不能在Func<>中使用，但至少这次编译器不需要显式实例

最后，你也可以将它与其他结构体一起使用，例如decimal、DateTime、Guid等。

小开

我觉得我的解决方案是一个非常干净和漂亮的解决方案:

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

当然，这是一个通用的解决方案，只需要泛型参数有一个静态方法“Parse(string)”。这适用于数字，布尔值，日期时间等。

小开

格伦抢:我更想知道是否有一个内置的框架方法这将直接解析为 nullable int ?< / p >

如果值是有效的，如null或空字符串，则有这种方法将直接解析为可空的int(而不仅仅是int)，但对于无效值抛出异常，因此您需要捕获异常并返回这些情况的默认值:

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

这种方法仍然可以用于非空解析和可空解析:

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

注:在转换器上有一个IsValid方法，你可以使用它来代替捕获异常(如果预期抛出的异常会导致不必要的开销)。不幸的是，它只从。net 4起工作，但仍然有一个问题，即它在验证正确的DateTime格式时不检查您的地区，请参阅错误93559。

小开

你可以忘记所有其他答案-有一个很好的通用解决方案: http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/ < / p >

这可以让你写出非常干净的代码，像这样:

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

还有:

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

小开

这个解决方案是通用的，没有反射开销。

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

小开

我想出了这个方法，它满足了我的要求(我希望我的扩展方法尽可能地模拟框架的TryParse的返回，但是没有try{} catch{}块，并且没有编译器抱怨在框架方法中推断出可空类型)

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

小开

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

小开

我建议代码如下。当转换错误发生时，您可以例外地工作。

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

在代码中使用此扩展方法(fill int?一个人类的年龄属性):

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

或

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

小开

我建议以下扩展方法将字符串解析为int值，并在解析不可能的情况下定义默认值:

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

小开

c# >= 7.1

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

_{参见 c#语言版本控制以确定您的项目支持哪种语言版本}

小开

更简洁的方法是编写一个单独的函数或扩展方法，但如果你只想要一行代码:

string s;
int? i = s == null ? (int?)null : int.Parse(s);